When the LHS of a class-typed assignment is a local slot that has not
yet been written within the function entry block, EmitVarAllocs has
just zeroed it via `storel 0, %_var_X`. Releasing nil is a no-op at
runtime but still pays a function call + ret per assignment. Skip
the load+release entirely in this case; only the addref+store
remain.
Tracking is conservative:
* `FArcSlotWritten` is cleared at every function start.
* `ArcSlotIsNil(X)` is True only while we are still in the @start
block and X has not been written.
* Any new label (branch/loop/case body) ends the elision window for
all slots; that prevents leaking a value written along a branch we
did not see.
* Globals, var-params and mem2reg-promoted locals are excluded.
Impact on `tests/bench_lists.pas` (Ryzen 7 5800X):
TList<TObject> hand-rolled scan x 1000: 131 ms -> 90 ms (~30%)
Sequential Get(i) x 1_000_000: 6 ms -> 5 ms
Random Get(i) x 1_000_000: 13 ms -> 12 ms
The IR for `TList<T>.Get` now shows a single AddRef call instead of
the prior AddRef+Release pair on the Result slot.
Adds three IR tests in cp.test.arc covering: first-store elision,
second-store still-releases, and post-branch still-releases.
All 2112 tests pass; fixpoint clean at stage-3/stage-4.
Linear scan over FData returning the index of the first equal element
or -1 when not found. Matches the semantics of TSet<T>.IndexOf which
the rest of the unit already exposes, and saves callers from writing
the hand-rolled scan that bench_lists.pas demonstrates.
Adds two e2e tests covering the integer/found and string/not-found
paths.
The multi-instance generic miscompile that forced the two-program
split is fixed (b6736d3), so the four workloads now run in a single
program: TStringList, TList<String>, TObjectList, TList<TObject>.
Add a fresh results entry on the post-fix compiler; timings are
within noise of the split run on the same hardware.
Generic instance method bodies were shared via OwnBody=False, so a
single TBlock AST was annotated by the semantic analyser once for each
instance in turn. The Resolved* annotations on the shared body ended
up reflecting whichever instance was analysed last, causing call
targets in earlier instances to point at later instances' helpers —
e.g. TList<String>.Add would emit `call $TList_TObject_Grow` and skip
$_StringAddRef on the value parameter.
Add CloneBlock/CloneStmt/CloneExpr in uAST.pas covering all node types
that can appear inside a method body (~26 expr/stmt forms plus block-
level Var/Const/Type/Proc decls). Annotations are deliberately not
copied — each instance re-runs semantic analysis on its own AST.
Wire the clone into InstantiateGeneric and InstantiateGenericFunction
so each instance owns its body.
Adds TestCodegen_Generic_TwoInstances_MethodCallsResolveToOwnInstance
to lock in: with TBox<Integer> and TBox<String> in one program, the
emitted TBox_Integer_Init body must contain
`call \$TBox_Integer_SetValue` and the TBox_String_Init body must
contain `call \$TBox_String_SetValue`. Previously both bodies called
the String instance's helper.
Verified: 2107 tests pass; fixpoint clean; the two-instance benchmark
scenario (TList<String> + TList<TObject> in one program) now compiles
and runs correctly.
A program that instantiated the same generic class with two different
concrete arguments (e.g. TList<String> and TList<TObject>) failed at
semantic analysis with 'Type mismatch: expected ''^T'' but got
''^TObject'''. Two compounding causes:
- FindTypeOrInstantiate cached compound types ('^T', 'array of T',
'class of T', 'array[lo..hi] of T') under the literal input string.
When 'T' was a scope-bound type parameter the cached entry pinned
the first instance's resolution ('^String'), so a second
instantiation that bound T to a different type re-used the wrong
entry. Key these caches by the canonical element-type name
('^String', 'array of TObject', ...) so each (constructor + element)
pair has its own slot.
- AnalyseMethodCallExpr mutated AExpr.ObjectName to the resolved class
name ('TFoo<T>' -> 'TFoo<String>') on first analysis. Because
cloned generic methods share the body AST (NewMDecl.OwnBody := False
in InstantiateGeneric), the mutation was visible to the next
instance's analysis and made it look up the wrong concrete class.
Only normalise casing when the lookup hit the original spelling;
otherwise keep the template form and pass the resolved name to
overload resolution via a local.
A separate codegen issue still affects per-instance method body
emission when the body is shared — each function is emitted but the
shared body's call-target annotations come from whichever instance
was analysed last, so e.g. TList<String>.Add can end up calling
TList<TObject>.Grow. Tracked separately; needs per-instance body
cloning to fix properly.
Micro-benchmark comparing the legacy list types against the generic
list equivalents introduced for self-hosting. Logs the median of two
runs to tests/bench_lists_results.txt for trend tracking — append a
new dated section after each meaningful runtime or codegen change.
Phases per container: bulk insert (1M), sequential read, random read
(1M), for..in iteration (strings only), and indexed lookup (IndexOf or
hand-rolled scan). Initial run on AMD Ryzen 7 5800X shows TList<String>
beating TStringList across the board, while TObjectList still beats
TList<TObject> on writes and on IndexOf — the latter by ~8x due to
direct pointer-scan vs. one Get call per element.
EmitPointerWrite emitted retain+release for tyString but had no parallel
case for tyClass. Storing a class reference through a typed pointer
('PItem^ := SomeObj' where PItem: ^TItem) therefore left the slot
without a strong reference, so the object was freed as soon as the
original holder dropped its ref — subsequent reads returned dangling
memory.
This surfaced when TList<TObject>.Add stored items through its 'FData:
^T' backing buffer: every Get returned garbage once the caller reused
the local variable that had supplied the value. TList<String> worked
because the string path was already in place.
Add the symmetric tyClass branch.
Wires up for..in on TList<T> from generics.collections. Two compiler
fixes were required:
- uSemantic: TClassName<T>.Method(args) inside a generic method body
failed to resolve because AnalyseMethodCallExpr looked up the literal
name with the unsubstituted type parameter. Now mirrors the existing
field-access path: if the receiver name contains '<' and lookup fails,
apply ResolveScopeBoundTypeParams + FindTypeOrInstantiate before
re-trying the lookup.
- uCodeGenQBE: constructor-with-args path emitted
$_FieldCleanup_TListEnumerator<String> with literal angle brackets
which QBE rejects. Mangle the class name like the no-arg path
already does.
InstantiateGeneric did not assign RT.Parent, CopyVTableFrom parent, or
copy parent fields onto the synthesised TRecordTypeDesc. With no parent
vtable copied in, RT.HasVTable returned false for every generic
instance, so the codegen skipped emitting $vtable_<T> while the
typeinfo emitter still referenced it — producing an unresolved symbol
at link time for any program that used TList<X>, TStack<X>, TQueue<X>,
TSet<X>, TDictionary<K,V>, etc. from generics.collections.
Mirror the regular class-resolution path in AnalyseProgramTypes: look
up the explicit parent (or fall back to TObject when no parent name is
given), set RT.Parent, CopyVTableFrom the parent so Destroy/ToString
slots are inherited, and copy the parent's fields so FindField sees
them. The order is preserved — parent-wiring runs before the vtable
slot pre-pass which runs before field resolution, so TotalSize
correctly accounts for the 8-byte vptr.
Add cp.test.e2e.tlist.pas — the first e2e coverage of a stdlib
generic class. IR-only tests would not have caught this because the
link step is what failed.
FindProperty and FindIndexedProperty searched only the current class's
own Properties list, so a subclass could not see properties declared on
its ancestors. Inherited fields work because parent fields are copied
into the child during class resolution, but properties are not copied —
they must be discovered via inheritance walking, as FindMethodDecl
already does.
Fixes#45.
Class methods in a program could not access program-level globals because
AnalyseBlock analysed method bodies before pushing the block scope and
registering its var declarations. Units were unaffected because
AnalyseUnit already registers impl-section vars first.
Closes#43.
Constructor calls like TFoo.Create(arg) were using FindMethodDecl, which
returns the first MethodDecl indexed for the TypeName.MethodName key.
With overloaded constructors that share a name (e.g. one-arg Create vs
two-arg Create), the picked candidate may have a higher arity than the
call site. AppendDefaultArgs then fails on the unfilled parameters
with "No default value for parameter 'X' of 'Create'" — even though a
matching lower-arity overload exists.
Reproduces with a class declaring Create(A, B) before Create(A): the
two-arg overload is indexed first and chosen for a one-arg call site.
Replace FindMethodDecl with ResolveMethodOverload at the constructor
call site; fall back to FindMethodDecl when the resolver returns nil
(extern/RTL constructors not registered in FMethodIndex).
Adds IR tests in cp.test.overload.pas and an E2E test in
cp.test.e2e.classes2.pas that exercise the declaration-order-sensitive
case.
Original contribution from Andrew Haines <andrewd207@aol.com>
(https://github.com/andrewd207/blaise_llvm/commit/c2a3bbed).
Subscript assignment into managed-element arrays (string or class)
emitted only a raw store, leaking the new value's refcount and dropping
the old value's release. After two writes to the same slot, the first
value was leaked and the program ran with an unbalanced refcount.
EmitStaticSubscriptAssign now emits the standard retain-new / release-
old pair before the store, for both the dynamic-array branch and the
static-array branch.
Regression coverage in cp.test.staticarray:
- TestCodegen_StaticArray_StringWrite_EmitsARC
- TestCodegen_StaticArray_ClassWrite_EmitsARC
- TestCodegen_DynArray_StringWrite_EmitsARC
- TestCodegen_DynArray_ClassWrite_EmitsARC
Original contribution from Andrew Haines (andrewd207).
A 'procedure of object' value is a 16-byte TMethod (Code+Data), but
TTypeDesc.ByteSize/RawSize fell through to 8 for procedural fields,
and EmitFieldAssignment stored a single 8-byte pointer instead of
memcpy-ing the 16 bytes inline. Reading the field then dereferenced
freed stack memory and crashed at runtime.
Fix in three places:
- uSymbolTable.ByteSize/RawSize: return 16 for IsMethodPtr
- EmitFieldAssignment: memcpy 16 into the field address
- Field-read paths (class + record): return field address for
method-ptr fields so callers treat the field storage as the value
Regression coverage in cp.test.proctypes_ofobject:
- TestSemantic_MethodPtr_ByteSizeIs16
- TestSemantic_BareProcPtr_ByteSizeIs8
- TestCodegen_MethodPtrField_AssignUsesMemcpy16
- TestCodegen_MethodPtrField_RecordTotalSizeIncludes16
- TestE2E_MethodPtrField_RoundTrip (class field round-trip)
Original contribution from Andrew Haines (andrewd207).
Remove EmitExcPathArcCleanup from the try/finally exception path.
The cleanup was releasing and nilling all ARC-managed variables (strings,
objects) before re-raising the exception, which destroyed variable state
that the outer except handler needed to read.
Root cause: the finally-exception path ran _StringRelease + storel 0 on
every in-scope ARC variable before calling _Reraise. When a try/finally
was nested inside a try/except, the outer handler saw nil strings and
objects instead of the values set by the try body and finally body.
The function-exit block already handles final ARC cleanup for all
variables, so the premature cleanup on the exception path was both
redundant and incorrect.
Added E2E test TestRun_FinallyStringMutation_SurvivesReraise that
verifies string mutations in the finally block are visible after
re-raise to the outer except handler (matching FPC behaviour).
2084 tests pass, fixpoint verified (stage-3/stage-4).
Port all exception frame management, type identity, and runtime check
functions from C to pure Pascal (blaise_exc.pas). Replace libc
setjmp/longjmp with a minimal custom implementation in x86_64 assembly
(blaise_setjmp_x86_64.s, ~40 lines) that saves only the 8 callee-saved
registers (64-byte jmp_buf vs libc's 200-byte one).
This eliminates the last C source file from the runtime build. The only
non-Pascal code in the runtime is now the assembly setjmp stub.
Changes:
- runtime/src/main/asm/blaise_setjmp_x86_64.s: _blaise_setjmp/_blaise_longjmp
- runtime/src/main/pascal/blaise_exc.pas: _PushExcFrame, _PopExcFrame,
_Raise, _Reraise, _CurrentException, _CurrentExceptionMessage,
_IsInstance, _ImplementsInterface, _GetItab, _Raise_InvalidCast,
_CheckNil — all ported from blaise_exc.c
- uCodeGenQBE.pas: emit call $_blaise_setjmp instead of call $setjmp
- cp.test.exceptions.pas: IR assertion updated for new symbol name
- runtime/Makefile: assembly rule, Pascal blaise_exc build, C rules removed
- .gitignore: whitelist runtime/src/main/asm/*.s
- runtime/src/main/c/blaise_exc.c: deleted
2083 tests pass, fixpoint verified (stage-3/stage-4).
Move _ClassAlloc, _ClassRelease, _StringReleaseCheck, and
_AbstractMethodError from C into blaise_arc.pas. Uses
TFieldCleanupProc procedure type to call the compiler-emitted
field cleanup function pointer from the class header.
Only blaise_exc.c (setjmp/longjmp) remains in C — everything
else in the runtime is now pure Pascal.
All 2083 tests pass. Fixpoint verified.
Merge blaise_io.pas, blaise_process.pas, blaise_sys.pas, and
blaise_time.pas into the OO platform facade (TRtlPlatformPosix).
All underscore ABI stubs now delegate through GRtlPlatform, enabling
future macOS/Windows/FreeBSD support via a single new TRtlPlatformXxx
subclass with no ifdefs or scattered platform files.
Key design decisions:
- _SetArgs creates GRtlPlatform eagerly (runs before unit _init)
- Path utilities stay in blaise_str.pas (platform-independent)
- Makefile sed strip keeps TObject typeinfo from program section
- Shared string helpers (StrAlloc, StrFromCStr) deduplicated
Deleted 8 files (4 units + 4 build drivers), replaced by the
expanded rtl.platform.posix.pas and its single build driver.
All 2083 tests pass. Fixpoint verified.
Mark all 26 E2E test classes with the [Threaded] attribute. The test
runner now launches each [Threaded] suite as an independent subprocess
in parallel, then collects and merges results after in-process tests
finish. Wall-clock test time drops from ~15s to ~3s.
Changes:
- blaise.testing: add ThreadedAttribute, TTestResult.MergeFrom
- blaise.testing.runner.text: launch all [Threaded] suites via TProcess
up front, run in-process tests, then collect subprocess output and
parse verbose results back into the main TTestResult
- cp.test.e2e.*.pas: add [Threaded] annotation to all 26 E2E classes
The destructor and the compiler-generated _FieldCleanup function both
released ARC-managed class fields, causing a double-free that corrupted
the arena freelist. After ~100 create/destroy cycles the corruption
manifested as a garbage string header in an unrelated TStringList.
Two changes:
- EmitFieldCleanupFn: store nil into each field slot after releasing it
- EmitMethodCall ObjExpr .Free path: compute the field address via
EmitLValueAddr, release, then nil — matching the IsImplicitSelf path
With both sites nilling after release, the second release loads nil and
_ClassRelease returns immediately.
Implement Delphi-style custom attributes: TCustomAttribute base class,
[AttrName] syntax on class declarations, attribute RTTI emission, and
the HasClassAttribute(AClass, AAttrClass) builtin for runtime queries.
Pipeline changes:
- uAST: add Attributes: TStringList to TClassTypeDef
- uParser: parse [Attr] before type names (ParseTypeSection loop now
accepts tkLBracket; ParseTypeDecl collects and copies to class def)
- uSymbolTable: register TCustomAttribute builtin; add ClassAttributeCount/
ClassAttributeAt accessors to TRecordTypeDesc
- uSemantic: resolve attribute names using Delphi suffix convention
([Threaded] matches ThreadedAttribute); semantic error for unknown attrs;
[Weak] remains compiler-intrinsic and is skipped; add HasClassAttribute
builtin handler in AnalyseFuncCallExpr
- uCodeGenQBE: extend typeinfo from 7 to 8 l-slots (slot 7 = $attrs_T or 0);
emit $attrs_T count+typeinfo-ptr tables; emit TCustomAttribute vtable and
field-cleanup stubs unconditionally; emit HasClassAttribute as a call to
$_HasClassAttribute
- blaise_arc: implement _HasClassAttribute — reads slot 7, scans the attrs
table, walks the parent chain so inherited attributes are visible
19 tests in cp.test.attributes.pas covering parser, semantic, codegen, and
four E2E round-trips. Updated cp.test.publishedrtti.pas for 8-slot layout.
Add blaise_thread.pas runtime unit wrapping pthread_create, pthread_join,
pthread_mutex_init/lock/unlock/destroy and sysconf for GetCPUCount.
Implement TThread (Create, Start, Terminate, WaitFor, Execute virtual,
FreeOnTerminate) and TCriticalSection (Enter/Leave) in classes.pas using
ARC-safe ref counting in the thread trampoline.
Fix EmitFieldCleanupFn to walk the parent chain when emitting the Destroy
call — previously a subclass without its own Destroy would generate an
empty cleanup, causing leaked resources from parent destructors.
Link -lpthread in both the compiler driver and E2E test base.
Include 7 E2E tests covering basic execution, WaitFor blocking, Terminate
flag, Finished flag, multiple threads, mutex-protected counter, and
inherited Destroy cleanup.
Binary expressions involving Single operands always emitted d-typed (Double)
QBE instructions, causing QBE to reject mixed s/d operands. Now the codegen
respects the resolved float type: Single op Single emits =s ops, Single op
Double widens the Single operand via exts before =d ops, and Single comparisons
use s-suffixed comparison opcodes (clts, cgts, etc.).
Delphi and FPC allow assigning an integer value to a Double or Single
variable without an explicit cast. Blaise previously rejected this as a
type mismatch. Add an IsFloat/IsNumeric widening rule in the semantic
pass and emit the correct QBE conversions (swtof, sltof) in codegen for
both Double and Single targets.
Replace the C variadic _StringFormat with a pure Pascal _StringFormatN
that takes a format string, a pointer to an array of tag/value pairs,
and a count. The codegen allocates the arg array on the stack via
alloc8, stores (tag:l, value:l) pairs, and calls the non-variadic
function — eliminating the last dependency on C va_list.
This required a multi-stage bootstrap: release binary compiled stage-1
(with new codegen), stage-1 compiled stage-2 (self-hosted with new ABI),
then the C file could be safely removed. Integer args are widened via
extsw when w-typed to satisfy QBE's storel type checking.
Only 2 C files remain in the runtime: blaise_exc.c (setjmp/longjmp)
and blaise_arc_class.c (function-pointer dispatch).
Replace the C-based float support (_DoubleToStr, _SingleToStr,
_StrToDouble, _AbsInt, _AbsInt64) with a pure Pascal implementation
using a simplified Grisu1 algorithm (Loitsch 2010) for float-to-string
conversion and native double arithmetic for string-to-float.
The new implementation has no libc dependency for the conversion logic
itself (memcpy is still used in BlaiseAllocStr as a temporary measure).
This is a step toward full platform independence.
Also fix a codegen bug where Int64-to-Double promotion in mixed
arithmetic/comparison expressions emitted swtof (32-bit truncation)
instead of sltof (64-bit). This affected three sites in EmitBinExpr
and one in EmitAssignment.
Replace the C weak-reference table implementation with an equivalent
Pascal unit (blaise_weak.pas). Same data structures — open-chained
hash table with linked slot lists — using _BlaiseGetMem/_BlaiseFreeMem
and ^Pointer locals for the void** dereference pattern.
Deletes blaise_weak.c; runtime C files now down to 4 (blaise_arc_class,
blaise_exc, blaise_float, blaise_str_fmt).
All 2023 tests pass including E2E weak-ref Valgrind test. Fixpoint OK.
Step 13 (partial): replace four C shims with self-hosted Pascal units that
bind directly to libc syscall surfaces. blaise_exc.c, blaise_arc_class.c,
blaise_weak.c, blaise_str_fmt.c, and blaise_float.c remain in C — they
either need setjmp/longjmp, function-pointer fields in records, or
variadic interfaces that QBE / Blaise cannot express today.
Ports:
- blaise_io.c → blaise_io.pas
File I/O, env vars, working directory, ParamStr, mkstemp, sleep,
process ID. Uses libc bindings (open/read/write/stat/...) declared in
the interface section per the migration rule in CLAUDE.md.
- blaise_process.c → blaise_process.pas
fork/exec/pipe/waitpid wrapped as TProcess; same libc-binding pattern.
- blaise_sys_posix.c → folded into blaise_sys.pas
Tiny shim (just _SysWrite + _SysWriteNewline); now writes directly via
posix_write. No separate C file needed.
- blaise_time.c → blaise_time.pas
clock_gettime + date arithmetic. The local typed-array-const Days
triggered the codegen bug fixed in fa69ae1.
Each unit is built via a thin build_driver.pas program (see existing
blaise_str_build_driver.pas pattern): the Makefile compiles the driver,
strips everything from the program section onward, then assembles + links
the unit-only IR into the runtime archive.
Outcome:
- C_SRCS shrinks from 9 → 5 files; runtime archive size unchanged in
spirit but the dependency surface contracts.
- Standalone units, not yet folded into rtl.platform.posix.pas — that
consolidation can happen later when the platform layer matures and a
second backend (windows / darwin) appears to justify the abstraction.
- All 2023 tests pass; fixpoint OK.
A typed array constant declared inside a function body (or class method
body) had its element values held in TConstDecl.ArrayElements but no
`data $Name = { ... }` item was emitted in the data section. The function
code referenced `$Name` (e.g. `add $Days, %_t`), which produced
`undefined reference to Name` at link time.
EmitGlobalConstData walked only the top-level program/unit blocks; method
bodies were never visited. Add EmitLocalArrayConstsInBlock /
EmitLocalArrayConstsInTypeDecls / EmitLocalArrayConstsInProgram /
EmitLocalArrayConstsInUnit which sweep standalone procs and class/record
methods and emit any locally-declared typed array constants.
Wired into all four IR-emission sites: Generate / AppendProgram /
GenerateUnit / AppendUnit. GenerateUnit was also missing the existing
EmitGlobalConstData calls for IntfBlock/ImplBlock — added those for
consistency.
Tests:
- IR: TestArrayConst_LocalInFunction_EmitsDataItem,
TestArrayConst_LocalInProcedure_EmitsDataItem,
TestArrayConst_LocalInMethod_EmitsDataItem assert the IR contains
`data $Name =` for each scope.
- E2E: TestRun_Const_LocalArrayInFunction compiles+links+runs a program
whose function uses a local typed array constant and reads three
elements, verifying the full toolchain catches the link error.
Unblocks 36 previously-failing DateUtils e2e tests (blaise_time.pas
declared `Days: array[1..12] of Integer` inside _TimeDaysInMonth).
P[I] := #N (and any single-char string literal like 'A') in a byte-store
context lowered through the normal string-literal path, emitting a
1-byte string data item and storing the low byte of its data pointer
into the target slot — yielding the address byte, not Ord(N).
This corrupted NUL terminators written by RTL helpers such as StrAlloc
and StrFromCStr in blaise_io.pas, causing _FileExists (and any libc
function reading NUL-terminated strings) to see one byte of garbage
past the intended end.
Extend EmitByteRhs to recognise TStringLiteral of length 1 and emit
the Ord as a `=w copy N` constant, mirroring the existing Chr(N)
short-circuit. Both traps share the same root cause and now share
the same fix.
Tests:
- IR: TestCodegen_PCharSubscript_HashCharLiteralShortCircuit asserts
the IR contains no `storeb $__s` or `add $__s` patterns for
`p[0] := #0`.
- E2E: TestRun_PCharSubscript_HashCharLiteralAssignment compiles and
runs a program that builds 'ABCD' + #0 via per-byte writes and
verifies the resulting C string.
Dynamic arrays are now valid collection expressions in for..in loops.
Iteration is 0-based (Low=0, High=Length-1), guarded by a runtime
call to $_DynArrayLength so empty/nil arrays iterate zero times.
- uAST: add IsDynArrayIter flag to TForInStmt
- uSemantic: add tyDynArray branch (validates element/var type, injects
synthetic __idx_N slot, same pattern as static array path)
- uCodeGenQBE: add IsDynArrayIter codegen path (csltw index < length,
data-pointer arithmetic identical to static array)
- cp.test.forin: 7 new unit tests (semantic + IR codegen)
- cp.test.e2e.staticarray: 2 new E2E tests (filled array; empty/nil array)
Pascal is case-insensitive but QBE symbols are case-sensitive. The
parser stores source-level casing on AST nodes, and the codegen emits
those names as QBE symbols. When a variable declared as 'inFile' was
referenced as 'infile.Size', the definition emitted $inFile but the
reference emitted $infile, causing a linker error.
The previous commit (952667e) fixed this for method call names only.
This commit extends the fix to all remaining AST name fields that flow
to QBE symbol emission: TFieldAccessExpr.RecordName, TFieldAssignStmt
.RecordName, TMethodCallExpr.ObjectName, TMethodCallStmt.ObjectName,
TProcCallStmt.Name, TFuncCallExpr.Name, TForStmt.VarName, TForInStmt
.VarName (both paths), TArrayAssignStmt.ArrayName, TSupportsExpr
.OutVarName, and the @-operator path in AnalyseAddrOfExpr.
The compiler now reads unit-path entries from a config file so users
no longer need to pass --unit-path for the runtime and stdlib on every
invocation. Search order: next to the binary, then ~/.blaise.cfg.
Relative paths are resolved against the config file's directory.
Includes a dev-layout config in compiler/src/main/resources/ (PasBuild
copies it to compiler/target/ automatically), a new uConfig unit with
the parsing logic, and 12 unit tests for config parsing.
Two code paths in EmitExpr built method-call symbols by concatenating
FldAccess.FieldName (the raw source-code casing) instead of routing
through MethodEmitName which resolves via ResolvedQbeName. This caused
linker errors when a call site used different casing than the declaration
(e.g. Reader.readline vs ReadLine), since the emitted symbol name
wouldn't match the function definition.
Route both paths through MethodEmitName and add a fallback that uses
AMDecl.Name (the declared name) when ResolvedQbeName is unset.
High() and Low() rejected tyDynArray variables with a semantic error.
Added tyDynArray to the allowed-type sets in both builtins, and added a
tyDynArray codegen branch for High() that calls _DynArrayLength and
subtracts 1. Low() already falls through to the constant-zero path.
Assigning a Double or Single to an Integer variable (or vice-versa)
was silently accepted because CheckTypesMatch treated all numeric types
as interchangeable. This caused the raw bit-pattern of the float to
be reinterpreted as an integer, producing garbage values at runtime
(e.g. PI*2 assigned to Integer yielded 1413754136).
Split the numeric-widening rule into two:
- integers ↔ integers: still allowed (widening/narrowing)
- floats ↔ floats: allowed (Single ↔ Double promotion)
- float ↔ integer: now a type-mismatch error, matching FPC/Delphi
Callers that legitimately need float→integer conversion must use
Trunc, Round, Floor, or Ceil; integer→float conversion must use
Double() or Single() casts.
Fixesgraemeg/blaise#33
Registers five new trig intrinsics in the symbol table, semantic analyser,
and codegen. Single arguments emit the *f libc variants (asinf, acosf,
sinhf, coshf, tanhf); Double arguments emit the unprefixed variants.
Removes the now-implemented section from docs/future-improvements.adoc.
INT_LIT previously only covered plain decimal. Expand the Tokens section
to formally define all four bases ($hex, &octal, %binary, decimal) and
the underscore-separator placement rules. Add FLOAT_LIT as an explicit
token production (it was absent entirely). Character-class helpers
(dec_digit, hex_digit, oct_digit, bin_digit) are defined in the
accompanying block comment, consistent with the existing style for
letter/char/any_char.
Octal (&377) and binary (%11111111) integer literals were tokenised
correctly but silently misconverted at parse time because StrToInt64
does not accept & or % prefixes. A new ParseIntLiteral helper in
uStrCompat handles all four bases (decimal, $hex, %binary, &octal)
with explicit digit-by-digit conversion for binary and octal.
Numeric literals now also accept underscore separators between digits
(1_000_000, $FF_EC, %0010_0101, &3_77, 3.14_15) following the same
rules as Delphi and FPC: underscores may appear only between digits,
not at the start of the digit run, not adjacent to a decimal point, and
not at the end of a literal. The tokeniser (uPasTokeniser) accepts the
underscore in all four number branches; ParseIntLiteral and
StripUnderscores (for float values) strip them before conversion.
Fixed a secondary bug in uLexer: the float/int classification checked
for 'e'/'E' anywhere in the token, which caused hex literals containing
those letters (e.g. $FF_EC) to be misclassified as tkFloatLit. The
check is now gated on the absence of a $ / % / & prefix.
uStrCompat rewritten without {$IFDEF FPC} dead code; all callers
compiled by Blaise only since v0.8.0.
Adds 21 new tests: lexer token shape tests for all bases with/without
underscores, and TParseIntLiteralTests covering conversion correctness
and invalid-placement rejection.
The unit-loading block was guarded by `SearchPaths.Count > 0`, so a
program with a `uses` clause compiled silently when no search paths were
provided — missing units were never checked (issue #31).
Remove the spurious count guard so TUnitLoader.LoadAll is always called
when the program has used units. With an empty search-path list, Locate
returns '' for every unit name and EUnitNotFound is raised as expected.
Adds a regression test: TestUnitLoader_MissingUnit_NoSearchPaths_RaisesError.
A var declaration shadowing a same-block const (or a const declared
twice in the same block) was silently accepted instead of raising a
Duplicate identifier error.
Root cause: AnalyseBlock registers consts in the outer scope then pushes
a new inner scope before calling AnalyseVarDecls, so FTable.Define
(which only checks the current scope) could not detect the clash.
Fix: AnalyseVarDecls now scans the block's own ConstDecls list before
defining each var name. AnalyseConstDecls now treats a duplicate as an
error when the collision originates from an earlier const in the same
block; cross-unit const shadowing (e.g. a unit redefining a system.pas
constant) continues to be silently accepted.
Also removes the redundant LineEnding const from blaise.testing.pas —
it is already exported by system.pas.
Fixes: https://github.com/graemeg/blaise/issues/30
First release with a Pascal-native memory allocator: the compiler RTL,
codegen builtins, and all C runtime helpers now route through blaise_mem
(_BlaiseGetMem / _BlaiseFreeMem / _BlaiseReallocMem) instead of libc
malloc. Self-hosting fixpoint achieved on the multi-file source —
stage-2 and stage-3 IR both 135,311 lines, byte-identical.
Add bench_libc_malloc.pas with explicit external malloc/free/realloc
bindings so the libc baseline can still be measured after the cutover.
The original bench_blaise_mem.pas now measures blaise_mem too (because
the GetMem builtin emits _BlaiseGetMem), so it is no longer suitable
as a baseline.
Log the post-cutover state: blaise_mem now beats libc on small, mixed,
and retain-free-all workloads. Realloc growth remains 1.6x. The
compile-time win on the real test suite (~10%) exceeds the microbench
gap, suggesting real workloads are dominated by short-lived small
allocations where the freelist pop/push beats glibc tcache.
When _StringRelease decrements the refcount, also validate that the
header looks plausible: refcount >= -1 (else double-free), length in
[0, 1 GiB], and capacity >= length and below 1 GiB. On corruption,
write a clear message to stderr and abort instead of returning to
the wild segfault that would follow.
Added so the upcoming blaise_mem cutover investigation has a clear
failure signal when string ownership crosses an allocator boundary.
Benign on healthy programs.
All 1934 tests pass; fixpoint clean.
Static-array element stores omitted tyPChar from the storel case,
falling through to the default storew (32-bit). Writing a PChar
heap pointer through Arr[I] := P silently truncated to its low 32
bits; reading Arr[I] later produced a wild pointer and segfault.
Add tyPChar to all five static-array load/store case statements
(EmitGlobalVarData, EmitConstArrayElem load, open-array load,
dynamic-array load, static-array store, and array-literal alloc/
store). The default branches were already 'l' or 'storel' so no
silent misalignment elsewhere.
Tests:
- cp.test.e2e.pointers.TestRun_StaticArrayOfPChar_ElementPreservesAllBits
asserts a round-trip through array[0..1] of PChar preserves the
full 64-bit pointer.
All 1934 tests pass; fixpoint clean.
P[I] := Chr(N) used to emit `call $_Chr` (which allocates a heap string)
and then storeb of the pointer's low byte, yielding garbage instead of
N. Same bug applied to dynamic-array, static-array, and pointer-deref
byte stores.
Add EmitByteRhs helper that detects Chr(N) and emits the argument
directly as a w-typed value. Use it at all four storeb sites:
- PChar subscript write (P[I])
- dynamic-array byte/bool subscript write
- static-array byte/bool subscript write
- pointer write to byte/bool typed pointer (P^ :=)
Tests:
- cp.test.pchar.TestCodegen_PCharSubscript_ChrByteShortCircuit
asserts the IR has storeb and no call $_Chr
- cp.test.e2e.pointers.TestRun_PCharSubscript_ChrAssignment
asserts ABCD output instead of garbage
All 1933 tests pass.
