pub const T5:   Reg = { n: 30 };  /// Temporary.

pub const T6:   Reg = { n: 31 };  /// Temporary.

/// Create a register from a number. Panics if `n > 31`.

pub fn reg(n: u8) -> Reg {

    return Reg { n };

}

////////////////////////////

// Architecture constants //

    e.code[index] = instr;

}

/// Record a block's address for branch resolution.

pub fn recordBlock(e: *mut Emitter, blockIdx: u32) {

    labels::recordBlock(&mut e.labels, blockIdx, e.codeLen as i32 * super::INSTR_SIZE);

}

/// Record a function's code offset for call resolution.

pub fn recordFuncOffset(e: *mut Emitter, name: *[u8]) {

    dict::insert(&mut e.labels.funcs, name, e.codeLen as i32 * super::INSTR_SIZE);

}

/// Record a function's start position for printing.

pub fn recordFunc(e: *mut Emitter, name: *[u8]) {

         | ((funct7       & 0x7F) << 25);

}

/// Encode an I-type instruction.

fn encodeI(opcode: u32, rd: super::Reg, rs1: super::Reg, funct3: u32, imm: i32) -> u32 {

    return (opcode        & 0x7F)

         | ((rd.n  as u32 & 0x1F)  << 7)

         | ((funct3       & 0x07)  << 12)

         | ((rs1.n as u32 & 0x1F)  << 15)

         | ((imm as u32   & 0xFFF) << 20);

}

/// Encode an S-type instruction.

fn encodeS(opcode: u32, rs1: super::Reg, rs2: super::Reg, funct3: u32, imm: i32) -> u32 {

    return (opcode  & 0x7F)

         | ((imm as u32        & 0x1F) << 7)

         | ((funct3            & 0x07) << 12)

         | ((rs1.n as u32      & 0x1F) << 15)

         | ((imm as u32 >> 5   & 0x7F) << 25);

}

/// Encode a B-type (branch) instruction.

fn encodeB(opcode: u32, rs1: super::Reg, rs2: super::Reg, funct3: u32, imm: i32) -> u32 {

    let imm11   = (imm as u32 >> 11) & 0x1;

    let imm4_1  = (imm as u32 >> 1)  & 0xF;

    let imm10_5 = (imm as u32 >> 5)  & 0x3F;

    let imm12   = (imm as u32 >> 12) & 0x1;

         | ((imm as u32  & 0xFFFFF) << 12);

}

/// Encode a J-type (jump) instruction.

fn encodeJ(opcode: u32, rd: super::Reg, imm: i32) -> u32 {

    let imm20    = (imm as u32 >> 20) & 0x1;

    let imm10_1  = (imm as u32 >> 1)  & 0x3FF;

    let imm11    = (imm as u32 >> 11) & 0x1;

    let imm19_12 = (imm as u32 >> 12) & 0xFF;

    return encodeI(OP_IMM, rd, rs1, F3_AND, imm);

}

/// Shift left logical immediate: `rd = rs1 << shamt`.

pub fn slli(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM, rd, rs1, F3_SLL, shamt & 0x3F);

}

/// Shift right logical immediate: `rd = rs1 >> shamt` (zero-extend).

pub fn srli(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM, rd, rs1, F3_SRL, shamt & 0x3F);

}

/// Shift right arithmetic immediate: `rd = rs1 >> shamt` (sign-extend).

pub fn srai(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    // SRAI has bit 10 set in immediate field (becomes bit 30 in instruction)

    return encodeI(OP_IMM, rd, rs1, F3_SRL, (shamt & 0x3F) | 0b10000000000);

}

///////////////////////////

    return encodeI(OP_IMM32, rd, rs1, F3_ADD, imm);

}

/// Shift left logical immediate word: `rd = sign_ext((rs1 << shamt)[31:0])`.

pub fn slliw(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM32, rd, rs1, F3_SLL, shamt & 0x1F);

}

/// Shift right logical immediate word: `rd = sign_ext((rs1[31:0] >> shamt))`.

pub fn srliw(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM32, rd, rs1, F3_SRL, shamt & 0x1F);

}

/// Shift right arithmetic immediate word: `rd = sign_ext((rs1[31:0] >> shamt))` (sign-extended).

