COMPILER_SOURCES := compiler/radiance.rad compiler/radiance/binary.rad

SEED_OPTS := $(STD) -pkg radiance $(patsubst %,-mod %,$(COMPILER_SOURCES)) -entry radiance

$(RAD_BIN): $(STD_LIB) $(COMPILER_SOURCES) | $(BIN_DIR)

/// Binary RIL file output and native loading.

mod binary;

constant MAX_LOADED_MODULES: u32 = module::MAX_MODULES;

    "usage: radiance -pkg <name> [-start <input.ras>] -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> [-emit ril] -o <output>\n       radiance -load <input.ril> [-start <input.ras>] [-mod <input.ras>] -o <output>\n";

    /// Write binary RIL instead of native instructions.

    emitIl: bool,

/// Accumulated RIL functions and the semantic entry selected during lowering.

record IlSinkContext {

    /// Stable function bodies owned by the lowering arena.

    functions: *mut [*il::Fn],

    /// Function marked with `@default` in the entry package.

    entry: ?*[u8],

    /// Storage for the function list.

    arena: *mut alloc::Arena,

}

    let mut emitIl = false;

        } else if mem::eq(arg, "-emit") {

            let mode = try nextArg(args, &mut idx, &["`-emit` requires `ril`"]);

            if not mem::eq(mode, "ril") {

                throw error(&["unknown output format", mode, "(expected: ril)"]);

            }

            set emitIl = true;

    if emitIl and (outputPath == nil or dump <> Dump::None) {

        throw error(&["`-emit ril` requires `-o` and cannot be combined with `-dump`"]);

    }

        if emitIl and (inputs[i].asmPathCount <> 0 or inputs[i].startupPath <> nil) {

            throw error(&["binary RIL cannot contain assembly; link assembly when loading the RIL"]);

        }

        emitIl,

/// Retain a lowered function and its entry role in an arena-owned RIL image.

fn collectLoweredFn(ctxPtr: *mut opaque, func: *il::Fn, role: lower::FnRole) {

    let ctx = ctxPtr as *mut IlSinkContext;

    ctx.functions.append(func, alloc::arenaAllocator(ctx.arena));

    if role == lower::FnRole::Default {

        set ctx.entry = func.name;

    }

}

/// Lower dependencies and the entry package into one binary RIL compilation unit.

) -> il::binary::Image throws (Error) {

    let entryPkg = try getEntryPackage(ctx);

    let mut sink = IlSinkContext { functions: &mut [], entry: nil, arena: &mut res.arena };

    set low.output = lower::FnOutput::Stream(lower::FnSink {

        ctx: &mut sink as *mut opaque, emitFn: collectLoweredFn,

    });

    return il::binary::Image {

        program: il::Program { data: low.data, fns: sink.functions },

        entry: sink.entry,

    };

    if ctx.emitIl {

        let path = ctx.outputPath else { throw error(&["binary RIL output requires a path"]); };

        let image = try lowerAllPackages(ctx, res);

        try binary::write(&image, path, &mut res.arena) catch {

            throw error(&["failed to write binary RIL", path]);

        };

        return;

    }

        let image = try lowerAllPackages(ctx, res);

        il::printer::printProgram(&mut out, &image.program);

    if env.args.len > 0 and mem::eq(env.args[0], "-load") {

        return binary::run(env.args, &mut STRING_POOL);

    }

//! Binary RIL file output and loading through the shared RV64 backend.

use std::mem;

use std::fmt;

use std::io;

use std::lang::alloc;

use std::lang::strings;

use std::lang::il;

use std::lang::gen::data;

use std::collections::dict;

use std::arch::rv64;

use std::arch::rv64::asm;

use std::arch::rv64::emit;

use std::sys::unix;

/// Maximum serialized RIL file size.

constant MAX_IMAGE: u32 = 16 * 1024 * 1024;

/// Maximum data bytes in each native section.

constant MAX_DATA: u32 = 4 * 1024 * 1024;

/// Maximum assembly inputs linked with an image.

constant MAX_ASM: u32 = 64;

/// Input storage includes one byte to detect an oversized file.

static IMAGE: [u8; MAX_IMAGE + 1] = undefined;

/// Stable decoded IL and native generator storage.

static ARENA: [u8; 48 * 1024 * 1024] = undefined;

/// Scratch storage reclaimed after each generated function.

static FN_ARENA: [u8; 16 * 1024 * 1024] = undefined;

/// Native read-only data.

static RO_DATA: [u8; MAX_DATA] = undefined;

/// Native writable initializers.

static RW_DATA: [u8; MAX_DATA] = undefined;

/// Assembly source input.

static ASM_SOURCE: [u8; 2 * 1024 * 1024] = undefined;

/// Encoded assembly instructions.

static ASM_TEXT: [u32; 262144] = undefined;

/// Temporary assembly data.

static ASM_DATA: [u8; MAX_DATA] = undefined;

/// Accumulated assembly read-only prefix.

static ASM_PREFIX: [u8; MAX_DATA] = undefined;

/// Native data symbol storage.

static DATA_SYMBOLS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;

/// Native data symbol index.

static DATA_INDEX: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;

/// Native loading options. Assembly is supplied separately from binary RIL.

record Options {

    /// Binary RIL input path.

    input: *[u8],

    /// Native output path.

    output: *[u8],

    /// Optional machine startup assembly.

    startup: ?*[u8],

    /// Trusted assembly modules linked after RIL functions.

    modules: [*[u8]; MAX_ASM],

    /// Number of module paths.

    moduleCount: u32,

}

/// Construct a file or command error without a binary byte offset.

fn error(message: *[u8]) -> il::binary::Error {

    return il::binary::Error { offset: 0, message };

}

/// Write a binary RIL image using the caller's disjoint scratch arena.

export fn write(image: *il::binary::Image, path: *[u8], arena: *mut alloc::Arena) throws (il::binary::Error) {

    let size = try il::binary::encode(image, arena, &mut IMAGE[..MAX_IMAGE]);

    if not unix::writeFile(path, &IMAGE[..size]) { throw error("cannot write binary RIL"); }

}

/// Parse the standalone binary loading command.

fn options(args: *[*[u8]]) -> Options throws (il::binary::Error) {

    if args.len < 2 { throw error("-load requires a binary RIL path"); }

    let mut result = Options { input: args[1], output: "", startup: nil, modules: undefined, moduleCount: 0 };

    let mut i: u32 = 2;

    while i < args.len {

        if i + 1 >= args.len { throw error("missing loading option value"); }

        let option = args[i];

        let value = args[i + 1];

        if mem::eq(option, "-o") {

            if result.output.len <> 0 { throw error("duplicate output path"); }

            set result.output = value;

        } else if mem::eq(option, "-start") {

            if result.startup <> nil { throw error("duplicate startup path"); }

            set result.startup = value;

        } else if mem::eq(option, "-mod") {

            if result.moduleCount == MAX_ASM { throw error("too many assembly modules"); }

            set result.modules[result.moduleCount] = value;

            set result.moduleCount += 1;

        } else { throw error("unknown binary loading option"); }

        set i += 2;

    }

    if result.output.len == 0 { throw error("-load requires -o"); }

    return result;

}

/// Check section capacity before the backend computes native addresses.

fn layout(program: *il::Program, prefix: u32) throws (il::binary::Error) {

    if program.data.len > data::MAX_DATA_SYMS { throw error("too many data symbols"); }

    for section in 0..2 {

        let readOnly = section == 0;

        let mut offset = prefix as u64 if readOnly else 0 as u64;

        for pass in 0..2 {

            for item in program.data {

                if item.readOnly <> readOnly or item.isZeroInit <> (pass == 1) { continue; }

                let alignment = item.alignment as u64;

                if alignment == 0 or alignment & (alignment - 1) <> 0 {

                    throw error("invalid data alignment");

                }

                set offset = ((offset + alignment - 1) & ~(alignment - 1)) + item.size as u64;

                if offset > MAX_DATA as u64 { throw error("native data section exceeds capacity"); }

            }

        }

    }

}

/// Append trusted assembly and retain its read-only data in the final layout.

fn assembly(generator: *mut rv64::Generator, path: *[u8], prefix: *mut u32,

    arena: *mut alloc::Arena, pool: *mut strings::Pool) throws (il::binary::Error) {

    let source = unix::readFile(path, &mut ASM_SOURCE[..]) else { throw error("cannot read assembly input"); };

    if source.len == ASM_SOURCE.len { throw error("assembly input exceeds capacity"); }

    let program = try asm::assemble(asm::scanner::SourceKind::File { path }, source,

        &mut ASM_TEXT[..], &mut ASM_DATA[..], arena, pool, rv64::RO_DATA_BASE + *prefix)

        catch { throw error("assembly failed"); };

    if program.data.len > ASM_PREFIX.len - *prefix { throw error("assembly data exceeds capacity"); }

    for symbol in program.symbols {

        if symbol.isExported and symbol.section == asm::Section::Text

            and dict::get(&generator.e.labels.funcs, symbol.name) <> nil {

            throw error("duplicate assembly function definition");

        }

    }

    try! mem::copy(&mut ASM_PREFIX[*prefix..], program.data);

    set *prefix += program.data.len;

    rv64::addAssembly(generator, program);

}

/// Reject unresolved function references before native relocation patching.

fn link(generator: *rv64::Generator, program: *il::Program) throws (il::binary::Error) {

    let names = &generator.e.labels.funcs;

    for call in generator.e.pendingCalls {

        if dict::get(names, call.target) == nil { throw error("unresolved function call"); }

    }

    for jump in generator.e.pendingJumps {

        if dict::get(names, jump.target) == nil { throw error("unresolved assembly jump"); }

    }

    for address in generator.e.pendingAddrLoads {

        if not address.isData and dict::get(names, address.target) == nil {

            throw error("unresolved function address");

        }

    }

    for item in program.data {

        for value in item.values {

            if value.count == 0 { continue; }

            if let case il::DataItem::Fn(name) = value.item {

                if dict::get(names, name) == nil { throw error("unresolved function initializer"); }

            }

        }

    }

}

/// Decode one trusted image and generate native code with optional assembly.

fn load(options: *Options, pool: *mut strings::Pool) throws (il::binary::Error) {

    let source = unix::readFile(options.input, &mut IMAGE[..]) else { throw error("cannot read binary RIL"); };

    if source.len > MAX_IMAGE { throw error("binary RIL exceeds capacity"); }

    let mut arena = alloc::new(&mut ARENA[..]);

    let mut fnArena = alloc::new(&mut FN_ARENA[..]);

    let image = try il::binary::decode(source, &mut arena, pool);

    let entry = image.entry else { throw error("binary RIL has no entry function"); };

    let entryPatch = rv64::EntryPatch::Reserved(entry)

        if options.startup == nil else rv64::EntryPatch::None;

    let mut generator = rv64::beginProgram(rv64::ProgramOptions { entryPatch, debug: false }, &mut arena);

    let mut prefix: u32 = 0;

    if let path = options.startup { try assembly(&mut generator, path, &mut prefix, &mut arena, pool); }

    for function in image.program.fns {

        if function.isExtern { continue; }

        if dict::get(&generator.e.labels.funcs, function.name) <> nil { throw error("duplicate function definition"); }

        rv64::generateFunction(&mut generator, function, &mut fnArena);

    }

    for i in 0..options.moduleCount {

        try assembly(&mut generator, options.modules[i], &mut prefix, &mut arena, pool);

    }

    let entryOffset = dict::get(&generator.e.labels.funcs, entry) else { throw error("unresolved entry function"); };

    if let previous = dict::get(&generator.e.labels.funcs, "::default") {

        if previous <> entryOffset { throw error("conflicting startup entry symbol"); }

    }

    emit::recordFuncOffsetAt(&mut generator.e, "::default", entryOffset as u32 / rv64::INSTR_SIZE as u32);

    try link(&generator, &image.program);

    try layout(&image.program, prefix);

    let result = rv64::finishProgram(&mut generator, image.program.data,

        rv64::Storage { dataSyms: &mut DATA_SYMBOLS[..], dataSymEntries: &mut DATA_INDEX[..] },

        &ASM_PREFIX[..prefix], &mut RO_DATA[..], &mut RW_DATA[..]);

    let code = @sliceOf(result.code.ptr as *u8, result.code.len * rv64::INSTR_SIZE as u32);

    let header = rv64::imageHeader(code.len, result.roDataSize, result.rwDataSize);

    let headerWords = &header[..];

    if not unix::writeFileParts(options.output, &[@sliceOf(headerWords.ptr as *u8, headerWords.len * rv64::WORD_SIZE as u32), code,

        &RO_DATA[..result.roDataSize], &RW_DATA[..result.rwDataSize]]) {

        throw error("cannot write native image");

    }

}

/// Run the binary loading command and report a bounded source offset on failure.

export fn run(args: *[*[u8]], pool: *mut strings::Pool) -> i32 {

    let options = try options(args) catch e {

        io::printError("radiance: "); io::printError(e.message); io::printError("\n");

        return 1;

    };

    try load(&options, pool) catch e {

        let mut digits: [u8; 10] = undefined;

        io::printError("radiance: binary RIL at byte ");

        io::printError(fmt::formatU32(e.offset, &mut digits[..]));

        io::printError(": "); io::printError(e.message); io::printError("\n");

        return 1;

    };

    return 0;

}

record the contracts established through step 16 of the 22-step plan.

## Binary RIL encoding and standalone compilation

- std::lang::il::binary preserves complete functions, instructions, block edges,

  types, and data records. Decoding reconstructs derived graph indices and

  validates declarations, references, control-flow shape, and structural bounds.

- RIL0 uses little-endian version 1, explicit wire tags, and a deduplicated symbol

  table. Files contain no compiler pointers or host-layout records. Every

  incomplete input prefix must fail decoding; nonbinary input fails at magic.

- The compiler writes inputs with -emit ril -o FILE and compiles them with

  -load FILE -o OUT. Trusted RAS startup/support can be linked during loading.

  Native compilation uses std::arch::rv64, its allocator, and its relocations.

- Structural validation is not pointer-provenance or type-safety verification.

  The trusted-input boundary remains unchanged. Round trips exercise switch

  arguments, loops with aggregate returns, and writable function pointers.

Exercise malformed binary inputs, every incomplete prefix, and source-to-binary-to-native graphs with switch block arguments, aggregate-return loops, and writable function pointers. Kernel behavior remains the retained mechanism baseline.

export mod binary;

//! Versioned, pointer-free binary serialization of the shared RIL model.

//!

//! Wire integers are little-endian. The header is "RIL0", version u32=1,

//! reserved flags u32=0, symbol count, length-prefixed symbol byte strings,

//! entry symbol index (0xffffffff for none), data count and function count.

//! Data records precede functions. Every list and byte string has a u32 count.

//! Instruction, value and data tags are explicit and independent of ABI layout.

//! Decoding checks structural consistency, not pointer provenance or type safety.

mod instructions;

mod records;

mod structure;

/// Binary input-boundary checks.

@test mod tests;

use std::mem;

use std::collections::dict;

use std::lang::alloc;

use std::lang::strings;

use std::lang::il;

/// A compilation unit and its optional declared entry function.

export record Image: Copy {

    /// Existing RIL representation consumed by lowering and code generation.

    program: il::Program,

    /// Entry function name, or nil for a library without an entry point.

    entry: ?*[u8],

}

/// A malformed input, unsupported structure, or exhausted caller buffer.

export record Error: Copy {

    /// Byte offset in the binary input or output where the error was detected.

    offset: u32,

    /// Static diagnostic message.

    message: *[u8],

}

/// One deduplicated wire symbol and its declaration/reference metadata.

export record Symbol: Copy {

    /// Interned or caller-owned symbol bytes.

    name: *[u8],

    /// Declaration kind: 0 undeclared, 1 data, 2 function.

    kind: u8,

    /// Required reference kinds, using the same data/function bit values.

    uses: u8,

    /// Offset identifying this symbol in the binary stream.

    offset: u32,

}

/// Internal bounded writer, shared with the instruction and record codecs.

export record Writer: Copy {

    /// Caller-provided destination, disjoint from the scratch arena.

    output: *mut [u8],

    /// Next output byte.

    offset: u32,

    /// Declaration-indexed wire symbols.

    symbols: *[Symbol],

    /// Name-to-wire-index dictionary with checked capacity.

    symbolMap: dict::Dict,

}

/// Internal bounded reader, shared with the instruction and record codecs.

export record Reader: Copy {

    /// Immutable binary source; returned strings may borrow it.

    input: *[u8],

    /// Next input byte.

    offset: u32,

    /// Caller storage for all returned records and mutable slices.

    arena: *mut alloc::Arena,

    /// Shared identifier pool, whose lifetime must cover the decoded image.

    pool: *mut strings::Pool,

    /// Deduplicated symbol table and deferred reference checks.

    symbols: *mut [Symbol],

}

/// Create a diagnostic at a known binary offset.

export fn error(offset: u32, message: *[u8]) -> Error {

    return Error { offset, message };

}

/// Allocate without overflowing the shared arena's u32 size arithmetic.

export fn storage(arena: *mut alloc::Arena, size: u32, alignment: u32, count: u32, offset: u32) -> *mut [opaque] throws (Error) {

    if count == 0 { return &mut []; }

    let bytes = size as u64 * count as u64;

    let padding = (alignment - (arena.offset % alignment)) % alignment;

    if arena.offset > arena.data.len or bytes + padding as u64 > (arena.data.len - arena.offset) as u64 {

        throw error(offset, "RIL arena exhausted");

    }

    return try alloc::allocSlice(arena, size, alignment, count) catch {

        throw error(offset, "RIL arena exhausted");

    };

}

/// Build an empty dictionary with enough space for `count` unique entries.

export fn dictionary(arena: *mut alloc::Arena, count: u32, offset: u32) -> dict::Dict throws (Error) {

    if count > 0x20000000 { throw error(offset, "RIL symbol count is too large"); }

    let mut capacity: u32 = 2;

    while capacity / 2 < count { set capacity *= 2; }

    let entries = try storage(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), capacity, offset) as *mut [dict::Entry];

    return dict::init(entries);

}

