ast

I hold the compiler's AST implementation.

`AST_ADDR_OP`

pub int AST_ADDR_OP = 103;

[AST_ADDR_OP, op, nameT]

`AST_AGAIN`

pub int AST_AGAIN = 406;

[AST_AGAIN, kwT]

`AST_ASSIGN`

pub int AST_ASSIGN = 402;

[AST_ASSIGN, expr, rhs]

`AST_BINARY`

pub int AST_BINARY = 102;

[AST_BINARY, op, left, right]

`AST_CALL`

pub int AST_CALL = 104;

[AST_CALL, callee, params[]]

`AST_DECL`

pub int AST_DECL = 302;

[AST_DECL, is_pub, fn_or_var]

`AST_DONE`

pub int AST_DONE = 405;

[AST_DONE, kwT]

`AST_EVAL`

pub int AST_EVAL = 401;

[AST_EVAL, expr]

`AST_FN`

pub int AST_FN = 303;

[AST_FN, nameT, args[], body?]

`AST_FN_BODY`

pub int AST_FN_BODY = 353;

[AST_FN_BODY, nlocal, stmts[]]

`AST_ID`

pub int AST_ID = 50;

[AST_ID, nameT]

`AST_IF`

pub int AST_IF = 403;

[AST_IF, cond, body[], else[]?]

`AST_INDEX`

pub int AST_INDEX = 106;

[AST_INDEX, rcvr, off_expr, width]

`AST_LIT_BOOL`

pub int AST_LIT_BOOL = 1;

[AST_LIT_BOOL, value]

`AST_LIT_CHAR`

pub int AST_LIT_CHAR = 2;

[AST_LIT_CHAR, value]

`AST_LIT_INT`

pub int AST_LIT_INT = 3;

[AST_LIT_INT, value]

`AST_LIT_STRING`

pub int AST_LIT_STRING = 20;

[AST_LIT_STRING, value]

`AST_MEMBER`

pub int AST_MEMBER = 105;

[AST_MEMBER, rcvr, offset, width]

`AST_PROGRAM`

pub int AST_PROGRAM = 301;

[AST_PROGRAM, decls[]]

`AST_RETURN`

pub int AST_RETURN = 407;

[AST_RETURN, kwT, expr?]

`AST_STRUCT`

pub int AST_STRUCT = 306;

[AST_STRUCT, nameT, members?]

`AST_TYPE_BOOL`

pub int AST_TYPE_BOOL = 501;

[AST_TYPE_BOOL]

`AST_TYPE_CHAR`

pub int AST_TYPE_CHAR = 502;

[AST_TYPE_CHAR]

`AST_TYPE_INT`

pub int AST_TYPE_INT = 503;

[AST_TYPE_INT]

`AST_TYPE_MEMBER`

pub int AST_TYPE_MEMBER = 1003;

[AST_TYPE_MEMBER, name, offset, width]

`AST_TYPE_NAMED`

pub int AST_TYPE_NAMED = 550;

[AST_TYPE_NAMED, nameT]

`AST_TYPE_PTR`

pub int AST_TYPE_PTR = 521;

[AST_TYPE_PTR, type]

`AST_TYPE_STRUCT`

pub int AST_TYPE_STRUCT = 1002;

[AST_TYPE_STRUCT, alignof, sizeof, memberMap]

`AST_TYPE_VOID`

pub int AST_TYPE_VOID = 520;

[AST_TYPE_VOID]

`AST_UNARY`

pub int AST_UNARY = 101;

[AST_UNARY, op, operand]

`AST_VARIABLE`

pub int AST_VARIABLE = 307;

[AST_VARIABLE, type, nameT?, init?]

`AST_WHILE`

pub int AST_WHILE = 404;

[AST_WHILE, cond, stmts[]]

`Ast4`

pub struct Ast4

`ast1`

pub fn ast1(int type)

[type] 1-tuple (silly, but uniform)

`ast2`

pub fn ast2(int type, void value)

[type, value] 2-tuple

`ast3`

pub fn ast3(int type, void value, void left)

[type, value, left] 3-tuple

`ast4`

pub fn ast4(int type, void value, void left, void right)

[type, value, left, right] 4-tuple

`ast_alignment`

pub fn ast_alignment(void* ast)

`ast_sizeof`

pub fn ast_sizeof(void* ast)

`drop_ast`

pub fn drop_ast(Ast4* ast)

I drop an AST. It might be narrower than Ast4, but the type field will indicate that.