11a — Beispiel: Bootstrap Core Seed in JDL

Status: Informativer Entwurf
Geltungsbereich: Beispielsyntax für jade::core::bootstrap
Ergänzt: 11-bootstrap-seeding-praegung.md

---

Zweck

Dieses Dokument zeigt beispielhaft, wie der Bootstrap Core als JDL-Quelle aussehen könnte.

Die Syntax ist bewusst konservativ. Das Beispiel ist kein endgültiger Grammatikvorschlag, sondern eine ableitbare Zielgestalt für das BootstrapSeedBackend.

---

Beispiel

module jade::core::bootstrap

// ------------------------------------------------------------
// Primitive classes and representation tags
// ------------------------------------------------------------

tag PrimitiveKind : enum =
    | Bool
    | SignedInteger
    | UnsignedInteger
    | Float
    | String

 tag RegisterKind : enum =
    | Immediate64
    | InlineValue
    | Handle

 tag BoundaryKind : enum =
    | Immediate64
    | IndirectValue
    | Handle

 tag OverflowMode : enum =
    | Trap
    | Wrap
    | Checked

 tag LiteralKind : enum =
    | Integer
    | Float
    | String
    | Bool

 typefn PrimitiveClass(kind: PrimitiveKind) = <{ primitive_class: kind }>
 typefn Bits(n: usize) = <{ bits: n }>
 typefn Size(n: usize) = <{ size: n }>
 typefn Align(n: usize) = <{ align: n }>
 typefn Register(kind: RegisterKind) = <{ register: kind }>
 typefn Boundary(kind: BoundaryKind) = <{ boundary: kind }>
 typefn Literal(kind: LiteralKind) = <{ literal: kind }>
 typefn Overflow(mode: OverflowMode) = <{ overflow: mode }>
 typefn Default(value) = <{ default: value }>
 typefn Min(value) = <{ min: value }>
 typefn Max(value) = <{ max: value }>

// ------------------------------------------------------------
// Memory / ownership / drop policy domains
// ------------------------------------------------------------

tag OwnPolicy : enum =
    | Unique
    | Shared
    | Weak

tag SharePolicy : enum =
    | Local
    | Send
    | Sync

tag MemoryPolicy : enum =
    | Value
    | Rc
    | Arena
    | Pool

tag DropKind : enum =
    | Trivial
    | Custom

typefn Own(policy: OwnPolicy) = <{ own: policy }>
typefn Share(policy: SharePolicy) = <{ share: policy }>
typefn Memory(policy: MemoryPolicy) = <{ memory: policy }>
typefn Drop(kind: DropKind) = <{ drop: kind }>

// ------------------------------------------------------------
// Primitive descriptors
// ------------------------------------------------------------

type bool : primitive
    :> PrimitiveClass(Bool)
    :> Bits(1)
    :> Size(1)
    :> Align(1)
    :> Register(Immediate64)
    :> Boundary(Immediate64)
    :> Literal(Bool)
    :> Default(false)
    :> Memory(Value)
    :> Drop(Trivial)

type u32 : primitive
    :> PrimitiveClass(UnsignedInteger)
    :> Bits(32)
    :> Size(4)
    :> Align(4)
    :> Register(Immediate64)
    :> Boundary(Immediate64)
    :> Literal(Integer)
    :> Overflow(Trap)
    :> Default(0)
    :> Min(0)
    :> Max(4294967295)
    :> Memory(Value)
    :> Drop(Trivial)

type i32 : primitive
    :> PrimitiveClass(SignedInteger)
    :> Bits(32)
    :> Size(4)
    :> Align(4)
    :> Register(Immediate64)
    :> Boundary(Immediate64)
    :> Literal(Integer)
    :> Overflow(Trap)
    :> Default(0)
    :> Min(-2147483648)
    :> Max(2147483647)
    :> Memory(Value)
    :> Drop(Trivial)