/// Write bytes after checking the caller's complete remaining capacity.

export fn putBytes(w: *mut Writer, bytes: *[u8]) throws (Error) {

    if bytes.len > w.output.len - w.offset { throw error(w.offset, "RIL output buffer exhausted"); }

    try mem::copy(&mut w.output[w.offset..w.offset + bytes.len], bytes) catch {

        throw error(w.offset, "RIL output buffer exhausted");

    };

    set w.offset += bytes.len;

}

/// Write a single wire byte.

export fn put8(w: *mut Writer, value: u8) throws (Error) {

    if w.offset == w.output.len { throw error(w.offset, "RIL output buffer exhausted"); }

    set w.output[w.offset] = value;

    set w.offset += 1;

}

/// Write an explicitly little-endian u32.

export fn put32(w: *mut Writer, value: u32) throws (Error) {

    if w.output.len - w.offset < 4 { throw error(w.offset, "RIL output buffer exhausted"); }

    for i in 0..4 { set w.output[w.offset + i] = (value >> (i * 8)) as u8; }

    set w.offset += 4;

}

/// Write an explicitly little-endian u64, preserving signed literal bits.

export fn put64(w: *mut Writer, value: u64) throws (Error) {

    if w.output.len - w.offset < 8 { throw error(w.offset, "RIL output buffer exhausted"); }

    for i in 0..8 { set w.output[w.offset + i] = (value >> (i as u64 * 8)) as u8; }

    set w.offset += 8;

}

