Harden frontend for v0.2.0 release

* Fixed segfault issue with arena allocator, beefed up test harness to tell if the rror cases errored correctly

* Fixed holes in analyzer type checking system, Added special error type for analyzing program with no main

* Reformatted LOC summary to split test harness code from compiler code

* Fixed bug with string escape truncation in the tokenizer, made struct decls consistent with semi colons

* Fix lexer error recovery and add struct-typed global parsing

Lexer: consume entire malformed number literal before returning an
error so diagnostics aren't repeated per digit. Add ERANGE check
for strtol overflow.

Parser: accept struct-typed globals at file scope (identifier
lookahead, same pattern as local declarations). Allow optional
trailing semicolon after struct closing brace. Add NULL check
after malloc in GENERATE_ERROR macro.

AST printer: loop ptr_depth for correct star count (u16** not u16*),
add depth guard in print_ast_labeled.

* Add error kinds for analyzer hardening

New error types: ERR_MISSING_MAIN, ERR_LITERAL_OUT_OF_RANGE,
ERR_NOT_LVALUE, ERR_VOID_VARIABLE, ERR_NOT_A_STRUCT,
ERR_MISSING_RETURN. Add lvalue union member to error_t.

Fix type_to_string to loop ptr_depth with a local stars buffer
instead of printing a single star.

* Close silent-accept gaps in semantic analyzer

Validate declared types everywhere (locals, params, globals, regs,
fields, return types) - unknown structs and non-pointer void rejected
at the declaration site. Bad symbols poisoned with TYPE_INVALID to
prevent cascading diagnostics.

New checks: lvalue validation for assignment/&/++/--, integer literal
range checking, negative literal typing (-5 as i8 not u8), global
initializer type checking, bare return in non-void rejection, shallow
missing-return detection, struct pointer auto-deref for field access.

* Update README and CHANGELOG for v0.2.0

Author: jackwthake

CHANGELOG.md

@@ -36,6 +36,35 @@ releases are reserved for bug fixes only.
 - Compiler test cases covering analyzer error paths (undeclared
   identifiers, type mismatches, call errors, struct errors) and
   success paths (scoping, widening, pointers, basic analysis).
+- **Analyzer hardening** — additional validation closing gaps where invalid
+  programs were previously accepted silently:
+  - Named struct types are checked for existence in *every* declaration form
+    (locals, parameters, globals, registers, struct fields, function return
+    types), not just struct initializers and field access. A symbol whose
+    declared type is invalid is poisoned, so later uses don't cascade
+    duplicate diagnostics.
+  - A non-pointer `void` is rejected as a variable/parameter/field/global
+    type (`void*` remains valid as a null pointer).
+  - Integer literals that don't fit any supported type are now an error
+    (previously swallowed); the lexer rejects literals that overflow `long`.
+    Negative literals are typed from their value (`-5` is `i8`, `-300` is
+    `i16`).
+  - Assignment targets and the operands of `&`, `++`, and `--` must be
+    lvalues.
+  - Global variable initializers are type-checked (resolved in the global
+    scope), just like local declarations - previously they were ignored.
+  - A bare `return;` in a non-void function is rejected, and a non-void
+    function that can fall off its end without returning a value is flagged.
+    (This last check is shallow: a function ending in a control-flow statement
+    — e.g. a one-armed `if` that falls through, or an `if`/`else` where only
+    some branches return — is assumed to return and is not flagged. Full
+    path-coverage analysis is future work.)
+- Struct-typed globals (`Point p;` at file scope) now parse, matching the
+  form used for locals.
+- Field access auto-dereferences a single-level struct pointer (`c.field` on
+  a `Struct*`), since there is no `->` operator.
+- A negative-test corpus exercising each new check, plus positive tests for
+  pointer field auto-deref and negative-literal typing.
 
 ### Changed
 
@@ -54,6 +83,18 @@ releases are reserved for bug fixes only.
 - Generalized the arena allocator out of `parser.c` into shared
   infrastructure, so semantic analysis can reuse it for its own
   allocations.
+- Diagnostics now print the full pointer depth (`u16**`, not `u16*`) and name
+  the actual type in field-access-on-non-struct errors; a malformed number
+  literal and a repeated unknown-type are each reported once rather than per
+  character / per use.
+
+### Fixed
+
+- Fixed a segfault when a parse error's offending token was a numeric literal.
+- Fixed a memory leak in the arena allocator when a standard chunk allocation
+  followed an oversized one.
+- String literals with escape sequences no longer drop a trailing character
+  per escape, and common escapes (`\n`, `\t`, `\\`, `\"`, ...) are decoded.
 
 ## [0.1.1] - 2026-06-20
 
@@ -96,7 +137,6 @@ implemented.
 
 ### Known Limitations
 
-- No semantic analysis: types, struct fields, and symbol references are not validated.
 - No code generation: `cc02` does not yet produce a working 65C02 binary.
 - No array type or subscript syntax.
 - `->` is not implemented; field access through a pointer is intended to auto-dereference via semantic analysis once that exists.

README.md

@@ -19,8 +19,8 @@
 
 1. **Source Tracking Tokenizer:** Maps characters to discrete tokens while maintaining source locations (file, line, column) for robust compilation errors.
 2. **Recursive Descent Parser:** Transforms the token stream into a structured AST, treating hardware registers and standard controls as first-class grammatical constructs.
