//! 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 trait Output {

    /// Write text to the output target.

    fn (&mut Output) write(s: &[u8]);

}

/// Print to stdout.

export record Stdout {}

/// Write to a buffer, tracking position.

export record Buffer: 'output {

    /// Storage for the printed text.

    buf: &'output mut [u8],

    /// Number of bytes written.

    pos: u32,

}

instance Output for Stdout {

    fn (out: &mut Stdout) write(s: &[u8]) {

        io::print(s);

    }

}

instance Output for Buffer 'output {

    fn (out: &mut Buffer 'output) write(s: &[u8]) {

        assert out.pos <= out.buf.len;

        let remaining = out.buf.len - out.pos;

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

        for i in 0..toWrite {

            set out.buf[out.pos] = s[i];

            set out.pos += 1;

        }

    }

}

/// 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 fn write(out: &mut opaque Output, s: &[u8]) {

    out.write(s);

}

/// Emit indentation to the output target.

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

    for _ in 0..depth {

        write(out, "  ");

    }

}

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

export fn printEscapedTo(out: &mut opaque 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 fn printStringTo(out: &mut opaque 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 fn printCharTo(out: &mut opaque Output, c: u8) {

    write(out, "'");

    printEscapedTo(out, c);

    write(out, "'");

}

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

export fn printTo(expr: Expr, depth: u32, out: &mut opaque 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 fn print(expr: Expr, depth: u32) {

    let mut out = Stdout {};

    printTo(expr, depth, &mut out);

}

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

export fn indent(depth: u32) {

    let mut out = Stdout {};

    indentTo(&mut out, depth);

}