type u64 : primitive
    :> PrimitiveClass(UnsignedInteger)
    :> Bits(64)
    :> Size(8)
    :> Align(8)
    :> Register(Immediate64)
    :> Boundary(Immediate64)
    :> Literal(Integer)
    :> Overflow(Trap)
    :> Default(0)
    :> Min(0)
    :> Max(18446744073709551615)
    :> Memory(Value)
    :> Drop(Trivial)

type f64 : primitive
    :> PrimitiveClass(Float)
    :> Bits(64)
    :> Size(8)
    :> Align(8)
    :> Register(Immediate64)
    :> Boundary(Immediate64)
    :> Literal(Float)
    :> Default(0.0)
    // Float-Grenzen sollten im realen Seed besser als Bits codiert werden.
    :> Memory(Value)
    :> Drop(Trivial)

// String ist user-facing primitive, aber nicht Immediate.
// Der echte Descriptor muss klären, ob der leere String symbolisch oder interned ist.
type str : primitive
    :> PrimitiveClass(String)
    :> Register(Handle)
    :> Boundary(Handle)
    :> Literal(String)
    :> Memory(Rc)
    :> Drop(Custom)

// ------------------------------------------------------------
// Core ids
// ------------------------------------------------------------

type TypeId : struct {
    raw: u32
} :> Memory(Value) :> Drop(Trivial)

type SymbolId : struct {
    raw: u32
} :> Memory(Value) :> Drop(Trivial)

type HandleId : struct {
    index: u32
    generation: u32
} :> Memory(Value) :> Drop(Trivial)

// ------------------------------------------------------------
// Minimal algebraic types
// ------------------------------------------------------------

type Option[T] : enum =
    | Some(T)
    | None

type Result[T, E] : enum =
    | Ok(T)
    | Err(E)

// ------------------------------------------------------------
// Minimal bootstrap diagnostics
// ------------------------------------------------------------

type BootstrapPhase : enum =
    | Seed
    | Loader
    | TypeEngine
    | MemoryEngine
    | VM

type Severity : enum =
    | Error
    | Warning
    | Info

type SourceSpan : struct {
    file: u32
    start: u32
    end: u32
} :> Memory(Value) :> Drop(Trivial)

type BootstrapDiagnostic : struct {
    phase: BootstrapPhase
    severity: Severity
    code: u32
    span: Option[SourceSpan]
} :> Memory(Value) :> Drop(Trivial)

// ------------------------------------------------------------
// Primitive operations / intrinsic ids
// ------------------------------------------------------------

// Diese Form ist illustrativ. Ob CoreOps eigene Decls, Meta-Records
// oder generierte Tabellen aus PrimitiveClass werden, ist eine
// Implementierungsentscheidung.

coreop i32.add {
    symbol: "+"
    lhs: i32
    rhs: i32
    result: i32
    lowering: CoreIntAdd
    overflow: Trap
}

coreop u32.add {
    symbol: "+"
    lhs: u32
    rhs: u32
    result: u32
    lowering: CoreUIntAdd
    overflow: Trap
}

intrinsic jade::vm::trap {
    id: 1
    params: [u32]
    result: ()
    domain: VM
}

intrinsic jade::jme::retain {
    id: 2
    params: [HandleId]
    result: ()
    domain: JME
}

intrinsic jade::jme::release {
    id: 3
    params: [HandleId]
    result: ()
    domain: JME
}

---

Hinweise

1. primitive, coreop und intrinsic sind hier nur im BootstrapSeedBuild-Kontext zulässig.
2. Normales User-JDL darf keine neuen Primitive definieren.
3. Das Seed-Beispiel erzeugt keine ausführbaren Protos.
4. Das Seed-Beispiel erzeugt Deskriptoren und Tabellen.
5. Der echte Seed sollte so wenig wie möglich enthalten. Wer hier Map oder Generator hineinzieht, sollte zur Strafe drei Wochen Build-Systeme debuggen.