use std::fmt;

use std::intrinsics;

/// Write the bytes to standard output.

export fn print(str: &[u8]) {

}

/// Write the bytes to standard error.

export fn printError(str: &[u8]) {

}

/// Write the bytes and a newline to standard output.

export fn printLn(str: &[u8]) {

    print(str);

    print(&buffer[start..]);

}

/// Read standard input into the buffer and return the system call result.

export fn read(buf: &mut [u8]) -> u32 {

}

export fn readToEnd(buf: *mut [u8]) -> *[u8] {

    let mut total: u32 = 0;

    if let case Type::Slice { class, item, mutable } = subjectTy {

        let fieldNode = access.child;

        let fieldName = try nodeName(self, fieldNode);

        if mem::eq(fieldName, PTR_FIELD) {

            setRecordFieldIndex(self, fieldNode, 0);

            return setNodeType(

                self,

                node,

                Type::Pointer { class, target: item, mutable },

    try expectExprStmtType(&a, indexStmt, super::Type::I32);

}

@test unsafe fn testResolveSliceFields() throws (testing::TestError) {

    let mut a = testResolver();

    let result = try resolveProgramStr(&mut a, program);

    try expectNoErrors(&result);

    let lenStmt = try getBlockStmt(result.root, 2);

    let case ast::NodeValue::ExprStmt(lenExpr) = lenStmt.value

        else throw testing::TestError::Failed;

    let lenTy = try typeOf(&a, lenExpr);

    try testing::expect(lenTy == super::Type::U32);

    let ptrStmt = try getBlockStmt(result.root, 3);

        else throw testing::TestError::Failed;

    let ptrTy = try typeOf(&a, ptrExpr);

    let targetTy = try expectPointerType(ptrTy, false);

    try testing::expect(targetTy == super::Type::I32);

}

    try expectAnalyzeOk("fn run() -> *[u32] { return &[1, 2]; }");

    try expectAnalyzeOk("fn run(value: *u32) -> *u32 { return &*value; }");

    try expectAnalyzeOk("fn run(values: *[u32]) -> *[u32] { return &values[..]; }");

    try expectAnalyzeOk("record Cell { value: u32 } fn run(value: *Cell) -> *u32 { return &value.value; }");

    try expectAnalyzeOk("fn run(values: *[u32]) -> *u32 { return &values[0]; }");

    try expectAnalyzeOk("unsafe fn run(value: *u32) -> *[u32] { return @sliceOf(value, 1); }");

}

/// References are rejected from every nested or storable type position.

@test unsafe fn testNestedRefPositionsRejected() throws (testing::TestError) {

    let mut a = testResolver();

    let result = try resolveProgramStr(&mut a, "fn run() { let n: u32 = 1; unsafe { let p = &n; } }");

    try expectErrorKind(&result, super::ErrorKind::RefBinding);

}

/// Unsafe declarations may compose unsafe operations and calls.

@test unsafe fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {

    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";

    try expectAnalyzeOk(program);

}

/// Check whether two byte slices have the same length and contents.

export fn eq(a: &[u8], b: &[u8]) -> bool {

    if a.len <> b.len {

        return false;

    }

    }

    for i in 0..a.len {

        if a[i] <> b[i] {

            return false;

        }

constant AT_FDCWD: i64 = -100;

/// Opens a file at the given path and returns a file descriptor.

/// Returns a negative value on error.

export fn open(path: &[u8], flags: OpenFlags) -> i64 {

}

/// Opens a file at the given path with mode, returns a file descriptor.

export fn openOpts(path: &[u8], flags: OpenFlags, mode: i64) -> i64 {

}

/// Reads from a file descriptor into the provided buffer.

/// Returns the number of bytes read, or a negative value on error.

export fn read(fd: i64, buf: &mut [u8]) -> i64 {

}

/// Reads from a file descriptor until EOF or buffer is full.

/// Returns the total number of bytes read, or a negative value on error.

export fn readToEnd(fd: i64, buf: &mut [u8]) -> i64 {

}

/// Writes to a file descriptor from the provided buffer.

/// Returns the number of bytes written, or a negative value on error.

export fn write(fd: i64, buf: &[u8]) -> i64 {

}

/// Writes the entire contents of a buffer to a file descriptor.

/// Returns `false` when the descriptor cannot accept the full buffer.

export fn writeAll(fd: i64, data: &[u8]) -> bool {

use std::fmt;

use std::mem;

use std::vec;

use std::testing;

use std::sys::unix;

// Data types //////////////////////////////////////////////////////////////////

record Point: Copy {

    x: i32,

@default fn main() -> i32 {

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

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

    // Write to stdout. The pointer is passed as i64.

    }

    return 0;

}

    set ANALYZER.entries[idx] = entry;

    set ANALYZER.len = idx + 1;

}

fn checkHeader(expected: *[Entry]) -> i32 {

    }

    if ANALYZER.len <> 1 {

        // Bookkeeping field was overwritten by the bad store.

        return 2;

    }

static STORAGE: [Entry; 2] = undefined;

static TABLE: Table = undefined;

static HOLDER: PtrBox = undefined;

    set TABLE.entries = &mut STORAGE[..];

    set TABLE.len     = 0;

    set HOLDER.ptr = &mut TABLE.entries;

fn sliceCap(s: *[i32]) -> u32 {

    return s.cap;

}

/// Returns the pointer field from a slice header.

    return s.ptr;

}

/// Copies a slice header into a new binding and returns it.

fn sliceCopy(s: *[i32]) -> *[i32] {