Consolidates initial compound literal improvements #253
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
This commit consolidates compound literal improvements:
- Support global struct/array initialization with compound literals
- Implement GP-relative stores for global array initializers
- Enhanced global struct variable declaration support
- Support nested compound literals in arrays
What still doesn't work:
- True C99 compound literals with cast syntax: (Type){...}
- Struct compound literals: (struct Point){10, 20}
- Array compound literals with type: (int[]){1, 2, 3}
This commit addresses two critical issues with global struct arrays:
1. Global struct arrays were missing the is_global flag, causing them to
be treated as local variables during code generation. This led to
segmentation faults when accessing them at runtime since they were
incorrectly loaded from the stack pointer (sp) instead of the global
pointer (gp).
2. Global struct array initialization values were being parsed but
ignored. The parser was only consuming the tokens without generating
the necessary OP_load_constant instructions to initialize the values
at runtime.
This fixes the test case where `struct point gpts1[] = { {3, 4} }` would
return 0 instead of the expected 7 when accessing gpts1[0].x+gpts1[0].y.
Apply control flow fix from dev-compound-literal branch to ensure proper execution order after global variable initialization. - Adjust syscall trampoline offset to 48 (was 44) - Adjust global init offset to 84 (was 80) - Add branch instruction after global init to skip early exit code - Clarify that r0 already contains main's return value at exit
Adapt changes from commit 191c6ac to the compound-literal branch. This replaces verbose index-based array initialization with cleaner compound literal arrays: - Convert directive initialization to use array compound literal - Convert keyword initialization to use array compound literal
Critical safety improvements:
- Add comprehensive null pointer checks to all ELF generation functions
- Prevent crashes from uninitialized ELF buffers
- Fix array compound literal crash: {1, 2, 3} now works in expressions
- Add support for empty arrays and trailing commas
- Proper type inference from first element
Extract parse_array_init and read_body_statement into reusable helper functions, reducing nesting levels and improve code readability.
jserv
force-pushed
the
compound-literal
branch
from
e352238 to
e179f4b
Compare
This commit improves compound literal support by implementing C99-style
compound literals with both standard and non-standard extensions.
- Array compound literals: (int[]){10, 20, 30}
- Scalar compound literals: (int){42}
- Character compound literals: (char){'A'}
- Mixed expressions: (int){10} + (int[]){20}
- Function argument support: func((int){5}, (int[]){10})
- Non-standard scalar assignment: int x = (int[]){100} assigns 100
ChAoSUnItY
approved these changes
Aug 20, 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.
This improve shecc's robustness and partial C99 compatibility while maintaining the critical self-hosting property.
{1, 2, 3}syntax now works in expression contextsWhile this improves compound literal support, full C99 compound literals remain unsupported due to architectural constraints:
(Type){...}(struct Point){10, 20}(int[]){1, 2, 3}Summary by Bito
This pull request enhances the shecc compiler's support for compound literals, improving robustness and partial C99 compatibility. Key updates include better support for array literals, global struct array initialization, and modernization of the lexer for cleaner token mapping. However, full C99 support remains limited due to architectural constraints.