//! Input/output utilities.

use std::fmt;

use std::intrinsics;

/// Write the bytes to standard output.

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

    unsafe {

        intrinsics::ecall(64, 1, str.ptr as i64, str.len as i64, 0);

    }

}

/// Write the bytes to standard error.

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

    unsafe {

        intrinsics::ecall(64, 2, str.ptr as i64, str.len as i64, 0);

    }

}

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

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

    print(str);

    print("\n");

}

/// Write a signed decimal integer to standard output.

export fn printI32(val: i32) {

    let mut buffer: [u8; 11] = [0; 11];

    let start = fmt::formatI32(val, &mut buffer[..]);

    print(&buffer[start..]);

}

/// Write an unsigned decimal integer to standard output.

export fn printU32(val: u32) {

    let mut buffer: [u8; 10] = [0; 10];

    let start = fmt::formatU32(val, &mut buffer[..]);

    print(&buffer[start..]);

}

/// Write a Boolean value to standard output.

export fn printBool(val: bool) {

    let mut buffer: [u8; 5] = [0; 5];

    let start = fmt::formatBool(val, &mut buffer[..]);

    print(&buffer[start..]);

}

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

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

    unsafe {

        return intrinsics::ecall(63, 0, buf.ptr as i64, buf.len as i64, 0) as u32;

    }

}

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

    let mut total: u32 = 0;

    while total < buf.len {

        let chunk: *mut [u8] = &mut buf[total..];

        let n: u32 = read(chunk);

        if n == 0 {

            break;

        }

        if n > chunk.len {

            set total = buf.len;

            break;

        }

        set total += n;

    }

    return &buf[..total];

}