formatting.nct

//! Formatting algorithms and allocation-failure policy.

include ./index.nct

use std/mem.allocation_abort_raw
use std/string.{String, try_push_str}

func try_append_str(out: &+String, value: &str): void! {
    try_push_str(out, value)?
    return
}

func append_str(out: &+String, value: &str): void {
    try_append_str(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_string(out: &+String, value: &String): void! {
    try_append_str(out, value as &str)?
    return
}

func append_string(out: &+String, value: &String): void {
    try_append_string(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_i32(out: &+String, value: i32): void! {
    try_append_i64(out, value as i64)?
    return
}

func append_i32(out: &+String, value: i32): void {
    try_append_i32(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_i8(out: &+String, value: i8): void! {
    try_append_i64(out, value as i64)?
    return
}

func append_i8(out: &+String, value: i8): void {
    try_append_i8(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_i16(out: &+String, value: i16): void! {
    try_append_i64(out, value as i64)?
    return
}

func append_i16(out: &+String, value: i16): void {
    try_append_i16(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_i64(out: &+String, value: i64): void! {
    if value == -9223372036854775808 {
        try_append_str(out, "-9223372036854775808")?
        return
    }
    if value < 0 {
        try_append_str(out, "-")?
        try_append_i64_digits(out, 0 - value)?
        return
    }
    try_append_i64_digits(out, value)?
    return
}

func append_i64(out: &+String, value: i64): void {
    try_append_i64(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_isize(out: &+String, value: isize): void! {
    try_append_i64(out, value as i64)?
    return
}

func append_isize(out: &+String, value: isize): void {
    try_append_isize(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_u8(out: &+String, value: u8): void! {
    try_append_u64_digits(out, value as u64)?
    return
}

func append_u8(out: &+String, value: u8): void {
    try_append_u8(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_u16(out: &+String, value: u16): void! {
    try_append_u64_digits(out, value as u64)?
    return
}

func append_u16(out: &+String, value: u16): void {
    try_append_u16(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_u32(out: &+String, value: u32): void! {
    try_append_u64_digits(out, value as u64)?
    return
}

func append_u32(out: &+String, value: u32): void {
    try_append_u32(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_u64(out: &+String, value: u64): void! {
    try_append_u64_digits(out, value)?
    return
}

func append_u64(out: &+String, value: u64): void {
    try_append_u64(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_usize(out: &+String, value: usize): void! {
    try_append_u64_digits(out, value as u64)?
    return
}

func append_usize(out: &+String, value: usize): void {
    try_append_usize(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_bool(out: &+String, value: bool): void! {
    if value {
        try_append_str(out, "true")?
        return
    }
    try_append_str(out, "false")?
    return
}

func append_bool(out: &+String, value: bool): void {
    try_append_bool(out, value) catch allocation_error {
        return allocation_abort_raw()
    }
    return
}

func try_append_u64_digits(out: &+String, value: u64): void! {
    if value >= 10 {
        try_append_u64_digits(out, value / 10)?
    }
    try_append_u64_digit(out, value % 10)?
    return
}

func try_append_i64_digits(out: &+String, value: i64): void! {
    if value >= 10 {
        try_append_i64_digits(out, value / 10)?
    }
    try_append_i64_digit(out, value % 10)?
    return
}

func try_append_u64_digit(out: &+String, value: u64): void! {
    if value == 0 {
        try_append_str(out, "0")?
        return
    }
    if value == 1 {
        try_append_str(out, "1")?
        return
    }
    if value == 2 {
        try_append_str(out, "2")?
        return
    }
    if value == 3 {
        try_append_str(out, "3")?
        return
    }
    if value == 4 {
        try_append_str(out, "4")?
        return
    }
    if value == 5 {
        try_append_str(out, "5")?
        return
    }
    if value == 6 {
        try_append_str(out, "6")?
        return
    }
    if value == 7 {
        try_append_str(out, "7")?
        return
    }
    if value == 8 {
        try_append_str(out, "8")?
        return
    }
    try_append_str(out, "9")?
    return
}

func try_append_i64_digit(out: &+String, value: i64): void! {
    if value == 0 {
        try_append_str(out, "0")?
        return
    }
    if value == 1 {
        try_append_str(out, "1")?
        return
    }
    if value == 2 {
        try_append_str(out, "2")?
        return
    }
    if value == 3 {
        try_append_str(out, "3")?
        return
    }
    if value == 4 {
        try_append_str(out, "4")?
        return
    }
    if value == 5 {
        try_append_str(out, "5")?
        return
    }
    if value == 6 {
        try_append_str(out, "6")?
        return
    }
    if value == 7 {
        try_append_str(out, "7")?
        return
    }
    if value == 8 {
        try_append_str(out, "8")?
        return
    }
    try_append_str(out, "9")?
    return
}

func unsupported(): error {
    return error.new("std.fmt.unsupported", "value cannot be formatted")
}