/// Environment call.

///

/// Issues a system call with the given number and arguments.

/// Arguments and the return value are `i64` to support both 32-bit

/// emulator addresses and 64-bit native (AMD64) pointers.

/// Break out of program.

    }

    if consume(p, scanner::TokenKind::Pub) or consume(p, scanner::TokenKind::Export) {

        let attrNode = nodeAttribute(p, ast::Attribute::Pub);

        attrs.append(attrNode, p.allocator);

    }

    if attrs.len > 0 {

        return ast::Attributes { list: attrs };

    }

    return nil;

}

    try testing::expect(super::check(&parser, scanner::TokenKind::Ident));

}

/// Test parsing a function declaration with attributes.

@test fn testParseFnDeclAttributes() throws (testing::TestError) {

    let case ast::NodeValue::FnDecl(decl) = node.value

        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Pub));

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));

    try testing::expect(decl.body == nil);

}

@test fn testParseFnDeclInferredExtern() throws (testing::TestError) {

    let node = try! parseStmtStr("fn run();");

    let case ast::NodeValue::FnDecl(decl) = node.value

        else throw testing::TestError::Failed;

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));

    try testing::expect(decl.body == nil);

}

@test fn testParseFnDeclExportInferredExtern() throws (testing::TestError) {

    let node = try! parseStmtStr("export fn run();");

    let case ast::NodeValue::FnDecl(decl) = node.value

        else throw testing::TestError::Failed;

    FnMissingReturn,

    /// Function is missing a body.

    FnMissingBody,

    /// Function body is not expected.

    FnUnexpectedBody,

    /// Encountered loop control outside of a loop construct.

    InvalidLoopControl,

    /// `try` used when the enclosing function does not declare throws.

    TryRequiresThrows,

    /// `try` used to propagate an error not declared by the enclosing function.

    };

    let retTy = *fnType.returnType;

    let isExtern = ast::hasAttribute(sym.attrs, ast::Attribute::Extern);

    let isIntrinsic = ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic);

    if let body = decl.body {

        if isExtern {

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

        }

        enterFn(self, node, fnType); // Enter function scope for body analysis.

            io::print("function is missing a body");

        }

        case super::ErrorKind::FnUnexpectedBody => {

            io::print("function body is not expected");

        }

        }

        case super::ErrorKind::InvalidLoopControl => {

            io::print("loop control outside of a loop construct");

        }

        case super::ErrorKind::TryRequiresThrows => {

    // Module-related tokens.

    Mod, Use, Super,

    // Type or function attributes.

    // Trait-related tokens.

    Trait, Instance,

    // Type-related tokens.

    /// 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: "assert", tok: TokenKind::Assert },

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

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

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

    { name: "continue", tok: TokenKind::Continue },

    { name: "else", tok: TokenKind::Else },

    { name: "export", tok: TokenKind::Export },

    { name: "false", tok: TokenKind::False },

    { name: "fn", tok: TokenKind::Fn },

    { name: "for", tok: TokenKind::For },

    { name: "i16", tok: TokenKind::I16 },

    { name: "i32", tok: TokenKind::I32 },

//! returns: 0

/// Test that ecall can pass and return i64 values.

@default fn main() -> i32 {

    // ecall(64, fd, buf, len, 0) = write(fd, buf, len).

    let msg: *[u8] = "ok\n";

//! Test intrinsic ebreak lowering.

fn test() {

    ebreak();

}

//! Test intrinsic ecall lowering.

fn test() -> i32 {

    return ecall(64, 1, 100, 5, 0);

}

syntax match radianceComment "--.*$"

syntax keyword radianceTodo TODO FIXME contained containedin=radianceComment

" Keywords

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

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

syntax keyword radianceKeyword throws throw try catch panic assert super

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

" Double-quoted strings