-3. **Lexically Scoped Semantic Analyzer:** Implements a type synthesizer and validation engine. It enforces a hierarchical symbol table structure to handle block scoping (`if/else`, `while`, `for`), tracking variable lifetimes, validating function signatures, and trapping type mismatches before code generation.
-5. **Optimized Code Generator:** Generates valid 65C02 binaries. It avoids slow stack execution by mapping parameters and expression scratchpads directly onto a high-performance zero-page register design.
+3. **Lexically Scoped Semantic Analyzer:** Two-pass validation engine over the AST. Pass 1 registers all top-level declarations (functions, structs, registers, globals) into the global symbol table. Pass 2 walks function bodies with a scoped symbol table, checking undeclared identifiers, type mismatches, argument counts/types, struct field access, lvalue validity, and return-type consistency. Invalid declarations are poisoned to prevent cascading diagnostics.
+4. **Optimized Code Generator:** Generates valid 65C02 binaries. It avoids slow stack execution by mapping parameters and expression scratchpads directly onto a high-performance zero-page register design.
 > To be implemented!!
 
 #### c02-objdump Disassembler
@@ -29,13 +29,14 @@
 
 ## Current Status & Limitations
 
-C02 is under active, early development. This is a **frontend-only** release — the tokenizer, parser, and analyzer are functional and tested, but nothing downstream of analysis exists yet:
+C02 is under active, early development. The **complete frontend** - tokenizer, parser, and semantic analyzer - is functional and tested, but nothing downstream of analysis exists yet:
 
 - **Code generation is not implemented.** `cc02` will not currently produce a working 65C02 binary. The zero-page register layout below is a design target for the code generator, not yet a reality.
 - **No arrays.** There's no array type or subscript syntax (`a[i]`) yet. Strings work as `u8*` and pointer arithmetic covers some of the same ground in the meantime, but fixed-size arrays with bounds/length tracking are unimplemented.
-- **No `struct` field access through a pointer is auto-dereferenced**, but there's no `->` operator — `.` is used uniformly and indirection is intended to be resolved during semantic analysis, which doesn't exist yet, so this is currently unverified in practice.
+- **Struct field access through a pointer is auto-dereferenced** - there's no `->` operator; `.` is used uniformly and the analyzer resolves single-level pointer indirection automatically (e.g. `ptr.field` where `ptr` is a `Struct*`).
+- **Missing-return detection is shallow.** A non-void function with no `return` at the end is flagged, but the analyzer does not perform full path-coverage analysis - a one-armed `if` that falls through, or an `if`/`else` where only some branches return, is not caught.
 
-If you're exploring the codebase: the parser, [parser.c](cc02/src/parser.c) and its design notes in the header comment are the most complete and representative part of the project right now. Issues and PRs around parser bugs, grammar gaps, or AST design are welcome; IR / codegen is actively being worked on next.
+If you're exploring the codebase: the parser ([parser.c](cc02/src/parser/parser.c)) and the analyzer ([analyzer.c](cc02/src/analysis/analyzer.c)) are the most complete parts of the project. Issues and PRs around parser bugs, grammar gaps, or analyzer edge cases are welcome; IR / codegen is actively being worked on next.
 
 ## Toolchain Usage
 
@@ -63,7 +64,8 @@ cc02 [OPTIONS] <FILE>
 - `<FILE>`:               The input source file (.c02).
 - `-h, --help`:           Show help message
 - `--token-dump`:         Dump the token list after tokenization
-- `--ast-dump`:           Dump the AST using print_ast after parsing
+- `--ast-dump`:           Dump the AST after parsing
+- `--symbol-dump`:        Dump the global symbol table after analysis
 - `--syntax-check-only`:  Stop after syntax and semantic checks
 - `--time-report`:        Prints a report showing how long each stage of compilation took
 - `-o, --output`:         Specify output file
@@ -86,7 +88,7 @@ All generated error messages are presented in a clang like format with concise s
 
 ## Language Specifications
 
-> The grammar below reflects what the tokenizer and parser currently accept. Semantic analysis and code generation are not implemented yet, so none of this is type-checked or compiled to 65C02 yet — see [Getting Started](#getting-started-key-features--architecture) above.
+> The grammar below reflects what the tokenizer and parser currently accept. Semantic analysis validates the full AST after parsing - see [Getting Started](#getting-started-key-features--architecture) above. Code generation is not implemented yet.
 
 ### Basic Types
 
@@ -136,19 +138,22 @@ reg u8 PORTB @ 0x6000;
 struct Point {
   u8 x;
   u8 y;
-};
+}
 ```
 
 - Body is a sequence of `type name;` fields, no nested initialisers.
+- A trailing `;` after the closing `}` is optional.
 
 #### Global Variables
 
 ```c
 u8 *msg = "Hello C02!";
 u16 counter;
+Point origin;
 ```
 
 - Same form as a local variable declaration: `type name;` or `type name = expr;`.
+- Struct-typed globals are supported (`Point p;`).
 
 ### Statements
 
@@ -203,7 +208,7 @@ Precedence, lowest to highest:
 ```
 
 - **Unary (prefix):** `!` (logical not), `-` (negate), `&` (address-of), `~` (bitwise not), `++` / `--`, `*` and `@` (dereference).
-- **Postfix:** `.field` field access, chainable (`a.b.c`).
+- **Postfix:** `.field` field access, chainable (`a.b.c`). Auto-dereferences struct pointers (`ptr.field` where `ptr` is a `Struct*`).
 - **Calls:** `name(arg1, arg2, ...)`.
 - **Casts:** `(type)expr`, e.g. `(u16)x`.
 - **Grouping:** `(expr)`.