/// Write a length-prefixed byte string, including embedded zero bytes.

export fn putString(w: *mut Writer, value: *[u8]) throws (Error) {

    try put32(w, value.len);

    try putBytes(w, value);

}

/// Read a source-backed byte slice after a subtraction-based bounds check.

export fn getBytes(r: *mut Reader, count: u32) -> *[u8] throws (Error) {

    if count > r.input.len - r.offset { throw error(r.offset, "truncated binary RIL"); }

    let bytes = &r.input[r.offset..r.offset + count];

    set r.offset += count;

    return bytes;

}

/// Read one wire byte.

export fn get8(r: *mut Reader) -> u8 throws (Error) {

    let bytes = try getBytes(r, 1);

    return bytes[0];

}

/// Read an explicitly little-endian u32 without alignment assumptions.

export fn get32(r: *mut Reader) -> u32 throws (Error) {

    let bytes = try getBytes(r, 4);

    let mut value: u32 = 0;

    for i in 0..4 { set value |= (bytes[i] as u32) << (i * 8); }

    return value;

}

/// Read an explicitly little-endian u64 without host pointer reinterpretation.

export fn get64(r: *mut Reader) -> u64 throws (Error) {

    let bytes = try getBytes(r, 8);

    let mut value: u64 = 0;

    for i in 0..8 { set value |= (bytes[i] as u64) << (i as u64 * 8); }

    return value;

}

