coolguy
fb65152901
The milestone structure had stopped describing the compiler and started
shaping it: m7.c, check_m7.c, tests/m2..m9, and a checker and emitter that had
each grown past 2,500 lines because there was nowhere else to put anything.
Restart from the pipeline instead.
What is left is the front end -- lexer, parser, types, ownership, semantic
analysis -- and the fixtures that describe it. The C backend, the DOSBox-X
runner, the milestone registry and the batch build are removed. The driver now
stops after semantic analysis; a code generator attaches where emit_c did.
Fixtures move from milestone directories to what they check:
parse/ grammar own/ ownership and borrowing
types/ type rules optional/ optionals and error unions
format/ formatting, try units/ units and visibility
generic/ generics pending-backend/
pending-backend/ holds the three fixtures that can only be checked by running
a program -- that the bounds check traps, that --no-checks removes it, and that
drops and defers actually fire, verified through a fake allocator. Those are
not front-end tests and are not pretending to be; they come back first when
there is a code generator.
tests/run.py replaces the DOSBox-X harness. It builds the front end with the
pinned Watcom's Windows-hosted driver and runs every fixture in about two
seconds, and it does something the old runner structurally could not: it reads
the `// ERROR:line:text` marker each fixture carries and checks the diagnostic
against it. Those markers have been in the tree all along, unverified, because
DOS could not redirect the compiler's stderr and only the exit code was ever
compared.
133/188 pass. The 55 failures are not regressions -- they are what was already
true and invisible:
- units (27) and generic (23): `import`, `comptime` and generic declarations
parse and are then dropped on the floor. No pass looks at them. The old
registry did not list these fixtures at all, so nothing said so.
- five in own/, optional/ and generic/: a marker disagrees with the diagnostic
about the line or the wording. Each is either a wrong marker or a wrong
diagnostic and has to be read individually.
Everything removed is in git history.
102 lines
3.5 KiB
C
102 lines
3.5 KiB
C
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
|
|
#undef malloc
|
|
#undef free
|
|
|
|
extern void *malloc(size_t size);
|
|
extern void free(void *p);
|
|
|
|
/* `run` returns !i32, which lowers to { error, value }. */
|
|
struct fe_result_value_9 { unsigned short e; long v; };
|
|
extern struct fe_result_value_9 fe_m5_runtime_run(long mode);
|
|
extern unsigned short fe_m5_runtime_conditional(unsigned char flag);
|
|
extern unsigned short fe_m5_runtime_argument_cleanup(void);
|
|
extern unsigned short fe_m5_runtime_owned_slice(unsigned long n);
|
|
extern unsigned short fe_m5_runtime_replace_field(void);
|
|
extern unsigned short fe_m5_runtime_loop_cleanup(void);
|
|
extern unsigned short fe_m5_runtime_try_cleanup(void);
|
|
extern unsigned short fe_m5_runtime_field_order(void);
|
|
extern unsigned short fe_m5_runtime_defer_order(void);
|
|
extern unsigned short fe_m5_runtime_match_cleanup(unsigned char flag);
|
|
extern unsigned short fe_m5_runtime_close_once(void);
|
|
extern unsigned short fe_m5_runtime_reassign_struct(void);
|
|
|
|
static void *live_ptrs[64];
|
|
static unsigned live_count;
|
|
static unsigned alloc_count;
|
|
static unsigned free_count;
|
|
static unsigned double_free_count;
|
|
static long fail_after = -1;
|
|
static unsigned malloc_attempts;
|
|
static int track_order;
|
|
static void *order_ptrs[2];
|
|
static unsigned order_allocs;
|
|
static unsigned order_frees;
|
|
static unsigned order_bad;
|
|
|
|
void *m5_malloc(size_t size)
|
|
{
|
|
void *p;
|
|
if (fail_after >= 0 && (long)malloc_attempts++ == fail_after) return 0;
|
|
p = malloc(size);
|
|
if (p && live_count < 64) live_ptrs[live_count++] = p;
|
|
if (p) ++alloc_count;
|
|
if (p && track_order && order_allocs < 2) order_ptrs[order_allocs++] = p;
|
|
return p;
|
|
}
|
|
|
|
void m5_free(void *p)
|
|
{
|
|
unsigned i;
|
|
if (!p) return;
|
|
for (i = 0; i < live_count; ++i) {
|
|
if (live_ptrs[i] == p) {
|
|
if (track_order && order_frees < 2 &&
|
|
p != order_ptrs[1-order_frees]) ++order_bad;
|
|
if (track_order && order_frees < 2) ++order_frees;
|
|
live_ptrs[i] = live_ptrs[--live_count];
|
|
++free_count;
|
|
free(p);
|
|
return;
|
|
}
|
|
}
|
|
++double_free_count;
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
struct fe_result_value_9 r;
|
|
r = fe_m5_runtime_run(0); if (r.e != 0 || r.v != 0) return 1;
|
|
r = fe_m5_runtime_run(1); if (r.e != 0 || r.v != 9) return 2;
|
|
r = fe_m5_runtime_run(2); if (r.e != 0 || r.v != 0) return 3;
|
|
if (fe_m5_runtime_conditional(0) != 0) return 4;
|
|
if (fe_m5_runtime_conditional(1) != 0) return 5;
|
|
if (fe_m5_runtime_argument_cleanup() != 0) return 6;
|
|
if (fe_m5_runtime_owned_slice(17) != 0) return 7;
|
|
if (fe_m5_runtime_replace_field() != 0) return 8;
|
|
if (fe_m5_runtime_loop_cleanup() != 0) return 9;
|
|
fail_after=1;
|
|
malloc_attempts=0;
|
|
if (fe_m5_runtime_try_cleanup() == 0) return 10;
|
|
fail_after=-1;
|
|
track_order=1;
|
|
order_allocs=order_frees=order_bad=0;
|
|
if (fe_m5_runtime_field_order() != 0) return 11;
|
|
track_order=0;
|
|
if (order_allocs != 2 || order_frees != 2 || order_bad != 0) return 12;
|
|
track_order=1;
|
|
order_allocs=order_frees=order_bad=0;
|
|
if (fe_m5_runtime_defer_order() != 0) return 13;
|
|
track_order=0;
|
|
if (order_allocs != 2 || order_frees != 2 || order_bad != 0) return 14;
|
|
if (fe_m5_runtime_match_cleanup(0) != 0) return 15;
|
|
if (fe_m5_runtime_match_cleanup(1) != 0) return 16;
|
|
if (fe_m5_runtime_close_once() != 0) return 17;
|
|
if (fe_m5_runtime_reassign_struct() != 0) return 18;
|
|
if (double_free_count != 0) return 19;
|
|
if (live_count != 0) return 20;
|
|
if (alloc_count != free_count) return 21;
|
|
return 0;
|
|
}
|