pub fn sraiw(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM32, rd, rs1, F3_SRL, (shamt & 0x1F) | 0b10000000000);

}

/// Add word: `rd = sign_ext((rs1 + rs2)[31:0])`.

pub fn addw(rd: super::Reg, rs1: super::Reg, rs2: super::Reg) -> u32 {

                    emit::emit(s.e, encode::sub(super::SP, super::SP, rs));

                    if alignment > 1 {

                        let mask = 0 - alignment as i32;

                        emit::emit(s.e, encode::andi(super::SP, super::SP, mask));

                    }

                    emit::emit(s.e, encode::mv(rd, super::SP));

                },

fn memEq(a: *[u8], b: *[u8]) -> bool {

    if a.len != b.len {

        return false;

    }

    for i in 0..a.len {

    return memEq(sliceU8("ABC"), "ABC")

       and sliceEqualI32(sliceI32(&[1, 2, 3]), &[1, 2, 3]);

}

@default fn main() -> i32 {

    return 0;

}

record Foo {

    x: u8,

    y: u32,

}

@default fn main() -> u8 {

    return 0;

}

//! returns: 0

union TestError { Fail }

static PTR_VALUE: i32 = 7;

@default fn main() -> u32 {

    // Catch block with early return

    let val1: u32 = catchWithReturn(true);

    // Catch block with early return (success case)

    let val2: u32 = catchWithReturn(false);

    // Catch block that discards error

    let mut flag: u32 = 0;

    try returnsErr() catch {};

    flag = 1;

    // Catch block with return in function

    let val3: u32 = returnsEarly();

    // try? converts to optional on error

    let ptr_ok: ?*i32 = try? returnsPtrOk();

    if let p = ptr_ok {

    } else {

    }

    // try? converts to nil on error

    let ptr_err: ?*i32 = try? returnsPtrErr();

    // try? on success

    let opt_ok: ?u32 = try? returnsOk();

    if let v = opt_ok {

    }

    // try? on error

    let opt_err: ?u32 = try? returnsErr();

    return 0;

}

fn catchWithReturn(fail: bool) -> u32 {

//! returns: 0

union PanicError { Boom }

fn makeOk(value: u32) -> u32 throws (PanicError) {

    return value;

}

@default fn main() -> u32 {

    let first: u32 = try! makeOk(7);

    let second: u32 = 2 * try! makeOk(11);

    let combined: u32 = try! makeOk(first + second);

    return 0;

}

//! Test null pointer optimization for optional slices (?*[T]).

//! Optional slices should have the same size as slices (16 bytes),

//! using a null data pointer to represent `nil`.

fn checkSizes() -> u8 {

    // ?*[T] should be the same size as *[T] (16 bytes, not 24).

    if @sizeOf(?*[u8]) != 16 {

        return 1;

    }

fn callPressure(a: u32, b: u32, c: u32, d: u32, e: u32, f: u32, g: u32, h: u32) -> u32 {

    return a + b + c + d + e + f + g + h;

}

fn bump(old: u32) -> u32 {

    let saved: u32 = old + 1;

    let first: u32 = callPressure(1, 2, 3, 4, 5, 6, 7, 8);

    let second: u32 = callPressure(8, 7, 6, 5, 4, 3, 2, 1);

    return saved;

}

@default fn main() -> i32 {

    let result: u32 = bump(0);

    return 0;

}

fn testDefaultAlignment() {

    let p1: u8 = 1;

    let p2: u8 = 2;

    let p3: u16 = 3;

    let p6: u32 = 6;

    // Each variable must be naturally aligned.

    let a1: u32 = (&p1) as u32;

    let a2: u32 = (&p2) as u32;

    let a3: u32 = (&p3) as u32;

    let a4: u32 = (&p4) as u32;

    let a5: u32 = (&p5) as u32;

    let a6: u32 = (&p6) as u32;

}

fn testAlignAnnotation() {

    let pad: [u8; 3] = [0; 3];

    let plain: u32 = 1;

    let custom: u32 align(16) = 2;

    let plainAddr: u32 = (&plain) as u32;

    let customAddr: u32 = (&custom) as u32;

}

@default fn main() -> i32 {

    testDefaultAlignment();

    testAlignAnnotation();

// TODO: Re-export `core::debug::*`.

use super::intrinsics;

    if not cond {

        intrinsics::ebreak();

    }

}

}

/// Maximum string length for a formatted bool (eg. "false").

pub const BOOL_STR_LEN: u32 = 5;

/// Format a u32 by writing it to the provided buffer.

pub fn formatU32(val: u32, buffer: *mut [u8]) -> *[u8] {

    let mut x: u32 = val;

    let mut i: u32 = buffer.len;

    // Handle the zero case separately to ensure a single '0' is written.

    return &buffer[i..];

}

/// Format a i32 by writing it to the provided buffer.

pub fn formatI32(val: i32, buffer: *mut [u8]) -> *[u8] {

    let neg: bool = val < 0;

    let mut x: u32 = -val as u32 if neg else val as u32;

    let mut i: u32 = buffer.len;

    // Handle the zero case separately to ensure a single '0' is written.

    return &buffer[i..];

}

/// Format a u64 by writing it to the provided buffer.

pub fn formatU64(val: u64, buffer: *mut [u8]) -> *[u8] {

    let mut x: u64 = val;

    let mut i: u32 = buffer.len;

    if x == 0 {

    return &buffer[i..];

}

/// Format a i64 by writing it to the provided buffer.

pub fn formatI64(val: i64, buffer: *mut [u8]) -> *[u8] {

    let neg: bool = val < 0;

    let mut x: u64 = -val as u64 if neg else val as u64;

    let mut i: u32 = buffer.len;

    if x == 0 {

///

/// Returns an opaque pointer to the allocated memory. Throws `AllocError` if

/// the arena is exhausted. The caller is responsible for casting to the

/// appropriate type and initializing the memory.

pub fn alloc(arena: *mut Arena, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {

    let aligned = mem::alignUp(arena.offset, alignment);

    let newOffset = aligned + size;

    if newOffset > arena.data.len as u32 {

    return self.list.len;

}

/// Fetch the attribute node at the specified index.

pub fn attributesGet(self: *Attributes, index: u32) -> *Node {

    return self.list.list[index];

}

/// Check if an attributes list contains an attribute.

pub fn attributesContains(self: *Attributes, attr: Attribute) -> bool {

    /// Panic statement.

    Panic {

        /// Optional panic message expression.

        message: ?*Node,

    },

    /// Conditional statement.

    If(If),

    /// Conditional expression.

    CondExpr(CondExpr),

    /// `if let` conditional binding.

            return sexpr::list(a, "return", &[toExprOrNull(a, value)]),

        case super::NodeValue::Throw { expr } =>

            return sexpr::list(a, "throw", &[toExpr(a, expr)]),

        case super::NodeValue::Panic { message } =>

            return sexpr::list(a, "panic", &[toExprOrNull(a, message)]),

        case super::NodeValue::If(c) =>

            return sexpr::block(a, "if", &[toExpr(a, c.condition)],

                &[toExpr(a, c.thenBranch), toExprOrNull(a, c.elseBranch)]),

        case super::NodeValue::IfLet(c) =>

            return sexpr::block(a, "if-let", &[

    } else {

        func.returnType = ilType(self, *fnType.returnType);

    }

    let body = decl.body else {

        // Extern functions have no body.

        return func;

    };

    func.blocks = try lowerFnBody(&mut fnLow, body);

    return func;

    switchToBlock(self, target);

}

/// Emit a conditional branch based on `cond`.

fn emitBr(self: *mut FnLowerer, cond: il::Reg, thenBlock: BlockId, elseBlock: BlockId) throws (LowerError) {

    emit(self, il::Instr::Br {

        op: il::CmpOp::Ne,

        typ: il::Type::W32,

        a: il::Val::Reg(cond),

        b: il::Val::Imm(0),

    a: il::Val,

    b: il::Val,

    thenBlock: BlockId,

    elseBlock: BlockId

) throws (LowerError) {

    emit(self, il::Instr::Br {

        op, typ, a, b,

        thenTarget: thenBlock.n, thenArgs: &mut [],

        elseTarget: elseBlock.n, elseArgs: &mut [],

    });

                try emitBr(self, eqReg, matchBlock, fallthrough);

            }

        }

        case MatchSubjectKind::Union(unionInfo) => {

            let case resolver::NodeExtra::UnionVariant { tag: variantTag, .. } =

                resolver::nodeData(self.low.resolver, pattern).extra

            else {

                throw LowerError::ExpectedVariant;

                try emitBrCmp(self, il::CmpOp::Eq, il::Type::W8, il::Val::Reg(tagReg), il::Val::Imm(variantTag as i64), matchBlock, fallthrough);

            }

        }

        else => { // Scalar comparison.

            let pattVal = try lowerExpr(self, pattern);

            try emitBrCmp(self, il::CmpOp::Eq, subject.ilType, subject.val, pattVal, matchBlock, fallthrough);

        }

    }

}

    subject: *MatchSubject,

    patterns: ast::NodeList,

    matchBlock: BlockId,

    fallthrough: BlockId

) throws (LowerError) {

    for i in 0..(patterns.len - 1) {

        let pattern = patterns.list[i];

        let nextArm = try createBlock(self, "arm");

        try emitPatternMatch(self, subject, pattern, matchBlock, nextArm);

/// Define (write) a variable. Record the SSA value of a variable in the

/// current block. Called when a variable is assigned or initialized (`let`

/// bindings, assignments, loop updates). When [`useVar`] is later called,

/// it will retrieve this value.

fn defVar(self: *mut FnLowerer, v: Var, val: il::Val) {

    getBlockMut(self, currentBlock(self)).vars[v.id] = val;

}

/// Use (read) the current value of a variable in the current block.

/// May insert block parameters if the value must come from predecessors.

/// Given a variable and a block where it's used, this function finds the

/// correct [`il::Val`] that holds the variable's value at that program point.

/// When control flow merges from multiple predecessors with different

/// definitions, it creates a block parameter to unify them.

fn useVarInBlock(self: *mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {

    let blk = getBlockMut(self, block);

    if let val = blk.vars[v.id] {

        return val;

    }

    self.varsLen = savedVarsLen;

}

/// Get the metadata for a variable.

fn getVar(self: *FnLowerer, v: Var) -> *VarData {

    return &self.vars[v.id];

}

/// Create a block parameter to merge a variable's value from multiple

/// control flow paths.

    let totalLen = fnType.paramTypesLen + offset;

    if totalLen == 0 {

        return &[];

    }

    let params = try! alloc::allocSlice(

        self.low.arena, @sizeOf(il::Param), @alignOf(il::Param), totalLen

    ) as *mut [il::Param];

///       jmp else#0;                     // guard failed, fallthrough to `else`

///   else#0:

///       ret 0;                          // `else` body

///

fn lowerMatch(self: *mut FnLowerer, node: *ast::Node, m: ast::Match) throws (LowerError) {

    let prongs = &m.prongs;

    // Lower the subject expression once; reused across all arms.

    let subject = try lowerMatchSubject(self, m.subject);

    // Merge block created lazily if any arm needs it (i.e., doesn't diverge).

            let _ = try lowerExpr(self, expr);

        }

        case ast::NodeValue::Panic { .. } => {

            emit(self, il::Instr::Unreachable);

        }

        else => {

            // Treat as expression statement, discard result.

            let _ = try lowerExpr(self, node);

        }

    }

    let tagBlock = try createBlock(self, "eq#tag");

    // Compare tags: if they differ, jump to merge with `false`; otherwise check payloads.

    let falseArgs = try allocVal(self, il::Val::Imm(0));

    // TODO: Use the helper once the compiler supports more than eight function params.

    emit(self, il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W8, a: tagA, b: tagB,

        thenTarget: tagBlock.n, thenArgs: &mut [],

    try emitRetVal(self, val);

}

/// Lower a throw statement.

fn lowerThrowStmt(self: *mut FnLowerer, expr: *ast::Node) throws (LowerError) {

    let errType = resolver::typeFor(self.low.resolver, expr) else {

        throw LowerError::MissingType(expr);

    };

    let tag = getOrAssignErrorTag(self.low, errType) as i64;

            // Panic in expression context (e.g. match arm). Emit unreachable

            // and return a dummy value since control won't continue.

            emit(self, il::Instr::Unreachable);

            val = il::Val::Undef;

        }

        case ast::NodeValue::Block(_) => {

            try lowerBlock(self, node);

            val = il::Val::Undef;

        }

        case ast::NodeValue::ExprStmt(expr) => {

    graph: *mut ModuleGraph,

    parentId: u16,

    name: *[u8],

    filePath: *[u8]

) -> u16 throws (ModuleError) {

    let parent = getMut(graph, parentId)

        else throw ModuleError::NotFound(parentId);

    // If the child already exists under this parent, return it.

    return &mut graph.entries[id as u32];

}

/// Return the identifier of the child stored at `index`.

pub fn childAt(m: *ModuleEntry, index: u32) -> u16 {

    return m.children[index];

}

/// Public accessor for a module's directory prefix.

pub fn moduleDir(m: *ModuleEntry) -> *[u8] {

    return &m.filePath[..m.dirLen];

}

/// Public accessor to the logical module path segments.

pub fn moduleQualifiedPath(m: *ModuleEntry) -> *[*[u8]] {

    return &m.path[..m.pathDepth];

}

/// Update the recorded lifecycle state for `id`.

pub fn setState(graph: *mut ModuleGraph, id: u16, state: ModuleState) throws (ModuleError) {

    m.source = source;

}

/// Look up a child module by name under the given parent.

pub fn findChild(graph: *ModuleGraph, name: *[u8], parentId: u16) -> ?*ModuleEntry {

    let parent = &graph.entries[parentId as u32];

    for i in 0..parent.childrenLen {

        let childId = parent.children[i];

        let child = &graph.entries[childId as u32];

    // Split on '/' to extract all but the last component.

    for i in 0..filePath.len {

        if filePath[i] == PATH_SEP {

            if i > last {

                components[count] = &filePath[last..i];

                count += 1;

            }

            last = i + 1;

        }

    if last >= filePath.len {

        return nil; // Path ends with separator or is empty.

    }

    // Handle the last component by removing extension.

    if let name = trimExtension(&filePath[last..]) {

        components[count] = name;

    } else {

        return nil;

    };

    return node(p, ast::NodeValue::Bool(value));

}

/// Convert a single ASCII digit into its numeric value for the given radix.

pub fn digitFromAscii(ch: u8, radix: u32) -> ?u32 {

    // Default to an out-of-range value so non-digits fall through to `nil`.

    let mut value: u32 = 36;

    if ch >= '0' and ch <= '9' {

            return try parseThrow(p);

        }

        case scanner::TokenKind::Panic => {

            return try parsePanic(p);

        }

        case scanner::TokenKind::Break => {

            advance(p);

            return node(p, ast::NodeValue::Break);

        }

        case scanner::TokenKind::Continue => {

    }

}

/// Report a parser error.

fn reportError(p: *mut Parser, token: scanner::Token, message: *[u8]) {

    // Ignore errors once the error list is full.

    if p.errors.count < p.errors.list.len {

        p.errors.list[p.errors.count] = Error { message, token };

        p.errors.count += 1;

    // `panic` or `panic "message"`.

    let message: ?*ast::Node = try? parseExpr(p);

    return node(p, ast::NodeValue::Panic { message });

}

/// Parse a `break` statement.

fn parseBreak(p: *mut Parser) -> *ast::Node

    throws (ParseError)

{

    try expect(p, scanner::TokenKind::Break, "expected `break`");

                item: allocType(self, Type::U8),

                mutable: false

            });

            return try setNodeType(self, node, Type::Never);

        },

        case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),

        case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),

        case ast::NodeValue::ExprStmt(expr) => {

            // Pass `Void` as expected type to indicate value is discarded.

            let exprTy = try visit(self, expr, Type::Void);

    if let a = decl.alignment {

        let case ast::NodeValue::Align { value } = a.value

            else panic "resolveLet: expected Align node";

        alignment = try checkSizeInt(self, value);

    }

    // Alignment must be zero or a power of two.

    if alignment != 0 and (alignment & (alignment - 1)) != 0 {

        throw emitError(self, decl.value, ErrorKind::InvalidAlignmentValue(alignment));

    }

    // Validate it fits within u32 range.

    if not validateConstIntRange(value, Type::U32) {

        throw emitError(self, node, ErrorKind::NumericLiteralOverflow);

    }

    try setNodeType(self, node, Type::U32);

    return int.magnitude as u32;

}

            actual: call.args.len,

        }));

    }

    // TODO: Check what happens when we exceed `MAX_FN_PARAMS`.

    for i in 0..call.args.len {

        let argNode = call.args.list[i];

        let expectedTy = *info.paramTypes[i];

        try checkAssignable(self, argNode, expectedTy);

    }

        expectedTy = *ary.item;

    };

    for i in 0..length {

        let itemNode = items.list[i];

        let itemTy = try visit(self, itemNode, expectedTy);

        // Set the expected type to the first type we encounter.

        if expectedTy == Type::Unknown {

            expectedTy = itemTy;

        } else {

    throws (ResolveError)

{

    let targetTy = try infer(self, expr.type);

    let sourceTy = try visit(self, expr.value, targetTy);

    if isValidCast(sourceTy, targetTy) {

        return try setNodeType(self, node, targetTy);

    }

    throw emitError(self, node, ErrorKind::InvalidAsCast(InvalidAsCast {

                returnType: allocType(self, Type::Void),

                throwList: undefined,

                throwListLen: 0,

                localCount: 0,

            };

            for i in 0..t.params.len {

                let paramTy = try infer(self, t.params.list[i]);

                fnType.paramTypes[fnType.paramTypesLen] = allocType(self, paramTy);

    let case ast::NodeValue::Block(block) = node.value

        else panic "resolvePackage: expected block for module root";

    // Module graph analysis phase: bind all module name symbols and scopes.

    try resolveModuleGraph(self, &block) catch {

        return Diagnostics { errors: self.errors };

    };

    // Declaration phase: bind all names and analyze top-level declarations.

    try resolveModuleDecls(self, &block) catch {

    };

    if self.errors.listLen > 0 {

        return Diagnostics { errors: self.errors };

    }

    // Definition phase: analyze function bodies and sub-module definitions.

    try resolveModuleDefs(self, &block) catch {

    };

    try setNodeType(self, node, Type::Void);

    return Diagnostics { errors: self.errors };

}

    // Control flow tokens.

    If, Else, Return, Break,

    Continue, While, For, In,

    Loop, Match, Case, Try, Catch,

    // Variable binding tokens.

    Let, Mut, Const, Align,

    // Module-related tokens.

        case TokenKind::Try => return "Try",

        case TokenKind::Catch => return "Catch",

        case TokenKind::Throw => return "Throw",

        case TokenKind::Throws => return "Throws",

        case TokenKind::Panic => return "Panic",

        case TokenKind::Let => return "Let",

        case TokenKind::Mut => return "Mut",

        case TokenKind::Const => return "Const",

        case TokenKind::Align => return "Align",

        case TokenKind::Mod => return "Mod",

    /// Corresponding token.

    tok: TokenKind,

}

/// Sorted keyword table for binary search.

    { name: "align", tok: TokenKind::Align },

    { name: "and", tok: TokenKind::And },

    { name: "as", tok: TokenKind::As },

    { name: "bool", tok: TokenKind::Bool },

    { name: "break", tok: TokenKind::Break },

    { name: "case", tok: TokenKind::Case },

    { name: "catch", tok: TokenKind::Catch },

    { name: "const", tok: TokenKind::Const },

    { name: "use", tok: TokenKind::Use },

    { name: "void", tok: TokenKind::Void },

    { name: "while", tok: TokenKind::While },

];

/// Lexical scanner state for tokenizing Radiance source code.

///

/// Maintains position information and source buffer reference.

pub record Scanner {

    /// File path.

///

/// * `arena` is a pointer to static array backing storage.

/// * `stride` is the size of each element.

/// * `alignment` is the required alignment for elements.

pub fn new(arena: *mut [u8], stride: u32, alignment: u32) -> RawVec {

    return RawVec { data: arena, len: 0, stride, alignment };

}

/// Get the current number of elements in the vector.

" Keywords

syntax keyword radianceKeyword mod fn return if else while true false and or not case align static

syntax keyword radianceKeyword pub extern break continue use loop in for match nil undefined

syntax keyword radianceKeyword let mut as register device const log record union

syntax keyword radianceType i8 i16 i32 i64 u8 u16 u32 u64 f32 void bool bit opaque

" Double-quoted strings

syntax region radianceString start=/"/ skip=/\\"/ end=/"/ contains=radianceEscape

" Characters