/// Read a canonical wire boolean; other bytes are malformed, not truthy.

export fn getBool(r: *mut Reader) -> bool throws (Error) {

    let offset = r.offset;

    let value = try get8(r);

    if value > 1 { throw error(offset, "invalid RIL boolean"); }

    return value == 1;

}

/// Read a count bounded by the smallest possible wire representation per item.

export fn count(r: *mut Reader, minimumBytes: u32) -> u32 throws (Error) {

    let offset = r.offset;

    let value = try get32(r);

    if value > (r.input.len - r.offset) / minimumBytes {

        throw error(offset, "RIL list count exceeds remaining input");

    }

    return value;

}

/// Read a byte string without copying its payload.

export fn getString(r: *mut Reader) -> *[u8] throws (Error) {

    let len = try get32(r);

    return try getBytes(r, len);

}

/// Intern a nonempty symbol, checking the fixed shared pool before insertion.

export fn intern(r: *mut Reader, name: *[u8], offset: u32) -> *[u8] throws (Error) {

    if name.len == 0 { throw error(offset, "empty RIL symbol name"); }

    if let existing = strings::find(r.pool, name) { return existing; }

    if r.pool.count >= r.pool.table.len / 2 { throw error(offset, "RIL string pool exhausted"); }

    return strings::intern(r.pool, name);

}

