OS

import stdlib::os::*;

import stdlib::os::*;

fn main() -> i32 {
    println!("os:", os_name());
    println!("arch:", os_arch());
    if os_is_windows() {
        println!("on windows, sep =", os_path_sep());
    } else {
        println!("on posix, sep =", os_path_sep());
    }
    if os_is_linux() { println!("linux"); }
    if os_is_macos() { println!("macos"); }
    if os_is_posix() { println!("posix"); }
    println!("path list sep:", os_path_list_sep());
    let line: string = format!("hello{}", os_line_sep());
    println!(line);
    if os_has_async_io() { println!("reactor active"); }
    if os_has_reuseport_balance() { println!("reuseport balances"); }
    return 0;
}

import stdlib::os::*;

fn opener() -> string {
    let n: string = os_name();
    if n.eq("macos")   { return "open"; }
    if n.eq("windows") { return "start"; }
    return "xdg-open";
}

fn main() -> i32 {
    println!("url opener for", os_name(), "is", opener());

    let sep: string = os_line_sep();
    let doc: string = format!("line1{}line2{}", sep, sep);
    println!(doc);
    return 0;
}

if os_has_async_io() { spawn handle(c); }
else                 { handle(c); }

import stdlib::os::*;
import stdlib::env::*;

fn main() -> i32 {
    let path: string = env_get("PATH");
    let sep: string = os_path_list_sep();          // ";" on Windows, ":" else
    let dirs: *Vector<string> = path.split(sep);
    println!("PATH has", dirs.len(), "entries");

    let mut i: i32 = 0;
    while i < dirs.len() {
        let d: string = dirs.get(i);
        if !d.eq("") { println!("  ", d); }
        i = i + 1;
    }
    return 0;
}

import stdlib::os::*;

fn main() -> i32 {
    println!("pid       :", os_pid());            // bare i32, infallible

    let pp: !i32 = os_ppid();                     // Err on Windows
    if pp.ok { println!("ppid      :", pp.val); }
    else     { println!("ppid      :", pp.err); }

    let u: !i32 = os_uid();                        // Err on Windows
    if u.ok  { println!("uid       :", u.val); }

    let g: !i32 = os_gid();                        // Err on Windows
    if g.ok  { println!("gid       :", g.val); }

    let user: !string = os_username();
    if user.ok { println!("user      :", user.val); }

    let host: !string = os_hostname();
    if host.ok { println!("host      :", host.val); }

    let kv: !string = os_kernel_version();
    if kv.ok   { println!("kernel    :", kv.val); }

    // uid == 0 means root on POSIX.
    if u.ok && u.val == 0 { println!("(running as root)"); }
    return 0;
}

import stdlib::os::*;

fn main() -> i32 {
    let saved: !string = os_cwd();
    if !saved.ok { println!("no cwd:", saved.err); return 1; }
    println!("start:", saved.val);

    let tmp: !string = os_temp_dir();
    if tmp.ok {
        let c: ! = os_chdir(tmp.val);
        if c.ok {
            let now: !string = os_cwd();
            if now.ok { println!("moved to:", now.val); }
        } else {
            println!("chdir failed:", c.err);
        }
    }

    // Always restore.
    let back: ! = os_chdir(saved.val);
    if !back.ok { println!("restore failed:", back.err); }
    return 0;
}

import stdlib::os::*;

fn main() -> i32 {
    let exe: !string = os_exe_path();
    if exe.ok { println!("running:", exe.val); }

    let dir: !string = os_exe_dir();
    if dir.ok {
        let asset: string = format!("{}{}assets{}logo.png",
            dir.val, os_path_sep(), os_path_sep());
        println!("asset:", asset);
    } else {
        println!("exe dir unavailable:", dir.err);
    }
    return 0;
}

import stdlib::os::*;

fn main() -> i32 {
    let cpus: !i32 = os_cpu_count();
    let workers: i32 = if cpus.ok { cpus.val } else { 1 };
    println!("spawning", workers, "workers");

    let phys: !i32 = os_cpu_count_physical();
    if phys.ok { println!("physical cores:", phys.val); }

    let pg: !i32 = os_page_size();
    if pg.ok { println!("page size:", pg.val, "bytes"); }

    let total: !u64 = os_memory_total();
    if total.ok { println!("RAM MiB :", (total.val / 1024 / 1024) as i32); }

    let free: !u64 = os_memory_free();
    if free.ok { println!("free MiB:", (free.val / 1024 / 1024) as i32); }

    let up: !u64 = os_uptime_secs();
    if up.ok { println!("uptime  :", (up.val / 3600) as i32, "h"); }

    let load: !f64 = os_loadavg_1m();      // Err on Windows
    if load.ok { println!("load 1m :", load.val); }
    else       { println!("load 1m :", load.err); }
    return 0;
}

import stdlib::os::*;

fn main() -> i32 {
    let tmp: !string = os_temp_dir();
    if tmp.ok { println!("temp:", tmp.val); }

    let home: !string = os_home_dir();
    if home.ok { println!("home:", home.val); }

    let cfg: !string = os_config_dir();
    if cfg.ok { println!("config:", cfg.val); }

    let cache: !string = os_cache_dir();
    if cache.ok { println!("cache:", cache.val); }

    let data: !string = os_data_dir();
    if data.ok { println!("data:", data.val); }

    return 0;
}

import stdlib::os::*;

fn config_path(app: string, file: string) -> !string {
    let base: string = os_config_dir()?;          // propagate Err
    return ok(format!("{}{}{}{}{}", base, os_path_sep(), app, os_path_sep(), file));
}

fn main() -> i32 {
    let p: !string = config_path("myapp", "settings.toml");
    if p.ok { println!("config at:", p.val); }
    else     { println!("could not resolve config dir:", p.err); }
    return 0;
}

fn os_is_tty(fd: i32) -> bool

import stdlib::os::*;

fn paint(msg: string) -> string {
    if os_is_tty(1) { return format!("\x1b[32m{}\x1b[0m", msg); }
    return msg;
}

fn main() -> i32 {
    println!(paint("build succeeded"));
    if !os_is_tty(0) { println!("(stdin is not interactive)"); }
    return 0;
}

fn os_shell(cmd: string) -> !i32

import stdlib::os::*;

fn main() -> i32 {
    let r: !i32 = os_shell("exit 3");
    if r.ok {
        if r.val == 0 { println!("command succeeded"); }
        else          { println!("command exited non-zero:", r.val); }
    } else {
        println!("shell did not spawn:", r.err);
    }
    return 0;
}