Support complex pointer arithmetic in dereference #230
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
jserv
requested review from
ChAoSUnItY,
DrXiao and
vacantron
and removed request for
ChAoSUnItY and
DrXiao
ChAoSUnItY
reviewed
Aug 5, 2025
Previously, the parser only handled simple identifier dereference (*var)
and would crash on complex expressions like *(ptr + offset). This change
extends the dereference operator handling to accept general expressions
in parentheses.
This enables compilation of previously failing patterns:
- *(p + 4) - direct offset
- *(p + i + 2) - variable in expression
- *(p + i * 2) - arithmetic in expression
It also handles consecutive asterisks ('**pp', '***ppp') by counting
dereference levels and applying them iteratively.
When expressions like arr[0] + arr[1] + arr[2] were parsed, the compiler
was incorrectly applying pointer arithmetic scaling to the values read
from the array elements, resulting in wrong calculations.
The issue was in read_lvalue() which was handling the '+' operator after
array indexing as if it were pointer arithmetic. After arr[0], we have
an integer value, not a pointer, so the '+' should be handled by the
expression parser, not by read_lvalue.
This fix adds a check to ensure pointer arithmetic handling only occurs
when we have a pointer/array that hasn't been dereferenced (i.e., when
lvalue->is_reference is false).
Test case that was failing:
int arr[3] = {10, 20, 12};
return arr[0] + arr[1] + arr[2]; // Was returning 26 instead of 42
jserv
force-pushed
the
pointer-arithmetic
branch
from
79290dd to
8ce5f7c
Compare
ChAoSUnItY
approved these changes
Aug 6, 2025
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Previously, the parser only handled simple identifier dereference (*var) and would crash on complex expressions like *(ptr + offset). This change extends the dereference operator handling to accept general expressions in parentheses.
This enables compilation of previously failing patterns:
It also handles consecutive asterisks ('**pp', '***ppp') by counting dereference levels and applying them iteratively.
Summary by Bito
This pull request enhances the parser's capability to handle complex pointer arithmetic in dereference operations, allowing expressions like *(ptr + offset) and supporting multiple dereferencing levels. It improves robustness by preventing crashes with intricate pointer patterns and includes a comprehensive suite of tests to validate these enhancements.