/// Write a symbol reference, rejecting undeclared or wrong-kind names.

export fn putSymbol(w: *mut Writer, name: *[u8], kind: u8) throws (Error) {

    let index = dict::get(&w.symbolMap, name) else {

        throw error(w.offset, "undefined RIL symbol");

    };

    if w.symbols[index as u32].kind <> kind { throw error(w.offset, "RIL symbol kind mismatch"); }

    try put32(w, index as u32);

}

/// Read a reference by table index and defer declaration-kind checks until EOF.

export fn getSymbol(r: *mut Reader, kind: u8) -> *[u8] throws (Error) {

    let offset = r.offset;

    let index = try get32(r);

    if index >= r.symbols.len { throw error(offset, "RIL symbol index out of range"); }

    set r.symbols[index].uses |= kind;

    return r.symbols[index].name;

}

/// Read and register a unique data or function declaration.

export fn declaration(r: *mut Reader, kind: u8) -> *[u8] throws (Error) {

    let offset = r.offset;

    let index = try get32(r);

    if index >= r.symbols.len { throw error(offset, "RIL declaration index out of range"); }

    let symbol = &mut r.symbols[index];

    if symbol.kind <> 0 { throw error(offset, "duplicate RIL declaration"); }

    set symbol.kind = kind;

    return symbol.name;

}

