//! S-expression data structure and printer.

//!

//! Provides a data structure for representing S-expressions and functions

//! to print them with proper formatting. Uses an arena allocator for storage.

use std::io;

use std::lang::alloc;

/// Output target for S-expression printing.

export union Output: Copy {

    /// Print to stdout.

    Stdout,

    /// Write to a buffer, tracking position.

    Buffer { buf: *unsafe mut [u8], pos: *unsafe mut u32 },

}

/// An S-expression element.

export union Expr: Copy {

    /// An empty expression.

    Null,

    /// A symbol/identifier.

    Sym(*[u8]),

    /// A quoted string literal.

    Str(*[u8]),

    /// A character literal.

    Char(u8),

    /// A list with a head and tail. If `multiline` is `true`, items are printed one per line.

    List { head: *[u8], tail: *[Expr], multiline: bool },

    /// A bracket-delimited list `[...]` for block parameters and arguments.

    Vec { items: *[Expr] },

    /// A block with a name, inline items, and child statements on separate lines.

    Block { name: *[u8], items: *[Expr], children: *[Expr] },

}

/// Allocate an array of Expr in the arena.

export unsafe fn allocExprs(arena: &mut alloc::Arena, len: u32) -> *mut [Expr] throws (alloc::AllocError) {

    if len == 0 {

        throw alloc::AllocError::OutOfMemory;

    }

    let ptr = try alloc::allocSlice(arena, @sizeOf(Expr), @alignOf(Expr), len);

    return ptr as *mut [Expr];

}

/// Allocate and copy items into the arena.

export unsafe fn allocItems(a: &mut alloc::Arena, items: &[Expr]) -> *[Expr] {

    if items.len == 0 {

        return &[];

    }

    let buf = try! allocExprs(a, items.len);

    for item, i in items {

        set buf[i] = item;

    }

    return buf;

}

/// Shorthand for creating a symbol.

export fn sym(s: *[u8]) -> Expr {

    return Expr::Sym(s);

}

/// Shorthand for creating a string literal.

export fn str(s: *[u8]) -> Expr {

    return Expr::Str(s);

}

/// Shorthand for creating a list.

export unsafe fn list(a: &mut alloc::Arena, head: *[u8], tail: &[Expr]) -> Expr {

    return Expr::List { head, tail: allocItems(a, tail), multiline: false };

}

/// Shorthand for creating a bracket-delimited vector.

export unsafe fn vec(a: &mut alloc::Arena, items: &[Expr]) -> Expr {

    return Expr::Vec { items: allocItems(a, items) };

}

/// Shorthand for creating a block with inline items and child expressions.

export unsafe fn block(a: &mut alloc::Arena, name: *[u8], items: &[Expr], children: &[Expr]) -> Expr {

    return Expr::Block { name, items: allocItems(a, items), children: allocItems(a, children) };

}

/// Write a string to the output target.

export unsafe fn write(out: &mut Output, s: &[u8]) {

    match *out {

        case Output::Stdout => io::print(s),

        case Output::Buffer { buf, pos } => {

            let remaining = buf.len - *pos;

            let toWrite = remaining if s.len > remaining else s.len;

            for i in 0..toWrite {

                set buf[*pos] = s[i];

                set *pos += 1;

            }

        }

    }

}

/// Emit indentation to the output target.

unsafe fn indentTo(out: &mut Output, depth: u32) {

    for _ in 0..depth {

        write(out, "  ");

    }

}

/// Print a single character with escaping to the output target.

export unsafe fn printEscapedTo(out: &mut Output, c: u8) {

    match c {

        case '\n' => write(out, "\\n"),

        case '\r' => write(out, "\\r"),

        case '\t' => write(out, "\\t"),

        case '\\' => write(out, "\\\\"),

        case '\'' => write(out, "\\'"),

        else => write(out, &[c]),

    }

}

/// Print a quoted string with escape sequences to the output target.

export unsafe fn printStringTo(out: &mut Output, s: &[u8]) {

    write(out, "\"");

    for i in 0..s.len {

        printEscapedTo(out, s[i]);

    }

    write(out, "\"");

}

/// Print a character literal with escape sequences to the output target.

export unsafe fn printCharTo(out: &mut Output, c: u8) {

    write(out, "'");

    printEscapedTo(out, c);

    write(out, "'");

}

/// Print an S-expression to the given output target at the given depth.

export unsafe fn printTo(expr: Expr, depth: u32, out: &mut Output) {

    match expr {

        case Expr::Null => {},

        case Expr::Sym(s) => write(out, s),

        case Expr::Str(s) => printStringTo(out, s),

        case Expr::Char(c) => printCharTo(out, c),

        case Expr::List { head, tail, multiline } => {

            write(out, "(");

            write(out, head);

            if multiline {

                for i in 0..tail.len {

                    if tail[i] <> Expr::Null {

                        write(out, "\n");

                        indentTo(out, depth + 1);

                        printTo(tail[i], depth + 1, out);

                    }

                }

            } else {

                let mut first = head.len == 0;

                for i in 0..tail.len {

                    if tail[i] <> Expr::Null {

                        if first {

                            set first = false;

                        } else {

                            write(out, " ");

                        }

                        printTo(tail[i], depth, out);

                    }

                }

            }

            write(out, ")");

        }

        case Expr::Vec { items } => {

            write(out, "[");

            for item, i in items {

                if item <> Expr::Null {

                    if i > 0 {

                        write(out, " ");

                    }

                    printTo(item, depth, out);

                }

            }

            write(out, "]");

        }

        case Expr::Block { name, items, children } => {

            write(out, "(");

            write(out, name);

            for i in 0..items.len {

                if items[i] <> Expr::Null {

                    write(out, " ");

                    printTo(items[i], depth, out);

                }

            }

            for i in 0..children.len {

                if children[i] <> Expr::Null {

                    write(out, "\n");

                    indentTo(out, depth + 1);

                    printTo(children[i], depth + 1, out);

                }

            }

            write(out, ")");

        }

    }

}

/// Print an S-expression to stdout at the given indentation depth.

export unsafe fn print(expr: Expr, depth: u32) {

    let mut out = Output::Stdout;

    printTo(expr, depth, &mut out);

}

/// Emit indentation for `depth` levels to stdout.

export unsafe fn indent(depth: u32) {

    let mut out = Output::Stdout;

    indentTo(&mut out, depth);

}