type context[link]

type context = struct {
	out: io::handle,
	stack: nullable *stack,
	linelen: size,
	indent: size,
};

Context about the unparsing state supplied to a synfunc. The linelen and indent fields may be mutated.

type stack[link]

type stack = struct {
	cur: (*ast::decl | *ast::expr | *ast::_type | *ast::import),
	up: nullable *stack,
	extra: nullable *opaque,
};

A linked list of AST nodes currently being unparsed.

type synfunc[link]

type synfunc = fn(ctx: *context, s: str, kind: synkind) (size | io::error);

A user-supplied function which writes unparsed Hare source code to a handle, optionally including extra stylistic features. The function is expected to write to, at the minimum, write the provided string to ctx.out, and update ctx.linelen based on how much data was written.

syn_nowrap and syn_wrap are provided for when no additional styling is desired.

type synkind[link]

type synkind = enum {
	IDENT,
	COMMENT,
	CONSTANT,
	FUNCTION,
	GLOBAL,
	TYPEDEF,
	IMPORT_ALIAS,
	SECONDARY,
	KEYWORD,
	TYPE,
	ATTRIBUTE,
	OPERATOR,
	PUNCTUATION,
	RUNE_STRING,
	NUMBER,
	LABEL,
};

The kind of thing being unparsed.

fn _type[link]

fn _type(out: io::handle, syn: *synfunc, t: *ast::_type) (size | io::error);

Unparses a hare::ast::_type.

fn builtin_type[link]

fn builtin_type(b: ast::builtin_type) str;

Returns a builtin type as a string.

fn decl[link]

fn decl(out: io::handle, syn: *synfunc, d: *ast::decl) (size | io::error);

Unparses a hare::ast::decl.

fn expr[link]

fn expr(out: io::handle, syn: *synfunc, e: *ast::expr) (size | io::error);

Unparses a hare::ast::expr.

fn ident[link]

fn ident(out: io::handle, id: ast::ident) (size | io::error);

Unparses an identifier.

fn identstr[link]

fn identstr(id: ast::ident) str;

Unparses an identifier into a string. The caller must free the return value.

fn import[link]

fn import(out: io::handle, syn: *synfunc, import: *ast::import) (size | io::error);

Unparses a hare::ast::import.

fn subunit[link]

fn subunit(out: io::handle, syn: *synfunc, s: ast::subunit) (size | io::error);

Unparses a hare::ast::subunit.

fn syn_nowrap[link]

fn syn_nowrap(ctx: *context, s: str, kind: synkind) (size | io::error);

A synfunc implementation which unparses without additional styling, and without wrapping any long lines.

fn syn_wrap[link]

fn syn_wrap(ctx: *context, s: str, kind: synkind) (size | io::error);

A synfunc implementation which unparses without additional styling, but which wraps some long lines at 80 columns, in accordance with the style guide.