AI review of 2026-11-17_12-24-34-0ea5f5f44f6e-results.txt PR: #8996 https://github.com/cppcheck-opensource/cppcheck/pull/8996 Tested: 0ea5f5f44f6e92b56b87b02e7b23cf2dc4104bc3 Merge base: 275e673c62902ac61e79d4151ced6a4882e50707 Reviewed: 2026-11-19 14:53:38 UTC Model: claude-opus-5-5 (effort high) Results: 50 reviewed of 280 in the report (random sample) Verdicts: 34 improvement, 1 neutral, 14 regression, 1 unclear Tokens: 112848 input, 155720 cache read, 38930 cache write, 43674 output The verdicts are written by AI and can be wrong. ---- 1 / 50 ---- Verdict: IMPROVEMENT (low confidence) Package: https://ftp.debian.org/debian/pool/main/a/arpalert/arpalert_2.0.12.orig.tar.gz Result: your arpalert-2.0.12/loadconfig.c:527:8: style: Variable 'm_eq' can be declared as pointer to const [constVariablePointer] Explanation: In `miseenmemoire`, `m_eq` is a `char*` cursor that points to the '=' in `buf`. The visible code only reads through it: `*m_eq`, `*(m_eq-1)`, `*(m_eq+1)`. The function copies the two sides into the separate buffers `m_gauche` and `m_droite` through `g` and `d`, which suggests `buf` is not modified through `m_eq`. The PR stops treating compound assignments on the pointer itself (`m_eq += n` / `m_eq -= n`) as writes to the pointee, which is most likely why the warning now appears. If the rest of the function never writes through `m_eq`, then `const char *m_eq` is valid and this is a new true positive. Low confidence because the code after line 567 is not shown, so a later write through `m_eq` cannot be ruled out. ---- 2 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/c/caveexpress/caveexpress_2.6+ds.orig.tar.xz Result: your caveexpress-2.6/src/tools/textureatlas/external/stb_image_resize2.h:8332:19: style: Variable 'end_output' can be declared as pointer to const [constVariablePointer] Explanation: `end_output` is an `unsigned char *` derived from the writable output buffer. In the STBIR_SIMD path it is adjusted with `end_output -= ...` and then assigned back to the non-const pointer with `output = end_output;` (line 8362). If it were declared `const unsigned char *`, that assignment would not compile. The warning only appears after this PR, which stops treating a compound assignment on a pointer as a write through it. That points to the SIMD configuration, where the `output = end_output` use should still block the suggestion. In the non-SIMD branch it is only compared, but the same declaration serves both branches. Following the advice would break the build, so this is a new false positive. ---- 3 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/c/caveexpress/caveexpress_2.6+ds.orig.tar.xz Result: your caveexpress-2.6/src/tools/textureatlas/external/stb_image_resize2.h:9092:20: style: Variable 'end_output' can be declared as pointer to const [constVariablePointer] Explanation: The warning is new, so the analysed configuration must contain the SIMD block. The old code only treated `end_output` as changed because of `end_output -= stbir__simdfX_float_count*2` in that block; the PR now correctly sees that this changes the pointer, not the data it points to. But the same block also does `output = end_output;` (line 9118), where `output` is a non-const `unsigned short *`. If `end_output` were declared `unsigned short const *`, that assignment would not compile, so the suggestion is wrong. Cppcheck probably misses this use because the `STBIR_SIMD_STREAMOUT_PTR( * )` macro hides the type of `output`. The new warning is a false positive. ---- 4 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/c/chafa/chafa_1.18.2.orig.tar.gz Result: your chafa-1.18.2/chafa/internal/chafa-string-util.c:116:9: error: Uninitialized variable: reg [uninitvar] Explanation: `reg` is declared without an initializer, and its first use is `reg <<= 8;`. That compound assignment reads the uninitialized value, which is formally undefined behavior. The author deliberately leaves it uninitialized and suppresses compiler warnings with pragmas, but the read of an uninitialized variable is real. The PR now treats compound assignments as reads, which matches its new test (`x += i; y <<= i;` give uninitvar). So this is a true positive that Cppcheck previously missed. ---- 5 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/c/cvs/cvs_1.12.13+real.orig.tar.gz Result: your cvs-1.12.13/diff/analyze.c:937:13: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] cvs-1.12.13/diff/analyze.c:935:31: note: Assuming allocation function fails cvs-1.12.13/diff/analyze.c:935:15: note: Assignment 'fdiag=(int*)xmalloc(diags*(2*sizeof(int)))', assigned value is 0 cvs-1.12.13/diff/analyze.c:937:13: note: Null pointer addition Explanation: The PR now treats compound assignment (`fdiag += ...`) as a read of the pointer value, so the null value assumed for a failed allocation reaches that line and `nullPointerArithmeticOutOfMemory` fires. The allocation here is CVS's `xmalloc` (gnulib-style), which calls `xalloc_die` and never returns NULL. So `fdiag` cannot be null at `fdiag += filevec[1].nondiscarded_lines + 1`, and in practice the warning is a false positive. It follows Cppcheck's general model of `xmalloc` as an ordinary allocator, but for users it is new noise on correct code. ---- 6 / 50 ---- Verdict: REGRESSION (high confidence) Package: https://ftp.debian.org/debian/pool/main/d/dwarves/dwarves_1.32.orig.tar.xz Result: your dwarves-1.32/lib/bpf/src/linker.c:3044:6: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] dwarves-1.32/lib/bpf/src/linker.c:3035:21: note: Assuming allocation function fails dwarves-1.32/lib/bpf/src/linker.c:3035:13: note: Assignment 'cur=data=calloc(1,total_sz)', assigned value is 0 dwarves-1.32/lib/bpf/src/linker.c:3036:6: note: Assuming condition is false dwarves-1.32/lib/bpf/src/linker.c:3044:6: note: Null pointer addition Explanation: The code does `cur = data = calloc(1, total_sz)` and then returns if `!data`. So at line 3044 `cur` equals the non-null `data`, and `cur += sizeof(...)` cannot be NULL pointer arithmetic. Cppcheck does not see that the `!data` check also covers `cur`. After the PR, the compound assignment treats the possible-null value of `cur` as read, which produces this false positive. ---- 7 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/e/edk2/edk2_2026.08+ds.orig.tar.xz Result: your edk2-2026.08+ds/MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/UnicodeCollationEng.c:152:39: style: Parameter 'This' can be declared as pointer to const. However it seems that 'EngStriColl' is a callback function, if 'This' is declared with const you might also need to cast function pointer(s). [constParameterCallback] edk2-2026.08+ds/MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/UnicodeCollationEng.c:66:3: note: You might need to cast the function pointer here edk2-2026.08+ds/MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/UnicodeCollationEng.c:152:39: note: Parameter 'This' can be declared as pointer to const Explanation: In `EngStriColl`, `This` is never used, so declaring it pointer to const is technically correct. The `constParameterCallback` wording already points out that the function is used as a callback and that a function-pointer cast may be needed. The warning probably appears now because the PR treats compound assignments on pointers (`Str1 += 1`, `Str2 += 1`) as changing the pointer itself rather than its pointee. That makes the function's parameter analysis more accurate. The new message is a true positive in the same style as other callback warnings, though of limited practical value for a protocol callback. ---- 8 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/e/espeak/espeak_1.48.15+dfsg.orig.tar.gz Result: your espeak-1.48.15+dfsg/src/synthdata.cpp:120:7: style: Variable 'pw' can be declared as pointer to const [constVariablePointer] Explanation: `pw` is only assigned `(int *)p` and then read through `Reverse4Bytes(pw[1])`; nothing is ever written through it in the shown code. So it could be declared `const int *pw`, and the warning is a true positive. Before the PR, cppcheck treated compound assignments like `p += 8` on the aliased pointer `p` as writes to the pointee, which suppressed the warning. The PR's new testcase (`p = r; r += s;`) shows exactly this fix. Confidence is not high because the rest of the function after line 160 is not shown. ---- 9 / 50 ---- Verdict: REGRESSION (high confidence) Package: https://ftp.debian.org/debian/pool/main/f/fastml/fastml_3.11.orig.tar.gz Result: your FastML.v3.11/libs/phylogeny/Parameters.cpp:157:51: style: Parameter 'paramList' can be declared as reference to const [constParameterReference] Explanation: The function returns a `ParamList::iterator` obtained from `paramList.begin()`. If `paramList` were `const ParamList&`, `begin()` would return a `const_iterator`, which cannot convert to `ParamList::iterator`, so the code would not compile. The new constParameterReference warning is therefore a false positive. It likely appears because the PR no longer treats the compound assignment `it+=stop` on the iterator as a change through `paramList`. ---- 10 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/f/freecad/freecad_1.1.3+dfsg.orig.tar.xz Result: your src/3rdParty/salomesmesh/src/Controls/SMESH_Controls.cpp:1855:7: warning: Uninitialized variable: aLength [uninitvar] src/3rdParty/salomesmesh/src/Controls/SMESH_Controls.cpp:1831:22: note: Assuming condition is false src/3rdParty/salomesmesh/src/Controls/SMESH_Controls.cpp:1855:7: note: Uninitialized variable: aLength Explanation: `aLength` is declared without an initializer. It is only assigned inside `if(anIter->more())` (line 1836) or inside the following loop, which also depends on `more()`. If the iterator is empty, neither runs, and line 1855 `aLength += ...` reads an uninitialized value. The PR makes compound assignments count as reads of the old value, matching its new uninitvar test (`x += i`). So this is a newly detected, genuinely possible uninitialized read on the empty-iterator path. In practice a quadratic face always has nodes, so the path may never happen, but the code relies on that unstated invariant and the warning is technically correct. ---- 11 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/g/gmap/gmap_2025-07-31+ds.orig.tar.xz Result: your gmap-2025-07-31/src/genomebits.c:69:50: style: Variable 'end_ptr' can be declared as pointer to const [constVariablePointer] Explanation: `end_ptr` is assigned once from `&(this->high_blocks[endblocki_32])` and is then only compared with `high_ptr` (`<=` and `==`). Nothing is ever written through it, so it can be declared `const Genomecomp_T *end_ptr`. Comparing a const pointer with a non-const pointer is valid C. Before the PR, the compound-assignment handling (presumably `high_ptr += ...` somewhere in the loop, which is not shown) apparently stopped Cppcheck from seeing this. The new warning is a true positive. ---- 12 / 50 ---- Verdict: REGRESSION (high confidence) Package: https://ftp.debian.org/debian/pool/main/g/gss/gss_1.0.4.orig.tar.gz Result: your gss-1.0.4/lib/krb5/checksum.c:76:5: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] gss-1.0.4/lib/krb5/checksum.c:67:20: note: Assuming allocation function fails gss-1.0.4/lib/krb5/checksum.c:67:11: note: Assignment 'p=buf=malloc(len)', assigned value is 0 gss-1.0.4/lib/krb5/checksum.c:68:7: note: Assuming condition is false gss-1.0.4/lib/krb5/checksum.c:76:5: note: Null pointer addition Explanation: The code does `p = buf = malloc(len)` and then checks `if (!buf)` and returns on failure. So at line 76, `p` cannot be NULL because `p` and `buf` hold the same value. Cppcheck does not tie the null check on `buf` back to `p`. Before this PR, `p` was not flagged, apparently because the compound assignment `p += ...` was not modeled the same way. With the PR, `p` keeps the 'possible null' value up to `p +=`, and the new warning is a false positive. ---- 13 / 50 ---- Verdict: REGRESSION (high confidence) Package: https://ftp.debian.org/debian/pool/main/g/gzip/gzip_1.14.orig.tar.xz Result: your gzip-1.14/util.c:322:11: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] gzip-1.14/util.c:319:23: note: Assuming allocation function fails gzip-1.14/util.c:319:23: note: Assignment 'env_val=xstrdup(env_val)', assigned value is 0 gzip-1.14/util.c:321:14: note: Assignment 'p=env_val', assigned value is 0 gzip-1.14/util.c:322:11: note: Null pointer addition Explanation: The new warning is a false positive. gnulib's `xstrdup` never returns NULL; it aborts through `xalloc_die` when allocation fails. Even if it could return NULL, the loop condition `*p` on line 321 dereferences `p` before line 322 runs. So the 'null pointer addition' in `p += strspn(...)` cannot happen with a NULL `p`. The PR now lets the null value reach the left side of a compound assignment, which adds this incorrect warning. ---- 14 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/h/hime/hime_0.9.11+git20231221.g1c15f1f+dfsg.orig.tar.xz Result: your hime/src/IMdkit/lib/i18nUtil.c:149:12: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] hime/src/IMdkit/lib/i18nUtil.c:146:38: note: Assuming allocation function fails hime/src/IMdkit/lib/i18nUtil.c:146:13: note: Assignment 'reply=(unsigned char*)malloc(reply_length)', assigned value is 0 hime/src/IMdkit/lib/i18nUtil.c:147:14: note: Assignment 'replyp=reply', assigned value is 0 hime/src/IMdkit/lib/i18nUtil.c:149:12: note: Null pointer addition Explanation: The PR now makes Cppcheck treat a compound assignment like `p += n` as a read of `p`, so known values are checked there before being invalidated. In this code, `reply` comes from an unchecked `malloc` and is copied to `replyp`. If the allocation fails, `replyp += header_size` does arithmetic on a NULL pointer. That is a genuine out-of-memory issue, the same pattern as the updated `nullPointerArithmetic` test. The new warning is a true positive. ---- 15 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/i/inn2/inn2_2.7.4.orig.tar.xz Result: your inn2-2.7.4/lib/inndcomm.c:245:10: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] inn2-2.7.4/lib/inndcomm.c:240:19: note: Assuming allocation function fails inn2-2.7.4/lib/inndcomm.c:240:19: note: Assignment 'buff=xmalloc(bufsiz)', assigned value is 0 inn2-2.7.4/lib/inndcomm.c:241:9: note: Assuming condition is true inn2-2.7.4/lib/inndcomm.c:245:10: note: Null pointer addition Explanation: The PR now treats the compound assignment `buff += HEADER_SIZE` as a read of the pointer, so the null value from an assumed allocation failure reaches it. The allocator here is `xmalloc`, though. In INN, as in GNU/libiberty, `xmalloc` never returns NULL: it calls a failure handler that exits. The 'Assuming allocation function fails' path cannot happen, so the new nullPointerArithmeticOutOfMemory warning is a false positive. ---- 16 / 50 ---- Verdict: IMPROVEMENT (low confidence) Package: https://ftp.debian.org/debian/pool/main/i/inspircd/inspircd_4.7.0+ds1.orig.tar.gz Result: your inspircd-4.7.0+ds1/src/modules/m_delaymsg.cpp:52:31: style: Either there is a missing override/final keyword, or the parameter 'chan' can be declared as pointer to const [constParameterPointer] Explanation: `SerializeParam(Channel* chan, intptr_t n, std::string& out)` never uses `chan`; it only appends `n` to `out`. It is not a virtual override: the CRTP base `ParamMode` calls it with a `Channel*`, which converts implicitly to `const Channel*`. So declaring the parameter as pointer to const would compile and is technically correct, and the message itself mentions the override/final possibility. It is unclear why this PR's compound-assignment change exposes the warning, since `out += ...` does not involve `chan`. That uncertainty, plus the fact that this is a style note on an unused parameter in a CRTP hook, keeps confidence low. ---- 17 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/l/lfortran/lfortran_0.69.0.orig.tar.gz Result: your lfortran-0.69.0/src/lfortran/ast_to_src.cpp:3817:9: warning: Access of moved variable 's'. [accessMoved] lfortran-0.69.0/src/lfortran/ast_to_src.cpp:3813:29: note: Calling std::move(s) lfortran-0.69.0/src/lfortran/ast_to_src.cpp:3817:9: note: Access of moved variable 's'. Explanation: In visit_DefUnaryOp, `s` is moved into `right` at line 3813. At line 3817 `s += ...` appends to that moved-from string without first reinitializing it (no `clear()` or plain assignment). The standard only guarantees that a moved-from std::string is valid but in an unspecified state. Appending to it therefore relies on the string being empty, which is unspecified behavior. Before the PR, the compound assignment was treated as a write, so the moved state was lost. The PR deliberately makes `+=` a read of the moved value, and its new test (#15155) asserts exactly this case. clang-tidy's bugprone-use-after-move flags the same pattern. The code works in practice because implementations leave the string empty, but this is a legitimate, intended new accessMoved finding. ---- 18 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/libc/libconvert-uulib-perl/libconvert-uulib-perl_1.8+dfsg.orig.tar.xz Result: your Convert-UUlib-1.8/uulib/uucheck.c:108:41: style: Variable 'part' can be declared as pointer to const [constVariablePointer] Explanation: `part` is set from `FP_stristr(subject, "part")` and then only compared with `subject`. Nothing is ever written through it, so declaring it `const char *` is valid and the warning is a true positive. Main missed it because the later `subject += 4` (a compound assignment that moves the pointer, not the data) was treated as a possible write through aliased data. The PR's own test for `p = r; r += s;` covers this exact pattern. The rest of the function is not shown, so a later write through `part` cannot be fully ruled out; the original uulib code does not appear to have one. ---- 19 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/libo/libotr/libotr_4.1.1.orig.tar.gz Result: your libotr-4.1.1/src/auth.c:1088:42: style: Variable 'macstart' can be declared as pointer to const [constVariablePointer] Explanation: `macstart` is set with `macstart = bufp;` and is then only read: in libotr it is passed to `otrl_mem_differ`, which takes const pointers, to check the MAC. The later `bufp += 20;` only moves the pointer `bufp` and does not write through it. Before this PR, Cppcheck treated that compound assignment as possibly modifying the data `macstart` points to. That is exactly the pattern of the new `p = r; r += s;` test in the PR. So the new constVariablePointer warning is a true positive: `macstart` can be `const unsigned char *`. ---- 20 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/libo/libotr/libotr_4.1.1.orig.tar.gz Result: your libotr-4.1.1/src/auth.c:909:42: style: Variable 'macstart' can be declared as pointer to const [constVariablePointer] Explanation: In libotr, `macstart = bufp;` is followed by `bufp += 20;`, and `macstart` is then only passed to `otrl_mem_differ`, which takes const pointers. The data `macstart` points to is never written through it, so it can be `const unsigned char *` and the warning is a true positive. Before the PR, `bufp += 20` on the aliased pointer was wrongly treated as a write to the pointed-to data. The PR fixes this: a compound assignment to a pointer changes the pointer, not what it points to. The new testother case (`p = r; r += s;`) covers exactly this pattern. ---- 21 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/libs/libsoup2.4/libsoup2.4_2.74.3.orig.tar.xz Result: your libsoup-2.74.3/libsoup/soup-websocket-connection.c:965:10: style: Variable 'mask' can be declared as pointer to const [constVariablePointer] Explanation: In libsoup's process_frame, 'mask' is only assigned with 'mask = header + at;' and then passed to xor_with_mask(), which (from upstream libsoup, not the shown excerpt) takes 'const guint8 *mask' and only reads it ('data[n] ^= mask[n & 3]'). Nothing is ever written through 'mask', so it can be declared as pointer to const. The PR makes isVariableChanged stop treating compound assignments through other pointers as modifications. The PR's own new constVariablePointer test case ('r += s' does not make 'p' non-const) is the same pattern. The new warning is therefore a true positive. Confidence is medium because the later use of 'mask' is not in the shown excerpt. ---- 22 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/libs/libsynthesis/libsynthesis_3.4.0.47.5+syncevolution-1.5.3.orig.tar.gz Result: your libsynthesis_3.4.0.47.5+syncevolution-1.5.3/src/sysync_SDK/Sources/san.cpp:329:12: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] libsynthesis_3.4.0.47.5+syncevolution-1.5.3/src/sysync_SDK/Sources/san.cpp:325:22: note: Assuming allocation function fails libsynthesis_3.4.0.47.5+syncevolution-1.5.3/src/sysync_SDK/Sources/san.cpp:325:22: note: Assignment 'fb=std::malloc(newLen)', assigned value is 0 libsynthesis_3.4.0.47.5+syncevolution-1.5.3/src/sysync_SDK/Sources/san.cpp:328:13: note: b is assigned '(unsigned char*)fb' here. libsynthesis_3.4.0.47.5+syncevolution-1.5.3/src/sysync_SDK/Sources/san.cpp:329:12: note: Null pointer addition Explanation: `fb = malloc(newLen)` is never checked for NULL. `b = (byte*)fb; b += fBodySize;` then does pointer arithmetic on a possibly null pointer, which is undefined behavior when the allocation fails. Before the PR, the analyzer did not treat the compound assignment `b +=` as a read of `b`'s current value. Now it treats it as Read|Invalid, so the null value is used at that point. The PR's own updated test in testnullpointer expects exactly this nullPointerArithmetic warning. The new warning is a true positive. ---- 23 / 50 ---- Verdict: REGRESSION (low confidence) Package: https://ftp.debian.org/debian/pool/main/libs/libsynthesis/libsynthesis_3.4.0.47.5+syncevolution-1.5.3.orig.tar.gz Result: your libsynthesis_3.4.0.47.5+syncevolution-1.5.3/src/zlib/deflate.c:886:21: style: Variable 'strend' can be declared as pointer to const [constVariablePointer] Explanation: In zlib's `longest_match`, `strend` is only used for comparisons (`scan < strend`) and pointer arithmetic (`strend - scan`). Its pointee is never written, so in isolation the warning looks plausible. However, the function also does `scan = strend - MAX_MATCH;`, and `scan` is a non-const `Bytef*` that Cppcheck does not flag. Following the advice alone would therefore produce a discarded-const-qualifier warning from the compiler. Cppcheck normally suppresses `constVariablePointer` when the pointer is assigned to a non-const pointer, but here it misses that because of the arithmetic. The PR stopped treating compound assignments like `scan += 2` as writes through the pointer. That exposed this report without accounting for the alias into the non-const `scan`. The finding is therefore incomplete or misleading rather than a clean true positive. ---- 24 / 50 ---- Verdict: IMPROVEMENT (low confidence) Package: https://ftp.debian.org/debian/pool/main/libx/libxt/libxt_1.2.1.orig.tar.gz Result: your libXt-1.2.1/src/TMparse.c:955:33: style: Parameter '_X_UNUSED' can be declared as pointer to const. However it seems that 'ParseAddModifier' is a callback function, if '_X_UNUSED' is declared with const you might also need to cast function pointer(s). [constParameterCallback] libXt-1.2.1/src/TMparse.c:283:49: note: You might need to cast the function pointer here libXt-1.2.1/src/TMparse.c:955:33: note: Parameter '_X_UNUSED' can be declared as pointer to const Explanation: Cppcheck does not know the `_X_UNUSED` macro, so it reads it as the name of the `Boolean *` parameter. That parameter is never used in `ParseAddModifier`, so it could technically be a pointer to const. The constParameterCallback message correctly warns that the function is used as a callback (line 283), so changing it would need a function-pointer cast. `ParseImmed` has the identical pattern and was not reported in either run, which suggests main already warned about it. The only difference in `ParseAddModifier` is the compound assignment `event->event.modifiers |= modval`, and the PR changes how compound assignments through pointers count as variable changes. The new warning therefore looks like the PR making results consistent rather than a new false positive. The odd parameter name comes from the missing macro configuration, not from the PR. ---- 25 / 50 ---- Verdict: IMPROVEMENT (low confidence) Package: https://ftp.debian.org/debian/pool/main/m/magpie/magpie_0.9.4.orig.tar.xz Result: your magpie-0.9.4/src/tests/meta-monitor-manager-test.c:371:65: style: Parameter 'manager' can be declared as pointer to const. However it seems that 'meta_monitor_manager_test_get_capabilities' is a callback function, if 'manager' is declared with const you might also need to cast function pointer(s). [constParameterCallback] magpie-0.9.4/src/tests/meta-monitor-manager-test.c:446:37: note: You might need to cast the function pointer here magpie-0.9.4/src/tests/meta-monitor-manager-test.c:371:65: note: Parameter 'manager' can be declared as pointer to const Explanation: In `meta_monitor_manager_test_get_capabilities`, the parameter `manager` is never used, so it could technically be declared `MetaMonitorManager const *`. Cppcheck intentionally warns for unused pointer parameters; the PR's own test `void h(int *p) {}` expects such a warning. The message also correctly says the function is a callback and would need a function-pointer cast (line 446). The warning is therefore technically a true positive in Cppcheck's terms. It is not very actionable for a GObject vfunc. It is also unclear why only this function changed, since similar functions with unused `manager` parameters are not reported. ---- 26 / 50 ---- Verdict: UNCLEAR (low confidence) Package: https://ftp.debian.org/debian/pool/main/m/mailfromd/mailfromd_9.2.orig.tar.xz Result: your mailfromd-9.2/src/srvcfg.c:563:41: style: Parameter 'po' can be declared as pointer to const. However it seems that 'opt_single_process' is a callback function, if 'po' is declared with const you might also need to cast function pointer(s). [constParameterCallback] mailfromd-9.2/src/srvcfg.c:644:23: note: You might need to cast the function pointer here mailfromd-9.2/src/srvcfg.c:563:41: note: Parameter 'po' can be declared as pointer to const Explanation: The reported location does not match the source shown. Line 563 is in opt_foreground's body, but the column of 'po' fits the opt_single_process declaration five lines later. The opt_single_process body shown never uses 'po' or 'op'. Cppcheck normally does not report const-pointer warnings for parameters that are never referenced, so the analyzed code apparently differs from what is shown. The new warning likely comes from the PR's change to compound-assignment handling, which now treats some writes through these parameters as non-modifying. Without the actual function body, we cannot tell whether that is correct (true positive) or a missed write (false positive). ---- 27 / 50 ---- Verdict: IMPROVEMENT (low confidence) Package: https://ftp.debian.org/debian/pool/main/m/mailfromd/mailfromd_9.2.orig.tar.xz Result: your mailfromd-9.2/src/srvcfg.c:563:63: style: Parameter 'op' can be declared as pointer to const. However it seems that 'opt_single_process' is a callback function, if 'op' is declared with const you might also need to cast function pointer(s). [constParameterCallback] mailfromd-9.2/src/srvcfg.c:644:23: note: You might need to cast the function pointer here mailfromd-9.2/src/srvcfg.c:563:63: note: Parameter 'op' can be declared as pointer to const Explanation: `opt_single_process(struct mu_parseopt *po, struct mu_option *op, char const *arg)` never uses `op`; the body only does `srvman_param.flags |= SRV_SINGLE_PROCESS;`. A pointer parameter that is never used could technically be declared as pointer to const. The message correctly says the function is a callback and that a function-pointer cast might be needed. That is exactly what constParameterCallback is meant to report. It is unclear why main missed it; the PR changes how compound assignments are handled, which may have unblocked the check. The finding looks like a valid, if low-value, true positive under Cppcheck's own rules. ---- 28 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/m/make-dfsg/make-dfsg_4.4.1.orig.tar.xz Result: your make-4.4.1/src/read.c:650:26: style: Variable 'ul' can be declared as pointer to const [constVariablePointer] Explanation: The warning refers to `ul`, declared at line 655 as `unsigned char *ul = (unsigned char *) line;`. Column 26 matches `ul`; the 5-line offset is probably a line-mapping quirk caused by the multi-line macro above. `ul` is only read, in the comparisons `ul[0] == 0xEF && ul[1] == 0xBB && ul[2] == 0xBF`, and nothing is written through it. It could be declared `const unsigned char *`, so the new constVariablePointer warning is a true positive. The PR's tighter handling of indirect and array accesses in isVariableChanged plausibly removed an earlier false 'changed' result. Confidence is medium because of the line-number mismatch. ---- 29 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/m/mono/mono_6.14.1+ds2.orig.tar.xz Result: your mono-6.14.1/external/corefx/src/Native/Windows/clrcompression/zlib/deflate.c:1174:21: style: Variable 'strend' can be declared as pointer to const [constVariablePointer] Explanation: In zlib's `longest_match`, `strend` is later used in `scan = strend - MAX_MATCH;`, where `scan` is a non-const `Bytef *`. If `strend` were declared as pointer to const, that assignment would discard the qualifier, which C diagnoses as a constraint violation. So the suggestion to make `strend` a pointer to const is wrong. The PR changed how assignments are treated in `isVariableChanged`, which apparently stopped Cppcheck from seeing this use. This new warning is a false positive. ---- 30 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/m/mono/mono_6.14.1+ds2.orig.tar.xz Result: your mono-6.14.1/mono/zlib/deflate.c:1302:21: style: Variable 'strend' can be declared as pointer to const [constVariablePointer] Explanation: In zlib's longest_match, `strend` is never written through, but it is used to compute a non-const pointer: `scan = strend - MAX_MATCH;`, where `scan` is a plain `Bytef *`. If `strend` were made `const Bytef *` as suggested, that assignment would discard the const qualifier, which is a diagnostic in C and an error in C++. Cppcheck normally suppresses constVariablePointer when the pointer flows into a non-const pointer. It also does not suggest making `scan` const, so the advice cannot be applied on its own. The PR only changed how compound assignments are handled, and nothing here justifies a new warning. This new report appears to be a false positive introduced by the change. ---- 31 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/n/ncbi-igblast/ncbi-igblast_1.20.0.orig.tar.gz Result: your ncbi-igblast-1.20.0-src/c++/src/algo/blast/core/blast_sw.c:474:18: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory] ncbi-igblast-1.20.0-src/c++/src/algo/blast/core/blast_sw.c:469:37: note: Assuming allocation function fails ncbi-igblast-1.20.0-src/c++/src/algo/blast/core/blast_sw.c:469:22: note: Assignment 'traceback_array=(Uint1*)malloc((a_size+1)*(b_size+1)*sizeof(Uint1))', assigned value is 0 ncbi-igblast-1.20.0-src/c++/src/algo/blast/core/blast_sw.c:471:18: note: traceback_row is assigned 'traceback_array' here. ncbi-igblast-1.20.0-src/c++/src/algo/blast/core/blast_sw.c:474:18: note: Null pointer addition Explanation: `traceback_array` comes straight from `malloc` with no NULL check and is copied into `traceback_row`. If the allocation fails, `traceback_row += b_size + 1` at line 474 is arithmetic on a NULL pointer, which is undefined behaviour. The PR makes compound assignment like `p += a` keep the known value and then read it, instead of discarding it. This matches the updated test in testnullpointer.cpp that now expects nullPointerArithmetic. The new warning is a genuine out-of-memory issue, though the code would already have crashed on the writes at line 473, so it is a minor true positive rather than a false one. ---- 32 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/n/ndpi/ndpi_4.2.orig.tar.gz Result: your nDPI-4.2/src/lib/protocols/openvpn.c:84:30: style: Variable 'packet' can be declared as pointer to const [constVariablePointer] Explanation: In ndpi_search_openvpn, `packet` is only read: `packet->payload`, `packet->payload_packet_len`, `packet->tcp` and `packet->udp`. Nothing is written through it, so it can be declared `const struct ndpi_packet_struct*` and the new warning is a true positive. Main probably missed it because `ovpn_payload += 2` (where `ovpn_payload` comes from `packet->payload`) was treated as modifying the pointed-to data. The PR now correctly treats a compound assignment to the pointer itself as not changing the pointee. This matches the new constVariablePointer test case in the PR. ---- 33 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/n/node-es-module-lexer/node-es-module-lexer_2.1.0+dfsg.orig.tar.xz Result: your guybedford-es-module-lexer-5fb11e1/src/lexer.c:422:13: style: Variable 'sStartPos' can be declared as pointer to const [constVariablePointer] Explanation: `sStartPos` is initialised from the global `pos`. The code then does `pos += 6` and further pointer increments on `pos`. Before the PR, `isVariableChanged` treated a compound assignment on a pointer (`pos += 6`) as writing through the pointer. Because `sStartPos` aliases `pos`, this suppressed the constVariablePointer check for `sStartPos`. The PR fixes exactly this pattern; the new testother case `p = r; r += s;` mirrors it. As far as I recall the lexer source, `sStartPos` is only passed as a statement-start marker to functions such as `readImportString` and `addImport`, which take `const char16_t*`. That part is not shown, hence medium confidence. The pointee is never written through it, so the new warning appears to be a true positive. ---- 34 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/o/ode/ode_0.16.6.orig.tar.gz Result: your ode-0.16.6/OPCODE/Ice/IceRevisitedRadix.cpp:271:11: style: Variable 'h3' can be declared as pointer to const [constVariablePointer] Explanation: h3 points into mHistogram and is only read (NbNegativeValues += h3[i]). Before the PR, the compound assignment `+= h3[i]` was wrongly treated as modifying h3 through the RHS read. The PR fixes this, so h3 can now be flagged as `const udword*`. The new constVariablePointer warning is a true positive. ---- 35 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/p/pdfjs-openjpeg/pdfjs-openjpeg_0.0~git20260423+ds.orig.tar.xz Result: your pdfjs-openjpeg-0.0~git20260423+ds/openjpeg/src/lib/openjp2/dwt.c:3313:18: style: Variable 'fl' can be declared as pointer to const [constVariablePointer] Explanation: `fl` is only read through (`fl[0]`..`fl[7]`). It is reassigned with `fl = fw - ...` and `fl = fw`, which are pointer assignments, not writes through `fl`. Assigning a `float*` to a `const float*` is valid, so `fl` could be declared `const OPJ_FLOAT32*`. The warning was presumably suppressed before because the compound assignment `fw += ...` on the aliased pointer was wrongly treated as modifying the pointee. This is the same pattern as the new test case in the PR (`p = r; r += s;`). This is a new true positive. ---- 36 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/p/pdfjs-openjpeg/pdfjs-openjpeg_0.0~git20260423+ds.orig.tar.xz Result: your pdfjs-openjpeg-0.0~git20260423+ds/openjpeg/src/lib/openjp2/jp2.c:1164:15: style: Variable 'orig_header_data' can be declared as pointer to const [constVariablePointer] Explanation: `orig_header_data` is an alias of `p_pclr_header_data`, and only the pointer itself is advanced (`p_pclr_header_data += 2`, `++p_pclr_header_data`). In upstream openjpeg, `orig_header_data` is only used in a bounds check (`p_pclr_header_data - orig_header_data`) and nothing is written through it. So it can be `const OPJ_BYTE *` and the warning is a true positive. Main missed it because the compound assignment on the pointer was wrongly treated as modifying the pointed-to data, which is exactly what the PR fixes (see its new constVariablePointer test). The later uses of the variable are not in the shown snippet, hence medium confidence. ---- 37 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/p/plptools/plptools_1.0.26.orig.tar.gz Result: your plptools-1.0.26/plpftp/ftp.cc:584:17: style: Variable 'td' can be declared as pointer to const [constVariablePointer] Explanation: `td` is only ever read through: `*td++` and `buf + *td`. Otherwise the pointer itself is incremented (`td++`). Nothing is ever written through it, so declaring it `const uint32_t *td` is valid. The new constVariablePointer warning is a true positive. The PR stops compound assignment and pointer-arithmetic patterns from being treated as writes through the pointer, which is what lets this missed case be reported now. ---- 38 / 50 ---- Verdict: IMPROVEMENT (low confidence) Package: https://ftp.debian.org/debian/pool/main/p/pymol/pymol_3.1.0+dfsg.orig.tar.xz Result: your pymol-open-source-3.1.0/layer0/Matrix.cpp:825:35: style: Parameter 'G' can be declared as pointer to const [constParameterPointer] Explanation: In the visible body of MatrixGetRMS, the parameter `G` is never used, so declaring it `const PyMOLGlobals *G` would compile and is technically correct. The new warning therefore looks like a true positive. Confidence is low for three reasons. First, the end of the function is not shown, so a later use of `G` cannot be ruled out. Second, `wt` is also read-only here, yet it is not flagged by either version. Third, it is not obvious how the compound-assignment change in this PR makes `G` newly reportable. ---- 39 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/p/pymol/pymol_3.1.0+dfsg.orig.tar.xz Result: your pymol-open-source-3.1.0/layer2/RepMesh.cpp:160:33: style: Variable 'color' can be declared as pointer to const [constVariablePointer] Explanation: 'color' is set from 'vc' (`color = vc;`) and afterwards only read, in the comparisons `*(color) != *(vc)` and similar. It is never written through or passed to a non-const parameter, so it can be declared `const float *color`; assigning a `float*` to it is valid. Before the PR, `vc += 3` on the aliased pointer was wrongly treated as modifying the pointed-to data, which hid this warning. The PR stops treating a compound assignment to the pointer itself as a write to the pointee. This is a new true positive. ---- 40 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/q/qt6-3d/qt6-3d_6.11.2+dfsg.orig.tar.xz Result: your qt3d-everywhere-src-6.11.2/src/3rdparty/assimp/src/code/AssetLib/STL/STLLoader.cpp:453:17: style: Variable 'theVec' can be declared as pointer to const [constVariablePointer] Explanation: `theVec` is only used to read data: it is assigned from `(aiVector3f *)sz`, passed as the source of `memcpy`, incremented, and (in upstream assimp) converted back to `sz`, which is a `const unsigned char *`. Nothing is ever written through it. It can be declared `const aiVector3f *`, which would also stop the cast from dropping const from `sz`. The PR stops treating compound assignments on pointer variables (such as `sz += 2`) as writes to the pointee, so this true positive is now reported. ---- 41 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/q/qt6-3d/qt6-3d_6.11.2+dfsg.orig.tar.xz Result: your qt3d-everywhere-src-6.11.2/src/plugins/renderers/opengl/debug/imguirenderer.cpp:435:31: error:inconclusive: Pointer addition with NULL pointer. [nullPointerArithmetic] qt3d-everywhere-src-6.11.2/src/plugins/renderers/opengl/debug/imguirenderer.cpp:417:46: note: Assignment 'idx_buffer_offset=nullptr', assigned value is 0 qt3d-everywhere-src-6.11.2/src/plugins/renderers/opengl/debug/imguirenderer.cpp:427:21: note: Assuming condition is false qt3d-everywhere-src-6.11.2/src/plugins/renderers/opengl/debug/imguirenderer.cpp:435:31: note: Null pointer addition Explanation: `idx_buffer_offset` is set to nullptr at line 417, and on the first inner-loop iteration line 435 does `idx_buffer_offset += pcmd->ElemCount`. That is pointer arithmetic on a null pointer, which is formally undefined behaviour in C++ (unless the added value is 0). It is a common OpenGL idiom of passing a buffer offset as a pointer, but the warning is technically correct. Before the PR, the compound assignment was treated as a plain write that killed the null value, so this was missed. The PR's own updated test (`p += a` now reports nullPointerArithmetic) confirms this is the intended behaviour. The 'Assuming condition is false' note is slightly off, since the addition happens on both branches, but the finding itself is valid. ---- 42 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/r/r-bioc-rtracklayer/r-bioc-rtracklayer_1.72.0+ds.orig.tar.xz Result: your rtracklayer/src/ucsc/bwgCreate.c:724:80: style: Variable 'prev' can be declared as pointer to const [constVariablePointer] Explanation: `prev` is only assigned from `items` and then read through `prev->start`; nothing is ever written through it, so it can be `const struct bwgVariableStepPacked *`. Main missed this because it treated `items += 1` (pointer arithmetic on the alias source) as modifying the pointed-to data. The PR fixes that case, matching its new test (`p = r; r += s;`). This is a new true positive. Fixing it would mean splitting the combined declaration, but the warning is correct. ---- 43 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/r/rust-capstone-sys/rust-capstone-sys_0.17.0.orig.tar.gz Result: your capstone-sys-0.17.0/capstone/suite/cstest/src/helper.c:110:40: style: Variable 'orig_found' can be declared as pointer to const [constVariablePointer] Explanation: `orig_found` is assigned from `found` and then only read, in `orig_found - tmp`. Nothing is ever written through it, so it can be `const char *`. Before the PR, the compound assignment `found += 2` on the aliased pointer was wrongly treated as modifying the pointed-to data, which suppressed the warning. The PR's new test case (`p = r; r += s;`) covers exactly this pattern, so this is a new true positive. ---- 44 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/s/spandsp/spandsp_0.0.6+dfsg.orig.tar.xz Result: your spandsp-0.0.6+dfsg/src/at_interpreter.c:3617:48: style: Parameter 's' can be declared as pointer to const [constParameterPointer] Explanation: `at_cmd_plus_FKS` never uses `s`. Like the other `at_cmd_*` handlers, it is almost certainly registered in the AT command dispatch table, whose function-pointer type takes a non-const `at_state_t *`. Changing `s` to a pointer to const would make the function incompatible with that table, so the advice cannot be followed. Cppcheck normally avoids this case or reports constParameterCallback instead. The PR adds over a hundred such warnings across these handlers, which looks like a side effect of changing how `t += 4` is analysed, not a real const-correctness finding. These are new false positives (or less accurate messages). ---- 45 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/s/spandsp/spandsp_0.0.6+dfsg.orig.tar.xz Result: your spandsp-0.0.6+dfsg/src/at_interpreter.c:4715:48: style: Parameter 's' can be declared as pointer to const [constParameterPointer] Explanation: `at_cmd_plus_VBT` never uses `s`; it only does `t += 4; return t;`. Like the other `at_cmd_*` handlers, it must keep the common `at_state_t *s` signature because it is registered as a callback in the AT command dispatch table. Making `s` const would break that function-pointer type. The new warning is also inconsistent: `at_cmd_plus_VAC`, which also ignores `s` but has no compound assignment to `t`, still gets no warning. This suggests the PR's compound-assignment handling has a side effect on the const-parameter check for an unrelated parameter. The many new warnings of this kind in this file are false positives that users cannot act on. ---- 46 / 50 ---- Verdict: REGRESSION (medium confidence) Package: https://ftp.debian.org/debian/pool/main/s/spandsp/spandsp_0.0.6+dfsg.orig.tar.xz Result: your spandsp-0.0.6+dfsg/src/at_interpreter.c:4789:48: style: Parameter 's' can be declared as pointer to const [constParameterPointer] Explanation: `at_cmd_plus_VEM` is one of about 100 AT-command handlers with the same signature `(at_state_t *s, const char *t)`. The new warnings are all about `s`, not `t`. These handlers are almost certainly stored in spandsp's AT-command function-pointer table, so `s` cannot be made const without breaking the common callback signature. In this function `s` is not even used: the body only does `t += 4` on the other parameter. The PR only changes how compound assignments and array accesses count as variable modifications, which has nothing to do with whether `s` could be const. The sudden mass appearance of these warnings is therefore a side effect, not a real finding. They are false positives that users cannot act on. ---- 47 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/t/texmaker/texmaker_6.0.1+dfsg.orig.tar.xz Result: your texmaker-6.0.1/3rdparty/pdfium/third_party/libopenjpeg20/dwt.c:755:24: style: Variable 'fl' can be declared as pointer to const [constVariablePointer] Explanation: 'fl' is only ever read through (fl[0]..fl[3]) and reassigned with 'fl = fw'. Nothing is written through it, so it can be 'const OPJ_FLOAT32* restrict', and assigning the non-const 'fw' to it is still valid. Before the PR, the compound assignment 'fw += 8' to the aliased pointer was wrongly treated as modifying the pointee, which suppressed the warning. The PR's own new test case ('p = r; r += s;') covers exactly this pattern. This is a new true positive. ---- 48 / 50 ---- Verdict: IMPROVEMENT (medium confidence) Package: https://ftp.debian.org/debian/pool/main/t/texmaker/texmaker_6.0.1+dfsg.orig.tar.xz Result: your texmaker-6.0.1/3rdparty/pdfium/third_party/libopenjpeg20/jp2.c:1079:12: style: Variable 'orig_header_data' can be declared as pointer to const [constVariablePointer] Explanation: `orig_header_data` is a copy of the incoming pointer. It is only used later in bounds checks such as `p_pclr_header_data - orig_header_data`, which read the pointer and never write through it. Before the PR, the compound assignment `p_pclr_header_data += 2` on the aliased pointer was wrongly treated as modifying the pointed-to data, which suppressed the warning. The PR makes compound assignment on a pointer count as changing the pointer, not the pointee. Declaring `orig_header_data` as `const OPJ_BYTE *` is valid C, so this new warning is a true positive. ---- 49 / 50 ---- Verdict: IMPROVEMENT (high confidence) Package: https://ftp.debian.org/debian/pool/main/t/texmaker/texmaker_6.0.1+dfsg.orig.tar.xz Result: your texmaker-6.0.1/3rdparty/pdfium/xfa/fde/cfde_txtedtparag.cpp:143:12: style: Variable 'pLineBaseArr' can be declared as pointer to const [constVariablePointer] Explanation: In `GetLineRange`, `pLineBaseArr` is only used to read pointees (`nStart += *pLineBaseArr`, `nCount = *pLineBaseArr`). The only writes are `pLineBaseArr++`, which change the pointer itself, not what it points to. So it can be declared `const int32_t*`, and assigning from `m_lpData` still compiles. The new constVariablePointer warning is a true positive. Main previously missed it because it treated the compound assignment as modifying the pointee. ---- 50 / 50 ---- Verdict: NEUTRAL (medium confidence) Package: https://ftp.debian.org/debian/pool/main/t/tightvnc/tightvnc_1.3.10.orig.tar.gz Result: your vnc_unixsrc/Xvnc/programs/Xserver/cfb/cfbfillarc.c:87:5: error: Uninitialized variable: yorg [uninitvar] Explanation: Main already reported this exact warning at the same location as legacyUninitvar. The PR only moves it to the ValueFlow-based uninitvar check, because compound assignment (`yorg += ...`) is now treated as a read. The underlying finding is unchanged. In the real code, `yorg` is assigned by the `MIFILLARCSETUP()` macro (`yorg = info.yorg`), so the warning is likely a false positive caused by the macro definition not being visible. Since that false positive existed before and only its ID changed, users see no meaningful difference.