// Records with inheritance, packing, alignment
type
  Base = record
    x: int32;
    y: int32;
  end;

  Derived = record(Base)
    z: int32;
  end;

  Packed = record packed
    a: int8;
    b: int32;
  end;

// Overlays (C unions)
  Value = overlay
    asInt: int64;
    asFloat: float64;
  end;

// Bit fields for hardware/protocol work
  StatusReg = record
    ready: uint32 : 1;
    mode:  uint32 : 3;
    data:  uint32 : 8;
  end;

// Record literals -- named initialization
var pt: Base = Base(x: 42, y: 99);

// if/then/else with end
if x > 0 then
  println("positive");
else
  println("non-positive");
end;

// for with to/downto
for i := 1 to 10 do
  total += i;
end;

// while loop
while count < 100 do
  count += 1;
end;

// repeat..until
repeat
  count += 1;
until count >= 10;

// match with ranges and multi-labels
match value of
  0:        println("zero");
  1, 2, 3: println("low");
  4..10:   println("mid");
else
  println("high");
end;

// Four module kinds
module exe  myapp;      // executable
module dll  mylib;      // shared library (DLL/SO)
module lib  mystaticlib;// static library
module unit myutils;    // importable unit

// Import and use with full qualification
import myutils;
println("version = %d", myutils.UTIL_VERSION);
println("add = %d", myutils.util_add(3, 4));

// Public/private visibility
public const VERSION: int32 = 1;
const SECRET: int32 = 42; // private

public routine add(a: int32; b: int32): int32;
begin
  return a + b;
end;

// Module lifecycle
initialize
  println("starting up...");
end;

finalize
  println("shutting down...");
end;

// guard/except/finally -- catches software AND hardware exceptions
guard
  result := a div b;
except
  println("error: code={}, msg={}", exccode(), excmsg());
finally
  cleanup();
end;

// Throw with message or code
throw("something went wrong");
throwcode(404, "resource not found");

// Hardware exceptions caught automatically
guard
  x := 10 div 0;  // divide by zero
except
  println("caught: {}", excmsg());
  // prints: "Divide by zero"
end;

// Exception propagation across modules
guard
  myutils.dangerous_operation();
except
  println("caught from unit: {}", excmsg());
end;

// External clause -- bind to any C library
routine clink abs_val(const n: int32): int32;
  external "c" name "abs";

// Windows API
routine clink GetTick(): uint64;
  external "kernel32" name "GetTickCount64";

// Third-party library via const
const RAYLIB: string = "raylib";
routine clink InitWindow(w: int32; h: int32;
  title: pointer); external RAYLIB;

// Raw C++ injection
cppstart header
#include <cmath>
cppend

// Inline C++ expressions
var sq: float64 = cpp("std::sqrt(2.0)");

// Conditional compilation for platform code
@ifdef TARGET_WIN64
  println("tick: {}", GetTick());
@endif

// Built-in unit testing framework
module exe mathlib;

@unittestmode on;

routine add(a: int32; b: int32): int32;
begin
  return a + b;
end;

end.

// Test blocks appear after end.
test "add returns correct sum"
begin
  asserteq(5, add(2, 3));
  asserteq(-2, add(-5, 3));
end;

test "add handles zero"
begin
  asserteq(0, add(0, 0));
  asserttrue(add(1, -1) = 0);
end;