/// Encode into disjoint caller output, restoring all arena scratch on success or error.

/// Returned bytes contain no addresses from the source program or host ABI.

export fn encode(image: *Image, arena: *mut alloc::Arena, output: *mut [u8]) -> u32 throws (Error) {

    let saved = alloc::save(arena);

    let result = try encodeImage(image, arena, output) catch err {

        alloc::restore(arena, saved);

        throw err;

    };

    alloc::restore(arena, saved);

    return result;

}

/// Build the declaration-only symbol table and serialize the image.

fn encodeImage(image: *Image, arena: *mut alloc::Arena, output: *mut [u8]) -> u32 throws (Error) {

    let total = image.program.data.len as u64 + image.program.fns.len as u64;

    if total > 0x7FFFFFFF { throw error(0, "too many RIL declarations"); }

    let symbols = try storage(arena, @sizeOf(Symbol), @alignOf(Symbol), total as u32, 0) as *mut [Symbol];

    let mut map = try dictionary(arena, total as u32, 0);

    for d, i in image.program.data {

        set symbols[i] = { name: d.name, kind: 1, uses: 0, offset: 0 };

    }

    for f, i in image.program.fns {

        set symbols[image.program.data.len + i] = { name: f.name, kind: 2, uses: 0, offset: 0 };

    }

    for symbol, i in symbols {

        if symbol.name.len == 0 { throw error(0, "empty RIL declaration name"); }

        if dict::get(&map, symbol.name) <> nil { throw error(0, "duplicate RIL declaration"); }

        dict::insert(&mut map, symbol.name, i as i32);

    }

    let mut w = Writer { output, offset: 0, symbols, symbolMap: map };