Aria

compiler.c (174123B)

---

 #include <assert.h>
 #include <ctype.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
 
 /* @note redeinition of assert() for ease of debugging. */
 
 #if 0
 #ifdef assert
 #undef assert
 #endif
 static void
 myassert(const char *expr, const char *file, int line)
 {
 	_assert(expr, file, line);
 }
 
 #define assert(_Expression) (void) ( \
 	(!!(_Expression)) || (myassert(#_Expression,__FILE__,__LINE__),0) \
 )
 #endif
 
 // @section forward declarations {{{
 
 typedef unsigned char uchar;
 typedef unsigned int uint;
 
 typedef
 struct Node Node;
 
 typedef
 struct Type Type;
 
 typedef
 struct Decl Decl;
 
 typedef
 struct Env Env;
 
 typedef
 struct AnnotParam AnnotParam;
 
 typedef
 struct Annot Annot;
 
 typedef
 struct Docket Docket;
 
 typedef
 struct Gist Gist;
 
 typedef
 struct Conduct Conduct;
 
 typedef
 struct Block Block;
 
 
 
 // }}}
 
 // @section node kind table {{{
 
 #define SENDOFFILE "end-of-file"
 #define SINVALID   "invalide token"
 #define SLINEDELIM "line-delimiter"
 
 #define SCHAR   "character-literal"
 #define SIDENT  "identifier"
 #define SNUMBER "number-literal"
 #define SSTRING "string-literal"
 
 #define SASTMT      "statement"
 #define SALOOPUNTIL "loop-until-clause"
 #define SADECL      "declaration"
 #define SADECLREF   "symbol-reference"
 #define SASWITCH    "case-clause"
 #define SACASE      "of-clause"
 #define SACONV      "conversion"
 
 #define NODETAB \
 	/*    tag        , string      , childs , flags   , prec */ \
 	/* Basic */ \
 	entry(ENDOFFILE  , SENDOFFILE  ,      0 ,       0 ,         0) \
 	entry(INVALID    , SINVALID    ,      0 ,       0 ,         0) \
 	entry(LINEDELIM  , SLINEDELIM  ,      0 ,       0 ,         0) \
 	entry(SEMIDELIM  , ";"         ,      0 ,       0 ,         0) \
 	entry(COMMADELIM , ","         ,      0 ,       0 ,         0) \
 	entry(COLONDELIM , ":"         ,      0 ,       0 ,         0) \
 	entry(LCURLDELIM , "{"         ,      0 ,       0 ,         0) \
 	entry(LSQRDELIM  , "["         ,      0 ,       0 ,         0) \
 	entry(LPARDELIM  , "("         ,      0 ,       0 ,         0) \
 	entry(RCURLDELIM , "}"         ,      0 ,       0 ,         0) \
 	entry(RSQRDELIM  , "]"         ,      0 ,       0 ,         0) \
 	entry(RPARDELIM  , ")"         ,      0 ,       0 ,         0) \
 	entry(ANNOT      , "@"         ,      0 ,       0 ,         0) \
 	entry(CHAR       , SCHAR       ,      0 ,       0 ,         0) \
 	entry(IDENT      , SIDENT      ,      0 ,       0 ,         0) \
 	entry(NUMBER     , SNUMBER     ,      0 ,       0 ,         0) \
 	entry(STRING     , SSTRING     ,      0 ,       0 ,         0) \
 	entry(TYPE       , "type"      ,      0 ,       0 ,         0) \
 	/* Keywords */ \
 	entry(KVOID      , "void"      ,      0 ,       0 ,         0) \
 	entry(KBOOL      , "bool"      ,      0 ,       0 ,         0) \
 	entry(KU8        , "u8"        ,      0 ,       0 ,         0) \
 	entry(KS8        , "s8"        ,      0 ,       0 ,         0) \
 	entry(KU16       , "u16"       ,      0 ,       0 ,         0) \
 	entry(KS16       , "s16"       ,      0 ,       0 ,         0) \
 	entry(KU32       , "u32"       ,      0 ,       0 ,         0) \
 	entry(KS32       , "s32"       ,      0 ,       0 ,         0) \
 	entry(KU64       , "u64"       ,      0 ,       0 ,         0) \
 	entry(KS64       , "s64"       ,      0 ,       0 ,         0) \
 	entry(KF32       , "f32"       ,      0 ,       0 ,         0) \
 	entry(KF64       , "f64"       ,      0 ,       0 ,         0) \
 	entry(KUCHAR     , "uchar"     ,      0 ,       0 ,         0) \
 	entry(KCHAR      , "char"      ,      0 ,       0 ,         0) \
 	entry(KUSHORT    , "ushort"    ,      0 ,       0 ,         0) \
 	entry(KSHORT     , "short"     ,      0 ,       0 ,         0) \
 	entry(KUINT      , "uint"      ,      0 ,       0 ,         0) \
 	entry(KINT       , "int"       ,      0 ,       0 ,         0) \
 	entry(KULONG     , "ulong"     ,      0 ,       0 ,         0) \
 	entry(KLONG      , "long"      ,      0 ,       0 ,         0) \
 	entry(KULLONG    , "ullong"    ,      0 ,       0 ,         0) \
 	entry(KLLONG     , "llong"     ,      0 ,       0 ,         0) \
 	entry(KFLOAT     , "float"     ,      0 ,       0 ,         0) \
 	entry(KDOUBLE    , "double"    ,      0 ,       0 ,         0) \
 	entry(KLDOUBLE   , "ldouble"   ,      0 ,       0 ,         0) \
 	entry(KUSIZE     , "usize"     ,      0 ,       0 ,         0) \
 	entry(KSSIZE     , "ssize"     ,      0 ,       0 ,         0) \
 	entry(KFALSE     , "false"     ,      0 ,       0 ,         0) \
 	entry(KTRUE      , "true"      ,      0 ,       0 ,         0) \
 	entry(KNULL      , "null"      ,      0 ,       0 ,         0) \
 	entry(KUSE       , "use"       ,      0 ,       0 ,         0) \
 	entry(KBUNDLE    , "bundle"    ,      0 ,       0 ,         0) \
 	entry(KNOT       , "not"       ,      0 ,       0 ,         0) \
 	entry(KAND       , "and"       ,      0 ,       0 ,         0) \
 	entry(KOR        , "or"        ,      0 ,       0 ,         0) \
 	entry(KIS        , "is"        ,      0 ,       0 ,         0) \
 	entry(KSIZEOF    , "sizeof"    ,      0 ,       0 ,         0) \
 	entry(KALIGNOF   , "alignof"   ,      0 ,       0 ,         0) \
 	entry(KLENGTHOF  , "lengthof"  ,      0 ,       0 ,         0) \
 	entry(KBITCAST   , "bitcast"   ,      0 ,       0 ,         0) \
 	entry(KEXTERN    , "extern"    ,      0 ,       0 ,         0) \
 	entry(KINTERN    , "intern"    ,      0 ,       0 ,         0) \
 	entry(KSTATIC    , "static"    ,      0 ,       0 ,         0) \
 	entry(KCONST     , "const"     ,      0 ,       0 ,         0) \
 	entry(KVAR       , "var"       ,      0 ,       0 ,         0) \
 	entry(KBREAK     , "break"     ,      0 ,       0 ,         0) \
 	entry(KCONTINUE  , "continue"  ,      0 ,       0 ,         0) \
 	entry(KGOTO      , "goto"      ,      0 ,       0 ,         0) \
 	entry(KRETURN    , "return"    ,      0 ,       0 ,         0) \
 	entry(KIF        , "if"        ,      0 ,       0 ,         0) \
 	entry(KELSE      , "else"      ,      0 ,       0 ,         0) \
 	entry(KCASE      , "case"      ,      0 ,       0 ,         0) \
 	entry(KOF        , "of"        ,      0 ,       0 ,         0) \
 	entry(KDO        , "do"        ,      0 ,       0 ,         0) \
 	entry(KFOR       , "for"       ,      0 ,       0 ,         0) \
 	entry(KLOOP      , "loop"      ,      0 ,       0 ,         0) \
 	entry(KWHILE     , "while"     ,      0 ,       0 ,         0) \
 	entry(KUNTIL     , "until"     ,      0 ,       0 ,         0) \
 	entry(KSTRUCT    , "struct"    ,      0 ,       0 ,         0) \
 	entry(KUNION     , "union"     ,      0 ,       0 ,         0) \
 	/* Operators */ \
 	entry(OSUFINC    , "++"        ,      1 , FRASSOC , PUNSUF   ) \
 	entry(OSUFDEC    , "--"        ,      1 , FRASSOC , PUNSUF   ) \
 	entry(OARRAY     , "[]"        ,      1 , FRASSOC , PUNSUF   ) \
 	entry(OCALL      , "()"        ,      1 , FRASSOC , PUNSUF   ) \
 	entry(ODISP      , "."         ,      1 , FRASSOC , PUNSUF   ) \
 	entry(ODEREF     , "*"         ,      1 ,       0 , PUNARY   ) \
 	entry(OINC       , "++"        ,      1 ,       0 , PUNARY   ) \
 	entry(ODEC       , "--"        ,      1 ,       0 , PUNARY   ) \
 	entry(OBNOT      , "~"         ,      1 ,       0 , PUNARY   ) \
 	entry(OLNOT      , "!"         ,      1 ,       0 , PUNARY   ) \
 	entry(OFLIP      , "!>"        ,      1 ,       0 , PUNARY   ) \
 	entry(OADDR      , "&"         ,      1 ,       0 , PUNARY   ) \
 	entry(OPLUS      , "+"         ,      1 ,       0 , PUNARY   ) \
 	entry(OMINUS     , "-"         ,      1 ,       0 , PUNARY   ) \
 	entry(OCAST      , "(type)"    ,      1 ,       0 , PUNARY   ) \
 	entry(OMUL       , "*"         ,      2 ,       0 , PMUL     ) \
 	entry(ODIV       , "/"         ,      2 ,       0 , PMUL     ) \
 	entry(OMOD       , "%"         ,      2 ,       0 , PMUL     ) \
 	entry(OLSH       , "<<"        ,      2 ,       0 , PMUL     ) \
 	entry(OARSH      , ">>>"       ,      2 ,       0 , PMUL     ) \
 	entry(ORSH       , ">>"        ,      2 ,       0 , PMUL     ) \
 	entry(OBAND      , "&"         ,      2 ,       0 , PMUL     ) \
 	entry(OADD       , "+"         ,      2 ,       0 , PADD     ) \
 	entry(OSUB       , "-"         ,      2 ,       0 , PADD     ) \
 	entry(OBOR       , "|"         ,      2 ,       0 , PADD     ) \
 	entry(OXOR       , "^"         ,      2 ,       0 , PADD     ) \
 	entry(ORANGE     , ".."        ,      2 ,       0 , PRANGE   ) \
 	entry(OLEQ       , "<="        ,      2 ,       0 , PRELAT   ) \
 	entry(OLET       , "<"         ,      2 ,       0 , PRELAT   ) \
 	entry(OGEQ       , ">="        ,      2 ,       0 , PRELAT   ) \
 	entry(OGRT       , ">"         ,      2 ,       0 , PRELAT   ) \
 	entry(ONEQ       , "!="        ,      2 ,       0 , PRELAT   ) \
 	entry(OEQU       , "=="        ,      2 ,       0 , PRELAT   ) \
 	entry(OIDENT     , "==="       ,      2 ,       0 , PRELAT   ) \
 	entry(OLAND      , "&&"        ,      2 ,       0 , PAND     ) \
 	entry(OLOR       , "||"        ,      2 ,       0 , POR      ) \
 	entry(OASS       , "="         ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OMULA      , "*="        ,      2 , FRASSOC , PASSIGN  ) \
 	entry(ODIVA      , "/="        ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OMODA      , "%="        ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OLSHA      , "<<="       ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OARSHA     , ">>>="      ,      2 , FRASSOC , PASSIGN  ) \
 	entry(ORSHA      , ">>="       ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OANDA      , "&="        ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OADDA      , "+="        ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OSUBA      , "-="        ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OORA       , "|="        ,      2 , FRASSOC , PASSIGN  ) \
 	entry(OXORA      , "^="        ,      2 , FRASSOC , PASSIGN  ) \
 	/* Ast */ \
 	entry(ACOMMA     , ","         ,      0 ,       0 ,         0) \
 	entry(ASTMT      , SASTMT      ,      0 ,       0 ,         0) \
 	entry(ADECL      , SADECL      ,      0 ,       0 ,         0) \
 	entry(ADECLREF   , SADECLREF   ,      0 ,       0 ,         0) \
 	entry(AENV       , "env"       ,      0 ,       0 ,         0) \
 	entry(ALOOPUNTIL , SALOOPUNTIL ,      0 ,       0 ,         0) \
 	entry(AFOREACH   , "for-each"  ,      0 ,       0 ,         0) \
 	entry(AFORSTEP   , "for-step"  ,      0 ,       0 ,         0) \
 	entry(ASCOPE     , "scope"     ,      0 ,       0 ,         0) \
 	entry(ALABEL     , "label"     ,      0 ,       0 ,         0) \
 	entry(ASWITCH    , SASWITCH    ,      0 ,       0 ,         0) \
 	entry(ACASE      , SACASE      ,      0 ,       0 ,         0) \
 	entry(ACONV      , SACONV      ,      0 ,       0 ,         0) \
 	entry(ADEREF     , "*"         ,      0 ,       0 ,         0) \
 	entry(AADDR      , "&"         ,      0 ,       0 ,         0) \
 	entry(ACOMPOUND  , "{...}"     ,      0 ,       0 ,         0) \
 	entry(AFIELDINIT , ":"         ,      0 ,       0 ,         0) \
 	entry(ASELFDISP  , ":"         ,      0 ,       0 ,         0) \
 	/* endof NODETAB */
 
 #define isbinaryop(kind) ((kind) >= OMUL && (kind) < ACOMMA)
 
 
 
 // }}}
 
 // @section type kind table {{{
 
 #define TYPETAB \
 	/*    tag        , size , align*/ \
 	entry(TNONE      ,    0 ,         0) \
 	entry(TERRTYPE   ,    0 ,         0) \
 	entry(TUNDEFINED ,    0 ,         0) \
 	entry(TVOID      ,    0 ,         0) \
 	entry(TBOOL      ,    1 ,         1) \
 	entry(TINFER     ,    4 ,         4) \
 	entry(TUINFER    ,    4 ,         4) \
 	entry(TS8        ,    1 ,         1) \
 	entry(TU8        ,    1 ,         1) \
 	entry(TS16       ,    2 ,         2) \
 	entry(TU16       ,    2 ,         2) \
 	entry(TS32       ,    4 ,         4) \
 	entry(TU32       ,    4 ,         4) \
 	entry(TS64       ,    8 ,         8) \
 	entry(TU64       ,    8 ,         8) \
 	entry(TF32       ,    4 ,         4) \
 	entry(TF64       ,    8 ,         8) \
 	entry(TPTR       ,    8 ,         8) \
 	entry(TARRAY     ,    0 ,         0) \
 	entry(TTUPLE     ,    0 ,         0) \
 	entry(TFUNCTION  ,    0 ,         0) \
 	entry(TSTRUCT    ,    0 ,         0) \
 	entry(TUNION     ,    0 ,         0) \
 	/* endof TYPETAB */
 
 #define TCHAR    TS8
 #define TUCHAR   TU8
 #define TSHORT   TS16
 #define TUSHORT  TU16
 #define TINT     TS32
 #define TUINT    TU32
 #define TLONG    TS64
 #define TULONG   TU64
 #define TLLONG   TS64
 #define TULLONG  TU64
 
 #define TFLOAT   TF32
 #define TDOUBLE  TF64
 #define TLDOUBLE TF64
 
 #define TSSIZE   TS64
 #define TUSIZE   TU64
 /* @todo maybe add long double type ? */
 
 #define TYPEKEWORDYTAB \
 	entry(VOID)  entry(BOOL)   \
 	entry(S8)    entry(U8)     \
 	entry(S16)   entry(U16)    \
 	entry(S32)   entry(U32)    \
 	entry(S64)   entry(U64)    \
 	entry(F32)   entry(F64)    \
 	entry(CHAR)  entry(UCHAR)  \
 	entry(SHORT) entry(USHORT) \
 	entry(INT)   entry(UINT)   \
 	entry(LONG)  entry(ULONG)  \
 	entry(LLONG) entry(ULLONG) \
 	entry(FLOAT) entry(DOUBLE) entry(LDOUBLE) \
 	entry(SSIZE) entry(USIZE)  \
 	/* endof TYPEKEYWORDTAB */
 
 
 
 // }}}
 
 // @section enumerations & constants {{{
 
 typedef
 enum Flags {
 	FRASSOC = 1
 } Flads;
 
 typedef
 enum Precedence {
 	PUNSUF  = 10,
 	PUNARY  =  9,
 	PMUL    =  8,
 	PADD    =  7,
 	PRANGE  =  6,
 	PRELAT  =  5,
 	PAND    =  4,
 	POR     =  3,
 	PASSIGN =  2,
 
 	PSTART  =  1
 } Precedence;
 
 typedef
 enum Kind {
 	#define entry(tag, string, childs, flags, prec) \
 		tag,
 	NODETAB
 	#undef entry
 
 	MAXKINDS
 } Kind;
 
 #define KSTART KVOID
 #define OSTART OSUFINC
 #define ASTART ASTMT
 
 #define iskeyword(kind) ((kind) >= KSTART && (kind) < OSTART)
 #define isoperator(kind) ((kind) >= OSTART && (kind) < ASTART)
 #define isastnode(kind) ((kind) >= ASTART && (kind) < MAXKINDS)
 
 static bool
 isatomnode(Kind kind)
 {
 	return kind == IDENT  || kind == ADECLREF || kind == NUMBER ||
 	       kind == STRING || kind == CHAR;
 }
 
 
 typedef
 enum TypeKind {
 	#define entry(tag, size, align) \
 		tag,
 	TYPETAB
 	#undef entry
 
 	TMAX
 } TypeKind;
 
 
 typedef
 enum DeclKind {
 	DMODULE = 0,
 	DTYPE, /* @note maybe be the same as void-module ? */
 	DVAR,
 	DPARAM,
 	DFUNCTION,
 	DFIELDALIAS,
 	DBUNDLE,
 	/*
 	DMACRO,
 	DENFOLD
 	*/
 } DeclKind;
 
 typedef
 enum DeclFlags {
 	MSPECIAL = 0x0001,
 	/* MINPORT  = 0x0002, ... */
 } DeclFlags;
 
 typedef
 enum EnvKind {
 	STOPLEVEL = 0,
 	SPARAMLIST,
 	SFUNCTION,
 	SSCOPE,
 	SIFHEADER,
 	SLOOPHEADER,
 	SDO,
 	SLOOP,
 	SWHILE,
 	SIF,
 	SELSE,
 	SSTRUCT,
 	SUNION
 	/*
 	SUNION,
 	SSTRUCT,
 	SENUM,
 	*/
 } EnvKind;
 
 typedef
 enum Qualifier {
 	QINTERN = 0x0001,
 	QEXTERN = 0x0002,
 
 	QSTATIC = 0x0010,
 
 	QCONST  = 0x0200,
 
 	QVAR    = 0x1000,
 
 	/* masks */
 	QALL     = QINTERN | QEXTERN | QSTATIC | QCONST | QVAR,
 	QVISIB   = QEXTERN | QINTERN,
 	QSTORAGE = QSTATIC,
 	QTYPE    = QCONST,
 	QINFER   = QVAR
 } Qualifier;
 
 typedef
 enum AnnotParamKind {
 	NSTATEEXPR,
 	NPARAM,
 	NEXPR
 } AnnotParamKind;
 
 typedef
 enum BlockKind {
 	BTOPLEVEL  = 0,
 	BFUNCTION  = 1,
 	BSCOPE     = 2,
 	BIF        = 3,
 	BLOOP      = 4,
 	BWHILELOOP = 5,
 	BLOOPUNTIL = 6,
 	BFORLOOP   = 7,
 	BELSE      = 8
 } BlockKind;
 
 typedef
 enum ConductKind {
 	CUNREACH   = 0, /* alway after a break, continue, goto or return */
 	CSCOPE     = 1, /* only the first conduct of a block and conducts after
 	                 * cunducts containing blocks are of this kind */
 	CBLOCK     = 2, /* always containing one or more blocks and nothing
 	                   else */
 	CLABEL     = 3  /* always after a label */
 } ConductKind;
 
 
 
 // }}}
 
 // @section type definitions {{{
 
 typedef
 struct SrcLoc {
 	uint line, column;
 	const char *filename;
 } SrcLoc;
 
 /**
  * @brief A node in the abstract syntax tree.
  * @details The location is used to report errors. The type is used to store the
  *          type of the node. The union u is used to store the value of the node
  *          for its given kind. The lhs pointer points to the left hand side of
  *          its child node and the rhs pointer points to the right hand side of
  *          its child node (if any). Or the lhs and rhs pointer are used to
  *          point to the previous and next statement in a linked list (in case
  *          of ASTMT). Additionally, the payload pointer is used to store the
  *          condition of an if-statement and other statements.
  */
 struct Node {
 	Kind kind;
 	SrcLoc loc;
 
 	Type *type;
 
 	union {
 		int key;
 
 		double d;
 		uintmax_t u;
 		intmax_t s;
 
 		Node *payload;
 		Decl *declref;
 		Env *env;
 	} u;
 
 	Node *lhs, *rhs;
 	/* ASTMT: rhs points to next stmt (linked list) */
 };
 
 struct Type {
 	TypeKind kind;
 	SrcLoc loc;
 
 	Type *target; /* pointer, array, tuple-lht, function param-list, ... */
 
 	size_t size, align;
 
 	union {
 		struct {
 			int offset, size; /* in bits */
 		} bit;
 
 		struct {
 			size_t length;
 			size_t elemsize;
 		} array;
 
 		Node *val;
 		Type *rtarget; /* for tuples (rht) and function return-type */
 	} u;
 
 	Decl *module; /* module and record info */
 };
 
 typedef struct Field Field;
 
 typedef struct Record {
 	Field *head, *tail;
 
 	bool isunion;
 } Record;
 
 struct Field {
 	Decl *decl;
 
 	size_t offset, size; /* in bytes */
 
 	bool use;
 
 	Field *prev, *next;
 };
 
 struct Decl {
 	DeclKind kind;
 	SrcLoc loc;
 
 	Type *type;
 	Decl *module; /* module or bundle */
 	Record *record;
 
 	int key;
 	DeclFlags flags;
 
 	Env *parentenv, *contentenv;
 	union {
 		Node *content; /* init or function body */
 
 		bool usefield;
 	} u;
 
 	Decl *prev, *next;
 };
 
 struct Env {
 	EnvKind kind;
 	SrcLoc loc;
 
 	uint8_t keycache[64];
 
 	Decl *head, *tail;
 
 	Node *stmts;
 	Decl *envdecl; /* for SFUNCTION, SSTRUCT, SUNION */
 
 	/* for toplevel declarations. it will be assigned to decl->module
 	 * if decl->module is null (in declaration()). */
 	Decl *bundle;
 
 	Env *below;
 
 	bool pending;
 	Env *pendingnext, *pendingprev;
 };
 
 typedef
 struct Source {
 	SrcLoc currloc;
 
 	/* pre-lexer state */
 
 	char line[4096];
 	long linepos;
 
 	bool handlereplprompt;
 
 	/* error-reporting and lexer state */
 
 	FILE *filein;
 	int tabwidth;
 	char stringbuf[1024];
 
 	int lastindent, lastkind;
 	Node tok, savedtok;
 
 	/* environment */
 
 	Env *headenv, *currenv;
 	Env *pendingenvhead, *pendingenvtail;
 
 	Env *implicitenv;
 
 	bool haspendingenv;
 
 	/* pending nodes */
 	Node *pendingnodes[512];
 	int pendingcount;
 
 	/* parser state */
 	Node *lastis;
 
 	/* stack-alloc save state */
 } Source;
 
 struct AnnotParam {
 	AnnotParamKind kind;
 
 	int key;
 
 	Node *node;
 
 	AnnotParam *prev, *next;
 };
 
 struct Annot {
 	int key;
 	SrcLoc loc;
 
 	AnnotParam *head, *tail;
 
 	Annot *prev, *next;
 };
 
 struct Docket {
 	Node *node;
 	Decl *decl;
 
 	Annot *head, *tail;
 };
 
 struct Gist {
 	Decl *decl;
 	Conduct *parent;
 
 	bool init;
 	Node *where;
 
 	/* for other declarations */
 	Gist *prev, *next;
 };
 
 struct Block {
 	BlockKind kind;
 
 	Env *env;
 
 	/* Conduct-Sequence list*/
 	Conduct *head, *tail, *parent;
 
 	/* Neighbooring Blocks */
 	Block *prev, *next;
 };
 
 struct Conduct {
 	ConductKind kind;
 	uint id;
 
 	Node *label, *branch;
 	Node *first, *last;
 
 	bool doesbreak;
 	bool doescontinue;
 	bool doesreturn;
 	bool doesjump;
 
 	struct ConductGists {
 		Gist *head, *tail;
 	} gists;
 
 	struct ConductBranches {
 		/* Branch-relation from child to parents */
 		Conduct *head, *tail;
 
 		/* Branch-parent list */
 		Conduct *next, *prev;
 	} branches;
 
 	/* Block-stack */
 	Block *head, *tail, *parent;
 
 	/* Conduct-sequence list */
 	Conduct *next, *prev;
 };
 
 typedef struct Section   Section;
 typedef struct Edge      Edge;
 typedef struct EdgeEntry EdgeEntry;
 typedef struct Analysis  Analysis;
 
 typedef enum EdgeKind {
 	JBRANCH   = 0, /* unconditional branch */
 	JIFBRANCH = 1, /* conditional branch */
 	JNEXT     = 2, /* unconditional next section (without branch) */
 	JIFNEXT   = 3  /* conditional next section (without branch) */
 } EdgeKind;
 
 struct Edge {
 	EdgeKind kind;
 	Section *section;
 
 	Conduct *gistlist; /* @note maybe remove this, since the gistlist
 	                    *              is always the last of a section */
 
 	/* @todo add information about the branch/edge condition */
 	
 	/* for memory-management, since an edge is used in mult. edge-entries */
 	int refcount;
 };
 
 typedef enum EdgeEntryKind {
 	JINGOING  = 0, /* added as reachedfrom to section */
 	JOUTGOING = 1, /* added as branchto to section */
 	JSTART    = 2, /* added as reachedfrom edge entry to first section */
 	JEND      = 3  /* added as branchto edge entry to last section */
 } EdgeEntryKind;
 
 /* @note since an edge is used in multiple lists, edge-entry is used
  *              as linked-list entry */
 struct EdgeEntry {
 	EdgeEntryKind kind;
 	Section *belongsto;
 
 	Edge *edge; /* is NULL on JSTART or JEND */
 	EdgeEntry *prev, *next;
 };
 
 /* a section is single level. there is no hierarchy, like in the case of
  * scopes/environments. a function has simply a list of section from top to
  * bottom. */
 struct Section {
 	uint id; /* incremental number */
 
 	/* a section begins after baranch/label/start and ends
 	 * containing a terminating branch/label/end. this way it contains at
 	 * least one instructin/statement (terminating branch/label), if the 
 	 * (terminating branch/label/end) is not augment at the end of the
 	 * function-scope/clause. */
 	Node *first, *last;
 
 	struct {
 		Conduct *head, *tail;
 	} gistlists;
 
 	struct {
 		EdgeEntry *head, *tail;
 	} reachedfrom;
 
 	struct {
 		EdgeEntry *head, *tail;
 	} branchto;
 
 	/* prev/next section in code (no branch-info) from top to bottom
 	 * in function */
 	Section *prev, *next;
 };
 
 struct Analysis {
 	Section *head, *tail;
 };
 
 
 
 // }}}
 
 // @section global-vars {{{
 
 Source testsource;
 
 
 
 // }}}
 
 // @section look-up tables {{{
 
 #define defaultloc {0, 1, "<builtin>"}
 
 #define entry(tag, size, align) \
 	{(tag), defaultloc, NULL, (size), (align), {{0}}, NULL},
 Type prim[] = {
 	TYPETAB
 };
 #undef entry
 
 #define primitive(typetag) (prim + typetag)
 
 int keywordlengths[OSTART - KSTART];
 
 const int keywordtypeids[] = {
 	#define entry(tag) \
 		[K##tag] = T##tag,
 	TYPEKEWORDYTAB
 	#undef entry
 
 	[OSTART] = 0
 };
 
 const char *const nodestrings[MAXKINDS] = {
 	#define entry(tag, string, childs, flags, prec) \
 		string,
 	NODETAB
 	#undef entry
 };
 
 /*
 Node kinds:
 	'@' - Annotation
 	';' ',' ':' '{' '}' ']' ')' - Delimiters
 	'A' - Statement
 	'I' - Identifier
 	'K' - Keyword
 	'N' - Number-literal
 	'O' - Operator
 	'S' - String-literal
 */
 
 #define opentry(numops, rassoc, prec) \
 	((uint8_t) ( ((numops) << 6) | ((rassoc) << 5) | (prec) ))
 
 const uint8_t opinfo[] = {
 	#define entry(tag, string, childs, flags, prec) ((uint8_t) ( \
 		((childs) << 6) | \
 		(!!(flags & FRASSOC) << 5) | \
 		(prec) \
 	)),
 	NODETAB
 	#undef entry
 };
 
 #define getnumops(kind) (opinfo[kind] >> 6)
 #define israssoc(kind) ((opinfo[kind] >> 5) & 0x01)
 #define getprec(kind) ((opinfo[kind] & 0x1f))
 
 
 
 // }}}
 
 // @section utility functions {{{
 
 #define listappendex(parent, child, head, tail, prev, next) do { \
 	if ((parent)->head) { \
 		assert((parent)->tail); \
 		(child)->prev = (parent)->tail; \
 		(child)->next = NULL; \
 		(parent)->tail->next = (child); \
 	} else { \
 		assert(!(parent)->tail); \
 		(child)->prev = NULL; \
 		(child)->next = NULL; \
 		(parent)->head = (child); \
 	} \
 	(parent)->tail = (child); \
 } while (0)
 
 #define listappend(parent, child) \
 	listappendex(parent, child, head, tail, prev, next)
 
 #ifndef lengthof
 #define lengthof(array) ((int) sizeof(array) / (int) sizeof(*(array)))
 #endif
 
 #define unpool(pool, top) \
 	(assert((top) < lengthof(pool)), \
 	 memset((pool) + (top), 0, sizeof*(pool)), \
 	 (pool) + (top)++)
 
 static int
 mystrncasecmp(const char *str1, const char *str2, size_t max_len)
 {
 	char tmp1[] = {'\0', '\0'};
 	char tmp2[] = {'\0', '\0'};
 	char c1, c2;
 	int result;
 
 	size_t i;
 
 	if (max_len == 0) {
 		size_t len1 = strlen(str1);
 		size_t len2 = strlen(str2);
 		max_len = len1 > len2 ? len1 : len2;
 	}
 
 	for (i = 0; i < max_len; ++i) {
 		c1 = tolower(str1[i]);
 		c2 = tolower(str2[i]);
 		if (c1 == '\0' && c2 == '\0') return 0;
 		tmp1[0] = c1;
 		tmp2[0] = c2;
 		result = strcmp(tmp1, tmp2);
 		if (result != 0) return result;
 	}
 
 	return 0;
 }
 
 static int
 mystrcasecmp(const char *str1, const char *str2)
 {
 	char tmp1[] = {'\0', '\0'};
 	char tmp2[] = {'\0', '\0'};
 	char c1, c2;
 	int result;
 
 	size_t i;
 
 	for (i = 0;; ++i) {
 		c1 = tolower(str1[i]);
 		c2 = tolower(str2[i]);
 		if (c1 == '\0' && c2 == '\0') return 0;
 		tmp1[0] = c1;
 		tmp2[0] = c2;
 		result = strcmp(tmp1, tmp2);
 		if (result != 0) return result;
 	}
 
 	return 0;
 }
 
 
 
 // }}}
 
 // @section pre-lexer {{{
 
 static void
 tryprompt(Source *source, const char ch);
 
 static bool
 processcommand(Source *source);
 
 static bool
 mygetline(Source *source)
 {
 	int i, l, c;
 	FILE *in = source->filein;
 
 	tryprompt(source, '.');
 	c = getc(in);
 
 	source->linepos = ftell(in);
 
 advance:
 	++source->currloc.line;
 
 	i = 0, l = 0;
 	while (c == '\r' || c == '\n') {
 		tryprompt(source, '.');
 		l = c, c = getc(in);
 
 		if (l == '\r' && c == '\n')
 		       c = getc(in);
 
 		++source->currloc.line;
 	}
 
 	source->tok.loc.line = source->currloc.line;
 
 	while (c != EOF && c != '\n' && c != '\r') {
 		source->line[i++] = c;
 		c = getc(in);
 
 		if (c == '\\') {
 			int x = getc(in);
 			if (x == '\n') {
 				tryprompt(source, '\\');
 				c = getc(in);
 
 				++source->currloc.line;
 			} else if (x == '\r') {
 				int y;
 
 				tryprompt(source, '\\');
 				y = getc(in);
 
 				c = (y == '\n') ? getc(in) : y;
 				++source->currloc.line;
 			} else if (x == EOF) {
 				c = x;
 			} else {
 				ungetc(x, in);
 			}
 		}
 	}
 
 	if (c == '\r') {
 		int x;
 
 		tryprompt(source, '.');
 		x = getc(in);
 		if (x != '\n')
 			ungetc(x, in);
 	}
 
 	if (c != EOF && i == 0)
 		goto advance;
 
 	source->line[i] = 0;
 
 	if (in == stdin && source->line[0] == ':')
 		return processcommand(source);
 
 	return c != EOF || i;
 }
 
 
 
 // }}}
 
 // @section keyword map {{{
 
 #define KEYWORD_MAP_SIZE 128
 const char *keywordkeys[KEYWORD_MAP_SIZE];
 int keywordvals[KEYWORD_MAP_SIZE];
 
 static int
 strnhash(const char *str, int n)
 {
 	int hash = 5381, i;
 	for (i = 0; i < n && str[i]; ++i)
 		hash = (hash << 5) + hash + str[i];
 	return hash;
 }
 
 static void
 initkeywords(void)
 {
 	int i, j, h;
 	for (i = 0; i < lengthof(keywordlengths); ++i) {
 		int n = keywordlengths[i] = strlen(nodestrings[i + KSTART]);
 		h = strnhash(nodestrings[i + KSTART], n) &
 			(lengthof(keywordkeys) - 8);
 		for (j = 0; j < 8; ++j, ++h) {
 			if (!keywordkeys[h]) {
 				keywordkeys[h] = nodestrings[i + KSTART];
 				keywordvals[h] = i;
 				goto nextkeyword;
 			}
 		}
 
 		fprintf(stderr, "bug: keyword hash-map is too small\n");
 		abort();
 	nextkeyword:
 		(void) 0;
 	}
 
 	/*
 	for (i = 0; i < lengthof(keywordkeys); ++i) {
 		printf("%-12s%c", keywordkeys[i] ? keywordkeys[i] : ".", (i+1) % 8 ? ' ' : '\n');
 	}
 	*/
 }
 
 static int
 getkeyword(const char *str, int n)
 {
 	int i, h = strnhash(str, n) & (lengthof(keywordkeys) - 8);
 	for (i = 0; i < 8; ++i, ++h) {
 		int len;
 		if (!keywordkeys[h])
 			return -1;
 		len = keywordlengths[keywordvals[h]];
 		if (n == len && memcmp(keywordkeys[h], str, n) == 0)
 			return keywordvals[h];
 	}
 	return -1;
 }
 
 
 
 // }}}
 
 // @section string map {{{
 
 typedef
 struct StringEntry {
 	int len;
 	const char *str;
 } StringEntry;
 
 typedef
 struct StringMap {
 	int *keys;
 	int keyscap;
 
 	StringEntry *vals;
 	int valscap, valslen;
 } StringMap;
 
 StringMap idents;
 StringMap strings;
 
 static void
 initstrmap(StringMap *map)
 {
 	map->keys = calloc(32, sizeof(int));
 	map->keyscap = 32;
 	assert(map->keys);
 
 	map->vals = calloc(32, sizeof(StringEntry));
 	map->valslen = 0;
 	map->valscap = 32;
 	assert(map->vals);
 }
 
 #if 0
 static void
 disposestrmap(StringMap *map)
 {
 	int i;
 	for (i = map->valslen - 1; i >= 0; --i) {
 		free((char *) map->vals[i].str);
 	}
 
 	free(map->vals);
 	free(map->keys);
 }
 #endif
 
 static void
 putstringkey(StringMap *map, int key, int hash)
 {
 	int *keys = map->keys;
 	StringEntry *vals = map->vals;
 
 	int i, j;
 
 redo:
 	j = (hash << 3) & (map->keyscap - 1);
 	for (i = 0; i < 8; ++i, ++j) {
 		if (!keys[j]) {
 			keys[j] = key;
 			return;
 		}
 	}
 
 	free(keys);
 	map->keyscap *= 2;
 	keys = map->keys = calloc(map->keyscap, sizeof(int));
 	for (i = 0; i < map->valslen; ++i) {
 		j = strnhash(vals[i].str, vals[i].len);
 		putstringkey(map, i + 1, j);
 	}
 
 	goto redo;
 }
 
 int auxthen, auxin, auxto, auxstep;
 int auxself;
 
 static int
 getstringkey(StringMap *map, const char *str, int n)
 {
 	int *keys = map->keys;
 	StringEntry *vals = map->vals;
 
 	int key, hash = strnhash(str, n);
 	int i, j = (hash << 3) & (map->keyscap - 1);
 
 	char *newstr;
 
 	for (i = 0; i < 8; ++i, ++j) {
 		key = keys[j];
 		if (!key)
 			break;
 
 		assert(key > 0);
 		if (n == vals[key - 1].len &&
 		    memcmp(str, vals[key - 1].str, n) == 0)
 		{
 			return key;
 		}
 	}
 
 	key = map->valslen + 1;
 	putstringkey(map, key, hash);
 
 	if (key > map->valscap) {
 		int cap = map->valscap * 3 / 2 + 1;
 		vals = map->vals = realloc(vals, cap * sizeof(StringEntry));
 		assert(vals);
 		map->valscap = cap;
 	}
 
 	newstr = calloc(n + 1, sizeof(char*)); /* @todo sizeof(char*) --> sizeof(char) ? */
 	assert(newstr);
 	memcpy(newstr, str, n);
 
 	vals[key - 1].len = n;
 	vals[key - 1].str = newstr;
 	++map->valslen;
 
 	return key;
 }
 
 #define getstring(map, key) ((map).vals[(key) - 1].str)
 #define getlength(map, key) ((map).vals[(key) - 1].len)
 
 
 
 // }}}
 
 // @section error reporting {{{
 
 int warningcount = 0;
 int errorcount = 0;
 
 static int
 warn(SrcLoc *loc, const char *fmt, ...)
 {
 	va_list ap;
 	int n;
 
 	const char *filename = loc ? loc->filename : "<unknown-source>";
 	uint line = loc ? loc->line : 1;
 	uint column = loc ? loc->column : 0;
 
 	va_start(ap, fmt);
 	n = fprintf(stderr, "%s:%u:%u: warning: ",
 		filename, line, column + 1);
 	n += vfprintf(stderr, fmt, ap);
 	n += fprintf(stderr, "\n");
 	va_end(ap);
 
 	++warningcount;
 	return n;
 }
 
 #define error(loc, ...) error_(loc, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
 
 static int
 error_(SrcLoc *loc, const char *func, const char *file, int line_,
 	const char *fmt, ...)
 {
 	va_list ap;
 	int n;
 
 	const char *filename = loc ? loc->filename : "<unknown-source>";
 	uint line = loc ? loc->line : 1;
 	uint column = loc ? loc->column : 0;
 
 	va_start(ap, fmt);
 	n = fprintf(stderr, "%s:%u:%u: error: ",
 		filename, line, column + 1);
 	n += vfprintf(stderr, fmt, ap);
 	n += fprintf(stderr, " \x1b[30m[in %s() at %s:%u]\x1b[0m\n", func, file, line_);
 	va_end(ap);
 
 	++errorcount;
 	return n;
 }
 
 
 
 // }}}
 
 // @section lexer {{{
 
 #define nextindent(source, indent) \
 	((indent) + (source)->tabwidth - ((indent) % (source)->tabwidth))
 
 #define peekchar(source) \
 	((source)->line[(source)->currloc.column])
 
 #define peeknextchar(source) \
 	((source)->line[(source)->currloc.column + 1])
 
 #define nextchar(source) \
 	((source)->line[++(source)->currloc.column])
 
 // @sub-section tokenize keyword / identifier {{{
 
 static int
 tokenizealphanumeric(Source *source, register int ch)
 {
 	int keyword;
 
 	while (isalnum(ch) || ch == '_')
 		ch = nextchar(source);
 
 	keyword = getkeyword(
 		source->line + source->tok.loc.column,
 		source->currloc.column - source->tok.loc.column
 	);
 
 	if (source->tok.kind != ANNOT && keyword >= 0 &&
 	    source->tok.kind != ODISP)
 	{
 		if (keyword == KOR - KSTART || keyword == KAND - KSTART) {
 			return source->tok.kind =
 				keyword == KOR - KSTART ? OLOR : OLAND;
 		} else if (keywordtypeids[keyword + KSTART]) {
 
 			source->tok.u.key =
 				keywordtypeids[keyword + KSTART];
 
 			source->tok.type = prim + source->tok.u.key;
 
 			return source->tok.kind = TYPE;
 		}
 
 		return source->tok.kind = keyword + KSTART;
 	}
 
 	source->tok.u.key = getstringkey(
 		&idents,
 		source->line + source->tok.loc.column,
 		source->currloc.column - source->tok.loc.column
 	);
 
 	return source->tok.kind = IDENT;
 }
 
 // }}}
 
 // @sub-section tokenize number {{{
 
 static Type *
 suffixfloattype(Source *source, const char *end)
 {
 	Type *ty = primitive(TDOUBLE);
 
 	if (*end == 0)
 		return ty;
 
 	/* FIXME(m21c): r-suffix might conflict with radix */
 	if ((*end == 'f' || *end == 'F') && !end[1]) {
 		ty = primitive(TFLOAT);
 
 	} else if (*end == 'l' || *end == 'L') {
 		ty = primitive(TDOUBLE);
 
 		if (end[1])
 			goto errorfloat;
 
 	} else if (!mystrcasecmp(end, "f32") || !mystrcasecmp(end, "r32")) {
 		ty = primitive(TF32);
 
 	} else if (!mystrcasecmp(end, "f64") || !mystrcasecmp(end, "r64")) {
 		ty = primitive(TF64);
 
 	} else {
 	errorfloat:
 		error(&source->currloc, "invalid floating-point format");
 	}
 
 	return ty;
 }
 
 static Type *
 suffixinttype(Source *source, const char *end)
 {
 	int typeid = TUINT - TINT;
 
 	switch (*end) {
 	case 0:
 		return primitive(TINFER);
 
 	case 's': case 'S': case 'i': case 'I':
 		typeid = 0;
 
 		/* fallthrough */
 	case 'u': case 'U':
 		++end;
 		if (*end == 0) {
 			return prim + (typeid + TINFER);
 
 		} else if (*end == '8') {
 			typeid += TS8;
 
 			if (end[1])
 				goto errorint;
 
 			return prim + typeid;
 
 		} else if (!strcmp(end, "16")) {
 			return prim + (typeid + TS16);
 
 		} else if (!strcmp(end, "32")) {
 			return prim + (typeid + TS32);
 
 		} else if (!strcmp(end, "64")) {
 			return prim + (typeid + TS64);
 
 		} else if (!mystrcasecmp(end, "sz")) {
 			return prim + (typeid + TSSIZE);
 		}
 
 		/* fallthrough */
 	default:
 		if (!mystrcasecmp(end, "ll")) {
 			return prim + (typeid + TLLONG);
 
 		} else if (*end == 'l' || *end == 'L') {
 			typeid += TLONG;
 
 			if (end[1])
 				goto errorint;
 
 			return prim + typeid;
 		}
 	}
 
 errorint:
 	error(&source->currloc, "invalid integer format");
 	return primitive(TINT);
 }
 
 static int
 tokenizenumber(Source *source, register int ch)
 {
 	int l = ch, t = peeknextchar(source), i, j;
 	bool hasdec = false, hasexp = false;
 	char *end;
 
 advancenum:
 	while (isalnum(ch) || ch == '_' ||
 	       (ch == '.' && peeknextchar(source) != '.' && !hasdec))
 	{
 		if (ch != '_')
 			l = ch;
 		if (ch == '.')
 			hasdec = true;
 
 		ch = nextchar(source);
 	}
 
 	if (hasdec && !hasexp && (ch == '+' || ch == '-')) {
 		t = tolower(t);
 		l = tolower(l);
 
 		if ((l == 'e' && t != 'x') || (l == 'p' && t == 'x')) {
 			ch = nextchar(source);
 			hasexp = true;
 
 			goto advancenum;
 		}
 	}
 
 	/* remove underscores */
 	for (j = 0, i = source->tok.loc.column;
 	     i < (int) source->currloc.column;
 	     ++i)
 	{
 		if (source->line[i] != '_') {
 			if (j >= lengthof(source->stringbuf) - 1) {
 				error(
 					&source->currloc,
 					"number-literal is too long"
 				);
 
 				source->tok.u.u = 0;
 				source->tok.type = primitive(TINT);
 
 				return source->tok.kind = NUMBER;
 			}
 
 			source->stringbuf[j++] = source->line[i];
 		}
 	}
 	source->stringbuf[j] = 0;
 
 	if (strpbrk(source->stringbuf, ".pPrR") ||
 	    (!strpbrk(source->stringbuf, "xX") &&
 	    strpbrk(source->stringbuf, "eEfF")))
 	{
 		source->tok.u.d = strtod(source->stringbuf, &end);
 		source->tok.type = suffixfloattype(source, end);
 
 	} else {
 		if (mystrncasecmp(source->stringbuf, "0b", 2) == 0) {
 			source->tok.u.u = strtoull(
 				source->stringbuf + 2,
 				&end, 2
 			);
 
 		} else {
 			source->tok.u.u = strtoull(
 				source->stringbuf,
 				&end, 0
 			);
 
 		}
 
 		source->tok.type = suffixinttype(source, end);
 	}
 
 	return source->tok.kind = NUMBER;
 }
 
 // }}}
 
 // @sub-section tokenize string {{{
 
 static int
 tokenizestring(Source *source, register int ch)
 {
 	int delim = ch, j;
 
 	ch = nextchar(source);
 	source->tok.loc.column = source->currloc.column;
 
 	j = source->currloc.column;
 	while (ch != delim && ch != 0) {
 		if (ch == '\\') {
 			ch = nextchar(source);
 
 			switch (ch) {
 			case '\\':
 				ch = '\\';
 				break;
 
 			case 'n':
 				ch = '\n';
 				break;
 
 			case 'r':
 				ch = '\r';
 				break;
 
 			case 't':
 				ch = '\t';
 				break;
 
 			case '\'':
 				ch = '\'';
 				break;
 
 			case '"':
 				ch = '"';
 				break;
 
 			/* @todo read more escape sequences */
 			case 0:
 				goto stringeol;
 
 			default:
 				error(&source->currloc,
 					"invalid escape sequence '\\%c'", ch);
 			}
 		}
 
 		source->line[j++] = ch;
 		ch = nextchar(source);
 	}
 
 	++source->currloc.column;
 	source->line[j++] = 0;
 
 	if (ch == 0) {
 	stringeol:
 		error(&source->currloc, "unexpected end-of-line");
 
 		return source->tok.kind = LINEDELIM;
 	}
 
 	if (ch == '"') {
 		source->tok.u.key = getstringkey(
 			&strings,
 			source->line + source->tok.loc.column,
 			j - source->tok.loc.column
 		);
 
 		return source->tok.kind = STRING;
 	}
 
 	/* @todo read numerical value of character properly
 	 *       (escape sequences, etc.) */
 	source->tok.type = prim + TUCHAR;
 	source->tok.u.u = source->line[source->tok.loc.column];
 	return source->tok.kind = CHAR;
 }
 
 // }}}
 
 // @sub-section tokenizer {{{
 
 static int
 gettok(Source *source)
 {
 	register int ch = (uchar) peekchar(source);
 	static bool hasnewline = false;
 
 	source->lastkind = source->tok.kind;
 
 	if (source->savedtok.kind) {
 		source->tok = source->savedtok;
 		source->savedtok.kind = 0;
 		return source->tok.kind;
 	}
 
 skipwhite:
 	if (hasnewline) {
 		if (!mygetline(source)) {
 			source->lastindent = 0;
 			return source->tok.kind = 0;
 		}
 
 		source->currloc.column = 0;
 		ch = peekchar(source);
 	}
 
 	if (source->currloc.column) {
 		/* just skip whitespace */
 		while (isspace(ch))
 			ch = nextchar(source);
 
 	} else {
 		/* skip whitespace and calculate indentation */
 		source->lastindent = 0;
 		while (isspace(ch)) {
 			if (ch == '\t') {
 				source->lastindent = nextindent(
 					source,
 					source->lastindent
 				);
 			} else {
 				++source->lastindent;
 			}
 
 			ch = nextchar(source);
 		}
 	}
 
 	source->tok.type = primitive(TUNDEFINED);
 	source->tok.u.u = 0;
 	source->tok.lhs = NULL;
 	source->tok.rhs = NULL;
 	source->tok.loc.column = source->currloc.column;
 
 	/* get line */
 	if (!ch || ch == '#') {
 		if (hasnewline) {
 			goto skipwhite;
 		} else {
 			/* defer reading new line to next call of gettok()
 			 * and return LINEDELIM */
 			hasnewline = true;
 			return source->tok.kind = LINEDELIM;
 		}
 	}
 
 	/* c-syle block comment with nesting allowed */
 	if (ch == '/' && peeknextchar(source) == '*') {
 		int nest = 1;
 
 		nextchar(source);
 		ch = nextchar(source);
 		
 		for (;nest; ch = nextchar(source)) {
 			if (!ch) {
 				if (!mygetline(source))
 					return source->tok.kind = 0;
 
 				source->currloc.column = 0; /* is this needed? */
 				ch = peekchar(source);
 			}
 
 			if (ch == '*' && peeknextchar(source) == '/') {
 				nextchar(source);
 				--nest;
 			} else if (ch == '/' && peeknextchar(source) == '*') {
 				nextchar(source);
 				++nest;
 			}
 		}
 
 		goto skipwhite;
 	}
 
 	hasnewline = false;
 
 	/* identifier or keyword */
 	if (isalpha(ch) || ch == '_')
 		return tokenizealphanumeric(source, ch);
 
 	/* number literal */
 	if (isdigit(ch) || (ch == '.' && isdigit(peeknextchar(source))))
 		return tokenizenumber(source, ch);
 
 	/* string & character-literal */
 	if (ch == '"' || ch == '\'')
 		return tokenizestring(source, ch);
 
 	/* operators */
 #define select(ch, then, otherwise) ( \
 		peekchar(source) == (ch) ? \
 		++source->currloc.column, (then) : \
 		(otherwise) \
 	)
 
 	++source->currloc.column;
 	switch (ch) {
 	case '.':
 		/* tok.kind = select('.', ORANGE, ODISP); */
 		ch = ODISP;
 		break;
 
 	case '*':
 		ch = select('=', OMULA, OMUL);
 		break;
 
 	case '/':
 		ch = select('=', ODIVA, ODIV);
 		break;
 
 	case '%':
 		ch = select('=', OMODA, OMOD);
 		break;
 
 	case '<':
 		ch = select('=', OLEQ,
 			select('<',
 				select('=', OLSHA, OLSH),
 			OLET));
 		break;
 
 	case '>':
 		ch = select('=', OGEQ,
 			select('>',
 				select('>',
 					select('=', OARSHA, OARSH),
 					select('=', ORSHA, ORSH)),
 				OGRT));
 		break;
 
 	case '&':
 		ch = select('=', OANDA, select('&', OLAND, OBAND));
 		break;
 
 	case '+':
 		ch = select('=', OADDA, select('+', OSUFINC, OADD));
 		break;
 
 	case '-':
 		ch = select('=', OSUBA, select('-', OSUFDEC, OSUB));
 		break;
 
 	case '|':
 		ch = select('=', OORA, select('|', OLOR, OBOR));
 		break;
 
 	case '^':
 		ch = select('=', OXORA, OXOR);
 		break;
 
 	case '!':
 		ch = select('=', ONEQ, OLNOT);
 		break;
 
 	case '~':
 		ch = select('=', OFLIP, OBNOT);
 		break;
 
 	case '=':
 		ch = select('=', select('=', OIDENT, OEQU), OASS);
 		break;
 
 	/* delimiters */
 	case ',': ch = COMMADELIM; break;
 	case ';': ch = SEMIDELIM;  break;
 	case '@': ch = ANNOT;      break;
 	case ':': ch = COLONDELIM; break;
 	case '{': ch = LCURLDELIM; break;
 	case '}': ch = RCURLDELIM; break;
 	case '[': ch = LSQRDELIM;  break;
 	case ']': ch = RSQRDELIM;  break;
 	case '(': ch = LPARDELIM;  break;
 	case ')': ch = RPARDELIM;  break;
 
 	default:
 		error(&source->currloc, "invalid input character '%c'", ch);
 		return INVALID;
 	}
 
 	return source->tok.kind = ch;
 #undef select
 }
 
 // }}}
 
 // @sub-section tokenizer utilities {{{
 
 static void
 pushbacktok(Source *source, Node *tok)
 {
 	assert(source->savedtok.kind == 0);
 
 	source->savedtok = source->tok;
 	source->tok = *tok;
 }
 
 #define skipnewline(source) \
 	((source)->tok.kind == LINEDELIM ? (void) gettok(source) : (void) 0)
 
 static bool
 isbasicdelimiter(Kind kind)
 {
 	switch ((int) kind) {
 	case 0:
 	case LINEDELIM: case COMMADELIM: case SEMIDELIM:
 	case COLONDELIM:
 	case RPARDELIM: case RSQRDELIM: case RCURLDELIM:
 	case KELSE:
 	case KUNTIL:
 		return true;
 	}
 
 	return false;
 }
 
 static Kind
 getunary(Kind kind)
 {
 	if (getprec(kind) == PUNARY)
 		return kind;
 
 	switch (kind) {
 	case OMUL: return ODEREF;
 	case OBAND: return OADDR;
 	case OADD: return OPLUS;
 	case OSUB: return OMINUS;
 	case OSUFINC: return OINC;
 	case OSUFDEC: return ODEC;
 	default:
 		return 0;
 	}
 }
 
 static bool
 isdelimiter(Kind kind)
 {
 	if (isbasicdelimiter(kind))
 		return true;
 
 	if (getunary(kind))
 		return false;
 
 	if (getnumops(kind))
 		return true;
 
 	return false;
 }
 
 static Kind
 getunarysuffix(Source *source)
 {
 	Kind kind = source->tok.kind;
 
 	if (getprec(kind) == PUNSUF)
 		return kind;
 
 	/* @note fixes parsing unary suffix across multiple lines.
 	 *              (which shouldn't happen) */
 	if (isbasicdelimiter(source->lastkind))
 		return 0;
 
 	switch (kind) {
 	case COLONDELIM: return ASELFDISP;
 	case LPARDELIM: return OCALL;
 	case LSQRDELIM: return OARRAY;
 	default:
 		return 0;
 	}
 }
 
 // }}}
 
 
 
 // }}}
 
 // @section ast-node {{{
 
 Node *poolednodes;
 Node nodebuf[4096];
 int nodetop, poolednodecount, totalnodecount;
 
 #define tokennode(source, lhs) makenode(&(source)->tok, (lhs))
 
 static Node *
 makenode(Node *orig, Node *lhs)
 {
 	Node *node;
 
 	if (poolednodes) {
 		node = poolednodes;
 		poolednodes = poolednodes->rhs;
 		node->rhs = NULL;
 		node->lhs = NULL;
 		--poolednodecount;
 	} else {
 		node = nodebuf + nodetop++;
 	}
 
 	++totalnodecount;
 	*node = *orig;
 	node->lhs = lhs;
 	node->rhs = NULL;
 
 	return node;
 }
 
 static void
 deleteenv(Env *env);
 
 static void
 deletenode(Node *node)
 {
 	if (node->kind == 0)
 		return;
 
 	if (node->kind == ASCOPE) {
 		Node *curr, *next;
 
 		if (node->u.env) {
 			assert(node->u.env->stmts == node);
 			node->u.env->stmts = NULL;
 			deleteenv(node->u.env);
 		}
 
 		for (curr = node->lhs; curr; curr = next) {
 			assert(curr->kind == ASTMT);
 			next = curr->rhs;
 			deletenode(curr);
 		}
 
 	} else if (node->kind == ASTMT) {
 		if (node->lhs)
 			deletenode(node->lhs);
 
 	} else {
 		if (node->rhs)
 			deletenode(node->rhs);
 
 		if (node->lhs)
 			deletenode(node->lhs);
 
 		if (node->u.payload && (node->kind == KIF ||
 		    node->kind == KWHILE || node->kind == ALOOPUNTIL))
 		{
 			deletenode(node->u.payload);
 		}
 	}
 
 	++poolednodecount;
 	node->kind = 0;
 	node->rhs = poolednodes;
 	poolednodes = node;
 }
 
 
 
 // }}}
 
 // @section type-struct {{{
 
 Type typebuf[4096];
 int typetop;
 
 static Type *
 maketype(SrcLoc *loc, Type *orig, Type *target)
 {
 	Type *ty = typebuf + typetop++;
 
 	*ty = *orig;
 	ty->loc = *loc;
 	ty->target = target;
 
 	return ty;
 }
 
 
 
 // }}}
 
 // @section annotation {{{
 
 Annot annotbuf[4096];
 int annottop;
 
 Docket docketbuf[4096];
 int dockettop;
 
 static Annot *
 makeannot(SrcLoc *loc, int key)
 {
 	Annot *annot;
 
 	assert(annottop < lengthof(annotbuf));
 
 	annot = annotbuf + annottop;
 
 	annot->key = key;
 	annot->loc = *loc;
 
 	/* @todo implement initialization. */
 
 	return annot;
 }
 
 static Docket *
 makedocket(Node *node)
 {
 	Docket *docket;
 
 	(void) node; /* @todo implement. */
 
 	assert(dockettop < lengthof(docketbuf));
 
 	docket = docketbuf + dockettop;
 
 	/* @todo implement initialization. */
 
 	return docket;
 }
 
 
 
 // }}}
 
 // @section environment {{{
 
 Env envbuf[4096];
 int envtop;
 
 static Decl *
 finddeclinenv(int key, Env *env)
 {
 	const int cacheindex = (key >> 3) & 0x3f;
 	const int cachebit = 1 << (key & 0x03);
 
 	Decl *decl;
 
 	if ((env->keycache[cacheindex] & cachebit) == 0)
 		return NULL;
 
 	for (decl = env->head; decl; decl = decl->next) {
 		if (decl->key == key)
 			return decl;
 	}
 
 	return NULL;
 }
 
 static Decl *
 finddeclaration(Source *source, Env *startenv, int key)
 {
 	const int cacheindex = (key >> 3) & 0x3f;
 	const int cachebit = 1 << (key & 0x03);
 
 	Env *env;
 	Decl *decl;
 
 	for (env = startenv; env; env = env->below) {
 		/* @note look-up exclusion list first.
 		 *              If found: only lookup in found env */
 		/* FIXME(m21c): make a separate list, and not use excludehead,
 		 *               excludenext ! */
 		/*
 		for (decl = env->excludehead; decl; decl = decl->excludenext) {
 			if (decl->key == key)
 				return finddeclinenv(key, env);
 		}
 		*/
 
 
 		if ((env->keycache[cacheindex] & cachebit) == 0)
 			continue;
 
 		for (decl = env->head; decl; decl = decl->next) {
 			if (decl->key == key)
 				return decl;
 		}
 	}
 
 	if (!source)
 		return NULL;
 
 	env = source->implicitenv;
 
 	if ((env->keycache[cacheindex] & cachebit) == 0)
 		return NULL;
 
 	for (decl = env->head; decl; decl = decl->next) {
 		if (decl->key == key)
 			return decl;
 	}
 
 	return NULL;
 }
 
 #if 0
 static Env *
 setheadenv(Source *source, EnvKind kind)
 {
 	/* @note this might only be useful for parameter => function env
 	 *              translation */
 	Env *env = envbuf + envtop++;
 
 	env->kind = kind;
 
 	/* @todo make sure that source->tok.loc is the correct
 	 *              source-location. */
 	/* @todo maybe use getloc(source) instead of
 	 *              &source->tok.loc and move the declaration of
 	 *              getloc() up in the source-code. */
 	env->loc = source->tok.loc;
 	env->below = source->currenv;
 
 	assert(source->headenv == NULL);
 	source->currenv = source->headenv = env;
 
 	return env;
 }
 #endif
 
 static Env *
 pushenv(Source *source, EnvKind kind)
 {
 	Env *env;
 
 	if (source->headenv) {
 		source->headenv->kind = kind;
 
 		assert(source->headenv == source->currenv);
 		source->headenv = NULL;
 
 		return source->currenv;
 	}
 
 	env = envbuf + envtop++;
 	env->kind = kind;
 	/* @todo make sure that source->tok.loc is the correct
 	 *              source-location. */
 	/* @todo maybe use getloc(source) instead of
 	 *              &source->tok.loc and move the declaration of
 	 *              getloc() up in the source-code. */
 	env->loc = source->tok.loc;
 	env->below = source->currenv;
 
 	source->currenv = env;
 
 	return env;
 }
 
 static Env *
 popenv(Source *source)
 {
 	Env *currenv = source->currenv;
 	Env *env = currenv;
 
 	if (currenv)
 		source->currenv = currenv->below;
 
 	return env;
 }
 
 static Env *
 getfuncenv(Env *currenv)
 {
 	Env *env;
 
 	for (env = currenv; env; env = env->below) {
 		if (env->kind == SFUNCTION) {
 			return env;
 		}
 	}
 
 	return NULL;
 }
 
 static bool
 deferfuncenv(Source *source, int keydeclinfunc)
 {
 	Env *funcenv = getfuncenv(source->currenv);
 
 	if (funcenv) {
 		if (!funcenv->pending) {
 			funcenv->pending = true;
 			/* @todo handle nested functions properly */
 			source->haspendingenv = true;
 
 			listappendex(source, funcenv,
 				pendingenvhead, pendingenvtail,
 				pendingprev, pendingnext);
 		}
 	} else {
 		/* @todo maybe use getloc(source) instead of
 		 *              &source->tok.loc and move the declaration of
 		 *              getloc() up in the source-code. */
 		error(
 			&source->tok.loc,
 			"'%s' undeclared",
 			getstring(idents, keydeclinfunc)
 		);
 
 		return false;
 	}
 
 	return true;
 }
 
 
 static Node *
 wrapenv(Node *node, Env *env)
 {
 	Node *aenv = makenode(node, node);
 
 	aenv->kind = AENV;
 	aenv->u.env = env;
 
 	return aenv;
 }
 
 static void
 deleteenv(Env *env)
 {
 	if (env->stmts)
 		deletenode(env->stmts);
 
 	/* @todo delete env */
 }
 
 
 
 // }}}
 
 // @section declaration {{{
 
 Decl declbuf[4096];
 int decltop;
 
 static void
 appenddecltoenv(Decl *decl, Env *targetenv)
 {
 	const int key = decl->key;
 	const int cacheindex = (key >> 3) & 0x3f;
 	const int cachebit = 1 << (key & 0x03);
 
 	targetenv->keycache[cacheindex] |= cachebit;
 
 	decl->parentenv = targetenv;
 
 	listappend(targetenv, decl);
 }
 
 static void
 removedeclfromenv(Decl *decl)
 {
 	Env *sourceenv = decl->parentenv;
 
 	if (decl->prev)
 		decl->prev->next = decl->next;
 	else
 		sourceenv->head = decl->next;
 
 	if (decl->next)
 		decl->next->prev = decl->prev;
 	else
 		sourceenv->tail = decl->prev;
 
 	decl->parentenv = NULL;
 	decl->next = decl->prev = NULL;
 }
 
 static Decl *
 makedecl(Source *source, int key, DeclKind kind)
 {
 	Env *currenv = source->currenv;
 	Decl *decl;
 
 	assert(currenv);
 
 	/* @todo maybe remove check if already declared,
 	 *              since many functions that call makedecl
 	 *              already try to obtain a declaration for
 	 *              other reasons. So the check if it is
 	 *              already declared can be done by those
 	 *              functions */
 
 	decl = finddeclinenv(key, currenv);
 
 	if (decl) {
 		if (decl->parentenv == source->implicitenv) {
 			removedeclfromenv(decl);
 			appenddecltoenv(decl, currenv);
 
 			return decl;
 		}
 
 		/* @todo make sure that source->tok.loc is the correct
 		*              source-location. */
 		/* @todo maybe use getloc(source) instead of
 		 *              &source->tok.loc and move the declaration of
 		 *              getloc() up in the source-code. */
 		error(
 			&source->tok.loc,
 			"'%s' already declared",
 			getstring(idents, key)
 		);
 	}
 
 	decl = declbuf + decltop++;
 
 	decl->kind = kind;
 	/* @todo make sure that source->tok.loc is the correct
 	 *              source-location. */
 	/* @todo maybe use getloc(source) instead of
 	 *              &source->tok.loc and move the declaration of
 	 *              getloc() up in the source-code. */
 	decl->loc = source->tok.loc;
 	decl->key = key;
 	decl->type = primitive(TVOID);
 	decl->contentenv = NULL;
 	decl->module = NULL;
 
 	appenddecltoenv(decl, currenv);
 
 	return decl;
 }
 
 static Decl *
 makebundle(Source *source, int key, Decl *parentbundle)
 {
 	/* Env *currenv = source->currenv; */
 	Decl *decl;
 
 	/* assert(currenv); */
 
 	decl = declbuf + decltop++;
 
 	decl->kind = DBUNDLE;
 	/* @todo make sure that source->tok.loc is the correct
 	 *              source-location. */
 	/* @todo maybe use getloc(source) instead of
 	 *              &source->tok.loc and move the declaration of
 	 *              getloc() up in the source-code. */
 	decl->loc = source->tok.loc;
 	decl->key = key;
 	decl->type = primitive(TVOID);
 	decl->contentenv = NULL;
 	decl->module = parentbundle;
 
 	return decl;
 }
 
 static Decl *
 makedecl2(SrcLoc *loc, Env *env, int key, DeclKind kind)
 {
 	Decl *decl;
 
 	assert(env);
 
 	/* @todo maybe remove check if already declared,
 	 *              since many functions that call makedecl
 	 *              already try to obtain a declaration for
 	 *              other reasons. So the check if it is
 	 *              already declared can be done by those
 	 *              functions */
 
 	decl = finddeclinenv(key, env);
 	if (decl) {
 		/* @todo maybe check also for implicit declarations */
 		error(loc, "'%s' already declared", getstring(idents, key));
 	}
 
 	decl = declbuf + decltop++;
 
 	decl->kind = kind;
 	/* @todo make sure that source->tok.loc is the correct
 	 *              source-location. */
 	/* @todo maybe use getloc(source) instead of
 	 *              &source->tok.loc and move the declaration of
 	 *              getloc() up in the source-code. */
 	decl->loc = *loc;
 	decl->key = key;
 	decl->type = primitive(TVOID);
 	decl->contentenv = NULL;
 
 	appenddecltoenv(decl, env);
 
 	return decl;
 }
 
 static Decl *
 defertypedeclaration(Source *source, int key)
 {
 	Env *savedcurrenv = source->currenv;
 	Decl *decl;
 
 	source->currenv = source->implicitenv;
 	decl = makedecl(source, key, DTYPE);
 
 	/* FIXME(m21c): type may be overwritten, when the declaration
 	 *               is completed */
 	decl->type = maketype(&source->tok.loc, primitive(TVOID), NULL);
 	decl->type->module = decl;
 	source->currenv = savedcurrenv;
 
 	return decl;
 }
 
 
 
 // }}}
 
 // @section record {{{
 
 Record recordbuf[4096];
 int recordtop;
 
 static Record *
 makerecord(Decl *recorddecl)
 {
 	Record *record;
 	
 	assert(recordtop < lengthof(recordbuf));
 	record = recordbuf + recordtop++;
 	record->head = record->tail = NULL;
 
 	recorddecl->record = record;
 
 	assert(recorddecl->type);
 	record->isunion = recorddecl->type->kind == TUNION;
 
 	return record;
 }
 
 Field fieldbuf[4096 * 16];
 int fieldtop;
 
 static Field *
 makefield(Record *record, Decl *decl)
 {
 	Field *field;
 	
 	assert(fieldtop < lengthof(fieldbuf));
 	field = fieldbuf + fieldtop++;
 	field->decl = decl;
 	field->offset = field->size = 0;
 	field->use = false;
 	field->prev = field->next = NULL;
 
 	assert(record);
 	listappend(record, field);
 
 	return field;
 }
 
 
 
 // }}}
 
 // @section parser {{{
 
 #define getkind(source) \
 	((source)->tok.kind)
 
 #define getloc(source) \
 	(&(source)->tok.loc)
 
 static bool
 expect(Source *source, int kind, const char *fmt, ...)
 {
 	va_list ap;
 
 	int line = source->tok.loc.line;
 	int column = source->tok.loc.column;
 	const char *filename = source->tok.loc.filename;
 
 	if (getkind(source) != (Kind) kind) {
 		va_start(ap, fmt);
 		fprintf(stderr, "%s:%i:%i: error: ",
 			filename, line, column + 1);
 		vfprintf(stderr, fmt, ap);
 		fprintf(stderr, "\n");
 		va_end(ap);
 
 		return false;
 	}
 
 	gettok(source);
 	return true;
 }
 
 // @sub-section read annotations {{{
 
 static AnnotParam *
 readannotparam(Source *source)
 {
 	bool hasident = false;
 
 	while (getkind(source)) {
 		int count = 1;
 
 		switch (getkind(source)) {
 		case IDENT:
 			if (!hasident) {
 				int key = source->tok.u.key;
 				const char *ident = getstring(idents, key);
 				printf("Annotation Parameter: %s\n", ident);
 
 				hasident = true;
 			}
 
 			gettok(source);
 			break;
 
 		case COMMADELIM: case RPARDELIM:
 			goto finish;
 
 		case LPARDELIM:
 			gettok(source);
 			while (getkind(source) && count > 0) {
 				switch (getkind(source)) {
 				case LPARDELIM:
 					++count;
 					break;
 				case RPARDELIM:
 					--count;
 					break;
 				default:
 					break;
 				}
 				gettok(source);
 			}
 
 			if(!getkind(source))
 				goto finish;
 
 			/* FALLTHROUGH */
 		default:
 			gettok(source);
 		}
 	}
 
 finish:
 	return NULL;
 }
 
 static void
 readannots(Source *source)
 {
 	Docket *docket = NULL;
 
 	while (getkind(source) == ANNOT) {
 		SrcLoc loc = source->tok.loc;
 		int key = 0;
 
 		Annot *annot = NULL;
 
 		gettok(source);
 
 		key = source->tok.u.key;
 		if (!expect(source, IDENT, "expected annotation-identifier."))
 			return;
 
 		annot = makeannot(&loc, key);
 
 		if (getkind(source) == LPARDELIM) {
 			int count;
 
 			gettok(source);
 			for (count = 0; getkind(source); ++count) {
 				AnnotParam *param = readannotparam(source);
 
 				if (param)
 					listappend(annot, param);
 
 				if (getkind(source) == COMMADELIM) {
 					gettok(source);
 					continue;
 				}
 
 				if (getkind(source) != RPARDELIM) {
 					error(getloc(source),
 						"expected ',' or ')'.");
 				} else {
 					gettok(source);
 				}
 
 				break;
 			}
 		}
 
 		if (docket == NULL) {
 			docket = makedocket(NULL);
 			/* @todo add docket to source */
 		}
 
 		listappend(docket, annot);
 
 		skipnewline(source);
 
 		printf("Annotation: '%s'\n", getstring(idents, key));
 	}
 }
 
 // }}}
 
 // @sub-section read statement list {{{
 
 static bool
 checkend(Source *source, bool hastail, int needindent,
 		const char *expecterrmsg)
 {
 	Node savedtok = {0};
 
 	if (getkind(source) == LINEDELIM) {
 		savedtok = source->tok;
 
 		gettok(source);
 
 		if (getkind(source) == SEMIDELIM) {
 			error(getloc(source), expecterrmsg);
 			gettok(source);
 
 			pushbacktok(source, &savedtok);
 			return true;
 		}
 	}
 
 	if (source->lastkind == LINEDELIM && source->lastindent < needindent) {
 		/* @note Is that correct? Maybe we should always pushback
 		 *              a made-up new-line, instead of asserting that we
 		 *              have saved one. Since it might be the case, that
 		 *              we already have read a new-line prior the call
 		 *              to this function. But I'll leave it this way,
 		 *              for now. */
 		/* assert(savedtok.kind == LINEDELIM); */
 
 		if (savedtok.kind == LINEDELIM)
 			pushbacktok(source, &savedtok);
 		return true;
 	}
 
 	if (getkind(source) == SEMIDELIM) {
 		savedtok = source->tok;
 		gettok(source);
 
 		/* @note used for REPL. it allows having
 		 *              semicolons on line-endings and nultiple
 		 *              adjacent semecolons in REPL-mode. */
 		if ((getkind(source) == SEMIDELIM ||
 		     getkind(source) == LINEDELIM) &&
 		    source->filein != stdin)
 			/* @note output an error-message if not in REPL-mode */
 			error(&savedtok.loc, "trailing semicolon.");
 	}
 
 	if (isdelimiter(source->tok.kind))
 		return true;
 
 	if (hastail &&
 	    source->lastkind != LINEDELIM &&
 	    source->lastkind != SEMIDELIM)
 		error(getloc(source), "expected line delimiter");
 
 	return false;
 }
 
 static Node *
 exprlist(Source *source, bool isparam, Type *paramtype);
 
 static Node *
 stmtlist(Source *source, int indent, EnvKind envkind,
 		Decl *envdecl, bool reuseenv)
 {
 	Node *head = NULL, *tail = NULL;
 	int needindent = nextindent(source, indent);
 
 	Env *env = NULL;
 
 	if (reuseenv) {
 		source->currenv->kind = envkind;
 	} else {
 		env = pushenv(source, envkind);
 		env->envdecl = envdecl;
 	}
 
 	for (;;) {
 		Node *stmt;
 
 		if (checkend(source, !!tail, needindent, "expected expression"))
 			break;
 
 		if (getkind(source) == LINEDELIM)
 			gettok(source);
 
 		readannots(source);
 		stmt = exprlist(source, false, NULL);
 		stmt = tokennode(source, stmt);
 		stmt->kind = ASTMT;
 
 		if (!tail) {
 			head = tail = stmt;
 		} else {
 			tail->rhs = stmt;
 			tail = stmt;
 		}
 	}
 
 	if (reuseenv) {
 		assert(env == NULL);
 		env = source->currenv;
 	}
 
 	if (head) {
 		head = tokennode(source, head);
 		head->kind = ASCOPE;
 		head->u.env = env;
 		env->stmts = head;
 
 		popenv(source);
 	} else {
 		popenv(source);
 		/* if (!reuseenv) deleteenv(env); */
 	}
 
 	return head;
 }
 
 // }}}
 
 // @sub-section read declaration {{{
 
 static int
 qualifiers(Source *source, int allowmask)
 {
 	int flags = 0, mask = allowmask;
 
 	while (iskeyword(getkind(source))) {
 		int f, m;
 
 		switch (getkind(source)) {
 		case KEXTERN:
 			f = QEXTERN, m = ~QVISIB;
 			break;
 
 		case KINTERN:
 			f = QINTERN, m = ~QVISIB;
 			break;
 
 		case KSTATIC:
 			f = QSTATIC, m = ~QSTORAGE;
 			break;
 
 		case KCONST:
 			f = QCONST, m = 0;
 			break;
 
 		/* @todo remove this */
 		case KVAR:
 			f = QVAR, m = ~(QTYPE | QINFER);
 			break;
 
 		default:
 			goto finish;
 		}
 
 		if (f & ~allowmask) {
 			const char *str = nodestrings[getkind(source)];
 
 			error(getloc(source), "invalid qualifier '%s'", str);
 		} else if (f & flags & QTYPE) {
 			const char *str = nodestrings[getkind(source)];
 
 			warn(getloc(source), "redundant qualifier '%s'", str);
 		} else if (f & ~mask) {
 			const char *str = nodestrings[getkind(source)];
 
 			error(getloc(source), "redundant qualifier '%s'", str);
 		}
 
 		flags |= f & allowmask & mask;
 		mask &= m;
 		gettok(source);
 	}
 
 finish:
 	return flags;
 }
 
 static Node *
 readexpr(Source *source, int minprec);
 
 static Type *
 gettype(Source *source, Type *basetype)
 {
 	int flags;
 
 	if (!basetype)
 		return NULL;
 
 advance:
 	flags = qualifiers(source, QTYPE);
 	(void) flags;
 
 	if (getkind(source) == LSQRDELIM) {
 		Type *tmp = maketype(getloc(source), primitive(TARRAY), basetype);
 		basetype = tmp;
 
 		gettok(source);
 		if (source->tok.kind != RSQRDELIM)
 			basetype->u.val = readexpr(source, PASSIGN);
 
 		expect(source, RSQRDELIM, "expect ']'");
 		goto advance;
 	}
 
 	if (getkind(source) == OMUL) {
 		Type *tmp = maketype(getloc(source), primitive(TPTR), basetype);
 		basetype = tmp;
 
 		gettok(source);
 		goto advance;
 	}
 
 	return basetype;
 }
 
 static Node *
 typecheck(Env *env, Node *expr);
 
 static Node *
 declaration(Source *source, Type *ty, bool tryreadtype)
 {
 	bool selfparam = false;
 	Type *module = NULL;
 	Decl *decl = NULL;
 	Node *result = NULL;
 
 	/*
 	EnvKind context;
 	*/
 
 	if (tryreadtype) {
 		decl = finddeclaration(source, source->currenv, source->tok.u.key);
 
 		if (decl && decl->kind == DTYPE) {
 			gettok(source);
 			ty = gettype(source, decl->type);
 			tryreadtype = false;
 		}
 	}
 
 	if (!ty)
 		return NULL;
 
 	/* @todo use the currenv->kind as context, whether or how
 	 *              certain declarations (like function-declarations)
 	 *              are processed */
 
 	/*
 	context = source->currenv->kind;
 	*/
 
 redodeclaration:
 	skipnewline(source);
 
 	/* variable name */
 	if (getkind(source) == IDENT) {
 		int key = source->tok.u.key;
 		SrcLoc loc = source->tok.loc;
 		EnvKind envkind = source->currenv->kind;
 
 		gettok(source);
 
 		if (tryreadtype && (envkind == SSTRUCT || envkind == SUNION)) {
 
 			if (!isbasicdelimiter(getkind(source)) &&
 			    getkind(source) != LPARDELIM)
 			{
 				decl = defertypedeclaration(source, key);
 				decl->loc = loc;
 				ty = gettype(source, decl->type);
 				tryreadtype = false;
 				goto redodeclaration;
 			}
 		}
 
 		decl = finddeclaration(source, source->currenv, key);
 
 		if (decl && decl->kind != DFUNCTION && decl->kind != DPARAM &&
 		    decl->kind != DVAR)
 		{
 			module = decl->type;
 			decl = NULL;
 			goto readvarmodule;
 		}
 
 		if ((getkind(source) == ODISP || getkind(source) == COLONDELIM) &&
 		    getkind(source) != LPARDELIM && getkind(source) != OASS)
 		{
 			error(&loc, "expected type or module");
 		}
 
 		decl = makedecl(source, key, DVAR);
 		decl->loc = loc;
 		decl->type = ty;
 
 	/* module for variable */
 	} else if (getkind(source) == TYPE) {
 		module = source->tok.type;
 		gettok(source);
 
 	readvarmodule:
 		module = gettype(source, module);
 
 		if (getkind(source) == ODISP || getkind(source) == COLONDELIM) {
 			selfparam = getkind(source) == COLONDELIM;
 			(void) selfparam;
 			gettok(source);
 		} else {
 			error(getloc(source), "expected '.' or ':'");
 		}
 
 		/* @todo obtain Decl* for
 		 *              Type Module:my_decl
 		 *              or Type Module.my_decl - declarations */
 
 		/* variable name */
 		if (getkind(source) == IDENT) {
 			Env *moduleenv = NULL;
 			assert(module->module);
 			assert(module->module->contentenv);
 			moduleenv = module->module->contentenv;
 
 			decl = makedecl2(&source->tok.loc, 
 				moduleenv, source->tok.u.key, DVAR);
 			decl->type = ty;
 			decl->module = module->module;
 			gettok(source);
 		} else {
 			error(getloc(source), "expected identifier");
 		}
 	/* just return a node for the type */
 	} else {
 		result = tokennode(source, NULL);
 		result->kind = TYPE;
 		result->type = ty;
 
 		return result;
 	}
 
 	if (!decl->module)
 		decl->module = source->currenv->bundle;
 
 	/* function declaration */
 	if (getkind(source) == LPARDELIM) {
 		Type *paramtype = NULL;
 		Env *functionenv = NULL;
 		Node *body = NULL;
 
 		/* function params */
 		gettok(source);
 		if (getkind(source) != RPARDELIM) {
 			Decl *param;
 			Node *paramlist;
 			Type *paramtype = NULL;
 
 			functionenv = pushenv(source, SPARAMLIST);
 			functionenv->envdecl = decl;
 
 			if (selfparam) {
 				param = makedecl(source, auxself, DVAR);
 				param->type = maketype(&param->loc,
 					prim + TPTR, module);
 				param->flags |= MSPECIAL;
 				/* @note param doesn't need to be added to
 				 *       paramlist. since paramlist will be 
 				 *       deleted anyway and param is already
 				 *       present in env. */
 				paramtype = param->type;
 			}
 
 			paramlist = exprlist(source, true, paramtype);
 			paramlist = typecheck(functionenv, paramlist);
 			paramtype = paramlist->type;
 			deletenode(paramlist);
 
 			for (param = functionenv->head; param;
 			     param = param->next)
 			{
 				assert(param->kind == DVAR);
 				param->kind = DPARAM;
 			}
 		} else if (selfparam) {
 			Type *selftype = maketype(&decl->loc,
 				primitive(TPTR), module);
 			Decl *selfdecl;
 			
 			functionenv = pushenv(source, SPARAMLIST);
 			functionenv->envdecl = decl;
 
 			selfdecl = makedecl(source, auxself, DPARAM);
 			selfdecl->type = selftype;
 			selfdecl->flags |= MSPECIAL;
 		}
 		expect(source, RPARDELIM, "expected ')'");
 
 		if (module && ty->kind == TINFER) {
 			ty = module;
 		} else if (ty->kind == TINFER) {
 			error(&decl->loc,
 				"cannot infer return type of function");
 		}
 
 		decl->type = maketype(&decl->loc, primitive(TFUNCTION), paramtype);
 		decl->kind = DFUNCTION;
 		decl->type->u.rtarget = ty;
 		ty = decl->type;
 
 		/* function body */
 		if (getkind(source) != OASS) {
 			body = stmtlist(source, source->lastindent,
 				SFUNCTION, decl, !!functionenv);
 
 			assert(body && body->kind == ASCOPE);
 			functionenv = body->u.env;
 
 		/* function init (body defined by assigment) */
 		} else if (getkind(source) == OASS) {
 			gettok(source);
 
 			functionenv->kind = SFUNCTION;
 			body = readexpr(source, PASSIGN);
 
 			popenv(source);
 
 		/* no function body */
 		} else {
 			popenv(source);
 		}
 
 		assert(decl->contentenv == NULL);
 		decl->contentenv = functionenv;
 
 		assert(decl->u.content == NULL);
 		decl->u.content = body;
 
 
 		/* @todo maybe add function-declaration to its type and
 		 *              add the paramlist to the type-info */
 
 		/* @todo store the params-node (its initializations)
 		 *              somewhere */
 
 		goto finish;
 	}
 
 	/* variable init */
 	if (getkind(source) == OASS) {
 		gettok(source);
 		assert(decl);
 		decl->u.content = readexpr(source, PASSIGN);
 
 	/* no init */
 	} else {
 		assert(decl);
 		decl->u.content = NULL;
 
 		if (ty->kind == TINFER) {
 			error(&decl->loc,
 				"cannot infer type, expected initialization");
 		}
 	}
 
 finish:
 	result = tokennode(source, decl->u.content);
 	result->type = ty;
 	result->u.declref = decl;
 	result->loc = decl->loc;
 	result->kind = ADECL;
 
 	return result;
 }
 
 // }}}
 
 // @sub-section read atom {{{
 
 static Node *
 readident(Source *source, int flags)
 {
 	Node *lhs = NULL;
 	Decl *decl = NULL;
 	SrcLoc loc = source->tok.loc;
 	int key = source->tok.u.key;
 
 	EnvKind envkind = source->currenv
 		? source->currenv->kind
 		: STOPLEVEL;
 
 	decl = finddeclaration(source, source->currenv, source->tok.u.key);
 	gettok(source);
 
 	if (!decl && (envkind == SSTRUCT || envkind == SUNION)) {
 		if (!isbasicdelimiter(getkind(source))) {
 			decl = defertypedeclaration(source, key);
 			decl->loc = loc;
 		}
 	}
 
 	if (decl && decl->kind == DTYPE) {
 		lhs = declaration(source, gettype(source, decl->type), false);
 		return lhs;
 	}
 
 	lhs = tokennode(source, NULL);
 	lhs->loc = loc;
 
 	if (decl) {
 		lhs->kind = ADECLREF;
 		lhs->type = decl->type;
 		lhs->u.declref = decl;
 	} else {
 		if (deferfuncenv(source, key)) {
 			lhs->kind = IDENT;
 			lhs->u.key = key;
 		} else {
 			lhs->kind = NUMBER;
 			lhs->u.u = 0;
 		}
 
 		lhs->type = primitive(TVOID);
 	}
 
 	if (flags & QCONST) {
 		/* @todo const - conversion */
 	}
 
 	return lhs;
 }
 
 static void
 extractfields(Record *record, Node *recordscope)
 {
 	Node *stmt;
 
 	for (stmt = recordscope->lhs; stmt; stmt = stmt->rhs) {
 		Node *expr;
 
 		assert(stmt->kind == ASTMT);
 
 		expr = stmt->lhs;
 
 		/* @fixme expr might be validly NULL */
 		assert(expr);
 
 		if (expr->kind == ACOMMA) {
 			for (; expr; expr = expr->lhs) {
 				Node *nested;
 
 				if (expr->kind == ADECL)
 					makefield(record, expr->u.declref);
 
 				if (expr->kind != ACOMMA)
 					break;
 
 				nested = expr->rhs;
 
 				if (nested->kind != ADECL)
 					continue;
 
 				makefield(record, nested->u.declref);
 			}
 			continue;
 		}
 		if (expr->kind != ADECL)
 			continue;
 
 		makefield(record, expr->u.declref);
 	}
 }
 
 static void
 calculatefields(Record *record, Type *recordtype)
 {
 	const bool isunion = record->isunion;
 	Field *field;
 
 	/* @todo calculate size/align for unions */
 	for (field = record->head; field; field = field->next) {
 		size_t mod = 0, padding;
 		Type *type;
 
 		type = field->decl->type;
 
 		if (recordtype->align < type->align)
 			recordtype->align = type->align;
 
 		if (isunion) {
 			if (recordtype->size < type->size)
 				recordtype->size = type->size;
 			continue;
 		}
 
 		if (recordtype->align)
 			mod = recordtype->size % recordtype->align;
 
 		padding = mod ? recordtype->align - mod : 0;
 		field->offset = padding + recordtype->size;
 		recordtype->size += padding + type->size;
 	}
 }
 
 static Node *
 readrecord(Source *source, bool isunion)
 {
 	Node *recordnode;
 	Decl *module;
 	Record *record;
 	int indent = source->lastindent;
 
 	EnvKind envkind = SSTRUCT;
 	TypeKind typekind = TSTRUCT;
 
 	if (isunion) {
 		envkind = SUNION;
 		typekind = TUNION;
 	}
 
 	recordnode = tokennode(source, NULL);
 	recordnode->kind = getkind(source);
 	gettok(source);
 
 	/* read record tag-name */
 	if (getkind(source) == IDENT) {
 		recordnode->lhs = tokennode(source, NULL);
 		gettok(source);
 	} else {
 		error(getloc(source), "expected identifier");
 	}
 
 	module = makedecl(source, recordnode->lhs->u.key, DTYPE);
 
 	if (module->type->module == module) {
 		*module->type = prim[TSTRUCT];
 	} else {
 		module->type = maketype(&recordnode->loc, prim + typekind, NULL);
 	}
 
 	module->type->module = module;
 	recordnode->type = module->type;
 
 	if (!module->module) /* @note currently module->module == NULL always */
 		module->module = source->currenv->bundle;
 
 	/* read record body */
 
 	/* @note maybe we will use stmtlist() for parsing the record body,
 	                since we have to parse statements or expressions beside
 	                field declarations */
 
 	/* @todo check for new-line and only then read body */
 	recordnode->rhs = stmtlist(source, indent, envkind, module, false);
 	if (recordnode->rhs) {
 		module->contentenv = recordnode->rhs->u.env;
 	}
 
 	record = makerecord(module);
 
 	/* @todo validate record body, extract declarations,
 	 *              compute size and align, resolve aliases */
 
 	if (recordnode->rhs) {
 		assert(recordnode->rhs->kind == ASCOPE);
 		extractfields(record, recordnode->rhs);
 	}
 
 	calculatefields(record, recordnode->type);
 	return recordnode;
 }
 
 static bool
 skipnewlineontok(Source *source, Kind kind, int neededindent)
 {
 	Node savedtok;
 
 	if (getkind(source) == kind)
 		return source->lastindent >= neededindent;
 
 	if (getkind(source) == LINEDELIM) {
 		savedtok = source->tok;
 
 		if (gettok(source) == (int) kind &&
 		    source->lastindent >= neededindent)
 			return true;
 
 		pushbacktok(source, &savedtok);
 	}
 
 	return false;
 }
 
 static Node *
 readrecordinitfield(Source *source, Type *recordtype)
 {
 	Node *fieldinit = NULL;
 	Node savedtok = {0};
 
 	/* @todo add init-env */
 
 	skipnewline(source);
 
 	fieldinit = tokennode(source, NULL);
 	fieldinit->kind = AFIELDINIT;
 	if (getkind(source) == IDENT) {
 		savedtok = source->tok;
 		gettok(source);
 		if (getkind(source) == COLONDELIM) {
 			gettok(source);
 			/* @todo associate field name with field in record type */
 			fieldinit->lhs = makenode(&savedtok, NULL);
 		} else {
 			pushbacktok(source, &savedtok);
 		}
 	}
 
 	fieldinit->rhs = readexpr(source, PASSIGN);
 	return fieldinit;
 }
 
 static Node *
 readrecordinitfieldlist(Source *source, Type *recordtype)
 {
 	/* @todo add init-env */
 	/* @todo check for missing field-initializers */
 	Node *init = readrecordinitfield(source, recordtype);
 
 	while (skipnewline(source), getkind(source) == COMMADELIM) {
 		init = tokennode(source, init);
 		init->kind = ACOMMA;
 		gettok(source);
 		init->rhs = readrecordinitfield(source, recordtype);
 	}
 
 	return init;
 }
 
 static Node *
 finishcontrolflow(Source *source, Node *lhs, int indent)
 {
 	if (skipnewlineontok(source, KELSE, indent)) {
 		gettok(source);
 		lhs->rhs = stmtlist(source, indent, SELSE, NULL, false);
 	}
 
 	return wrapenv(lhs, popenv(source));
 }
 
 static Node *
 readatom(Source *source, int flags)
 {
 	Node *lhs = NULL, *savedis = source->lastis;
 	int indent;
 
 	/* unary 'is'-operator */
 	if (getkind(source) == KIS) {
 		if (!source->lastis) {
 			error(
 				getloc(source),
 				"there is no left-hand-side for 'is'"
 			);
 
 			lhs = tokennode(source, NULL);
 		} else {
 			lhs = tokennode(source, source->lastis->lhs);
 		}
 
 		gettok(source);
 
 		if (getkind(source) == KNOT)
 			gettok(source), lhs->kind = ONEQ;
 		else
 			lhs->kind = OEQU;
 
 		lhs->rhs = readexpr(source, PRELAT);
 		return lhs;
 	}
 
 	/* unary prefix operators */
 	if (getunary(source->tok.kind)) {
 		lhs = tokennode(source, NULL);
 
 		/* @todo remove redundant function-call */
 		lhs->kind = getunary(source->tok.kind);
 
 		gettok(source);
 		lhs->lhs = readatom(source, 0);
 		return lhs;
 	}
 
 	if (flags & ~(QINFER | QCONST)) {
 		error(getloc(source), "invalid use of qualifiers");
 		flags = flags & (QINFER | QCONST);
 	}
 
 	if (flags) {
 		lhs = readatom(source, flags);
 		return lhs;
 	}
 
 	/* actual atom */
 	switch (getkind(source)) {
 	case LPARDELIM:
 		gettok(source);
 
 		if (getkind(source) == LINEDELIM) {
 			/* FIXME(m21c): stmtlist should ignore indentation in
 			 *               this case! */
 			lhs = stmtlist(source, source->lastindent,
 					SSCOPE, NULL, false);
 			source->lastis = savedis;
 		} else {
 			lhs = exprlist(source, false, NULL);
 			source->lastis = savedis;
 
 			if (lhs->kind == TYPE) {
 				/* @note expecting that the type is also set in lhs->type */
 				lhs->kind = OCAST;
 				skipnewline(source);
 				expect(source, RPARDELIM, "expected ')'");
 
 				lhs->lhs = readatom(source, 0);
 				break;
 			}
 
 			if (lhs->kind == ACOMMA &&
 			    lhs->lhs->kind == TYPE &&
 			    lhs->rhs->kind == TYPE)
 			{
 				Type *ty = maketype(&lhs->loc, primitive(TTUPLE), NULL);
 				ty->target = lhs->lhs->type;
 				ty->u.rtarget = lhs->rhs->type;
 				deletenode(lhs);
 
 				skipnewline(source);
 				expect(source, RPARDELIM, "expected ')'");
 
 				lhs = declaration(source, gettype(source, ty), false);
 
 				assert(lhs);
 				return lhs;
 			}
 
 			skipnewline(source);
 		}
 
 		expect(source, RPARDELIM, "expected ')'");
 		break;
 
 	case IDENT:
 		lhs = readident(source, flags);
 		break;
 
 	case TYPE:
 		do {
 			Type *type = source->tok.type;
 			gettok(source);
 			lhs = declaration(source, gettype(source, type), false);
 		} while (0);
 
 		break;
 
 	case NUMBER:
 	case STRING:
 	case CHAR:
 		lhs = tokennode(source, NULL);
 		gettok(source);
 
 		if (flags & QCONST) {
 			/* @todo const - conversion */
 		}
 
 		break;
 
 	case KVAR:
 		gettok(source);
 		lhs = declaration(source, primitive(TINFER), false);
 		/* skip postfix-operators */
 		return lhs;
 
 	case KFALSE:
 	case KTRUE:
 		lhs = tokennode(source, NULL);
 		lhs->kind = NUMBER;
 		lhs->type = primitive(TBOOL);
 		lhs->u.u = (uintmax_t) (getkind(source) == KTRUE);
 		gettok(source);
 		break;
 
 	case KNULL:
 		lhs = tokennode(source, NULL);
 		lhs->kind = NUMBER;
 		lhs->type = maketype(&source->tok.loc, primitive(TPTR), primitive(TVOID));
 		lhs->u.u = (uintmax_t) (getkind(source) == KTRUE);
 		gettok(source);
 		break;
 
 	case KSTRUCT:
 	case KUNION:
 		lhs = readrecord(source, source->tok.kind == KUNION);
 		/* skip postfix-operators */
 		return lhs;
 
 	case KNOT:
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		lhs->kind = OLNOT;
 		lhs->lhs = readexpr(source, PRELAT);
 		break;
 
 	case KALIGNOF:
 	case KSIZEOF:
 	case KLENGTHOF:
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		if (getkind(source) == LPARDELIM) {
 			gettok(source);
 			lhs->lhs = exprlist(source, false, NULL);
 			expect(source, RPARDELIM, "expected ')'");
 		} else {
 			lhs->lhs = readatom(source, 0);
 		}
 
 		break;
 
 	case KBITCAST:
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		expect(source, LPARDELIM, "expected '('");
 		lhs->rhs = exprlist(source, false, NULL);
 		expect(source, RPARDELIM, "expected ')'");
 		lhs->lhs = readatom(source, 0);
 		break;
 
 	case KBREAK:
 	case KCONTINUE:
 		lhs = tokennode(source, NULL);
 		lhs->kind = getkind(source);
 		gettok(source);
 
 		if (getkind(source) == COLONDELIM) {
 			gettok(source);
 			skipnewline(source);
 			if (getkind(source) == IDENT) {
 				lhs->lhs = tokennode(source, NULL);
 				gettok(source);
 			} else {
 				error(getloc(source), "expected identifier");
 			}
 		}
 
 		break;
 
 	case KRETURN:
 		lhs = tokennode(source, NULL);
 		gettok(source);
 
 		if (getkind(source) == COLONDELIM) {
 			gettok(source);
 			skipnewline(source);
 			if (getkind(source) == IDENT) {
 				lhs->lhs = tokennode(source, NULL);
 				gettok(source);
 			} else {
 				error(getloc(source), "expected identifier");
 			}
 		}
 
 		/* if is atom */
 		if (!isdelimiter(source->tok.kind))
 			lhs->rhs = exprlist(source, false, NULL);
 
 		break;
 
 	case KDO:
 		indent = source->lastindent;
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		lhs->lhs = stmtlist(source, indent, SDO, NULL, false);
 		/* skip postfix-operators */
 		return lhs;
 
 	case KLOOP:
 		indent = source->lastindent;
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		pushenv(source, SLOOPHEADER);
 		lhs->lhs = stmtlist(source, indent, SLOOP, NULL, false);
 
 		if (skipnewlineontok(source, KUNTIL, indent)) {
 			lhs->kind = ALOOPUNTIL;
 			gettok(source);
 			lhs->u.payload = readexpr(source, POR);
 		}
 
 		if (lhs->kind != KLOOP)
 			goto joinelse;
 		
 		/* skip postfix-operators */
 		//	return finishcontrolflow(source, lhs, indent);
 
 		return wrapenv(lhs, popenv(source));
 
 	case KFOR:
 		indent = source->lastindent;
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		
 		pushenv(source, SLOOPHEADER);
 		lhs->u.payload = readexpr(source, POR);
 		if (getkind(source) == IDENT) {
 			if (source->tok.u.key == auxin) {
 				Node *aux = tokennode(source, NULL);
 				aux->lhs = lhs->u.payload;
 				aux->kind = AFOREACH;
 				lhs->u.payload = aux;
 				gettok(source);
 				aux->rhs = readexpr(source, POR);
 			} else if (source->tok.u.key == auxto) {
 				Node *aux = tokennode(source, NULL);
 				aux->lhs = lhs->u.payload;
 				aux->kind = AFORSTEP;
 				lhs->u.payload = aux;
 				gettok(source);
 				aux->rhs = readexpr(source, POR);
 				if (getkind(source) == IDENT
 				&&  source->tok.u.key == auxstep) {
 					gettok(source);
 					aux->u.payload = readexpr(source, POR);
 				} else {
 					aux->u.payload = tokennode(source, NULL);
 					aux->u.payload->kind = NUMBER;
 					aux->u.payload->type = primitive(TINFER);
 					aux->u.payload->u.s = 1;
 				}
 			} else if (source->tok.u.key == auxstep) {
 				Node *aux = tokennode(source, NULL);
 				aux->lhs = lhs->u.payload;
 				aux->kind = AFORSTEP;
 				lhs->u.payload = aux;
 				gettok(source);
 				aux->u.payload = readexpr(source, POR);
 
 				/* @note is this even correct? */
 				aux->rhs = tokennode(source, NULL);
 				aux->rhs->kind = NUMBER;
 				aux->rhs->type = primitive(TINFER);
 				aux->rhs->u.s = INTMAX_MAX;
 			}
 		}
 
 		/* @todo maybe use SFOR instead of SLOOP */
 		lhs->lhs = stmtlist(source, indent, SLOOP, NULL, false);
 		goto joinelse;
 		return finishcontrolflow(source, lhs, indent);
 
 	case KWHILE:
 		indent = source->lastindent;
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		pushenv(source, SLOOPHEADER);
 		lhs->u.payload = readexpr(source, POR);
 		lhs->lhs = stmtlist(source, indent, SWHILE, NULL, false);
 		goto joinelse;
 		return finishcontrolflow(source, lhs, indent);
 
 	case KIF:
 		indent = source->lastindent;
 		lhs = tokennode(source, NULL);
 		gettok(source);
 		pushenv(source, SIFHEADER);
 		lhs->u.payload = readexpr(source, POR);
 		/* skipnewline(source); */
 
 		if (getkind(source) == IDENT && source->tok.u.key == auxthen)
 			gettok(source);
 
 		lhs->lhs = stmtlist(source, indent, SIF, NULL, false);
 	joinelse:
 		if (skipnewlineontok(source, KELSE, indent)) {
 			gettok(source);
 			lhs->rhs = stmtlist(source, indent, SELSE, NULL, false);
 		}
 		return finishcontrolflow(source, lhs, indent);
 
 		/* skip postfix-operators */
 		return wrapenv(lhs, popenv(source));
 
 	default:
 	/* joinerror: */
 		error(getloc(source), "expected expression");
 		lhs = tokennode(source, NULL);
 		lhs->kind = NUMBER;
 		lhs->type = primitive(TERRTYPE);
 		lhs->u.u = 0;
 		gettok(source);
 	}
 
 	/* compound-literal */
 	if (getkind(source) == LCURLDELIM && lhs->kind == TYPE) {
 		lhs = tokennode(source, lhs);
 		lhs->kind = ACOMPOUND;
 		lhs->type = lhs->lhs->type;
 
 		gettok(source);
 		// source->lastindent = nextindent(source, source->lastindent);
 		lhs->rhs = readrecordinitfieldlist(source, lhs->type);
 		expect(source, RCURLDELIM, "expected '}'");
 	}
 
 	/* unary postfix operators */
 	while (getunarysuffix(source)) {
 		lhs = tokennode(source, lhs);
 
 		/* @todo remove redundant function-call */
 		lhs->kind = getunarysuffix(source);
 
 		if (getkind(source) == ODISP) {
 			gettok(source);
 			skipnewline(source);
 
 			if (getkind(source) != IDENT)
 				error(getloc(source), "expected identifier");
 
 			lhs->rhs = tokennode(source, NULL);
 
 		} else if (getkind(source) == COLONDELIM) {
 			gettok(source);
 			skipnewline(source);
 
 			if (getkind(source) != IDENT)
 				error(getloc(source), "expected identifier");
 
 			lhs->rhs = tokennode(source, NULL);
 
 		} else if (getkind(source) == LPARDELIM) {
 			gettok(source);
 
 			if (getkind(source) != RPARDELIM) {
 				lhs->rhs = exprlist(source, false, NULL);
 				source->lastis = savedis;
 			}
 
 			expect(source, RPARDELIM, "expected ')'");
 			continue;
 
 		} else if (getkind(source) == LSQRDELIM) {
 			gettok(source);
 
 			lhs->rhs = exprlist(source, false, NULL);
 			source->lastis = savedis;
 
 			expect(source, RSQRDELIM, "expected ']'");
 			continue;
 		}
 
 		gettok(source);
 	}
 
 	/* 'not'-suffix for the binary 'is'-operator (i.e. 'is not') */
 	while (getkind(source) == KIS) {
 		lhs = tokennode(source, lhs);
 		gettok(source);
 
 		lhs->kind = 'O';
 		if (getkind(source) == KNOT)
 			gettok(source), lhs->kind = ONEQ;
 		else
 			lhs->kind = OEQU;
 
 		source->lastis = lhs;
 		lhs->rhs = readexpr(source, PRELAT);
 	}
 
 	/* skip funtion-call without parentheses when next token is an
 	 * auxiliary keyword */
 	if (getkind(source) == IDENT) {
 		if (source->tok.u.key == auxthen
 		||  source->tok.u.key == auxin
 		||  source->tok.u.key == auxto
 		||  source->tok.u.key == auxstep) {
 			return lhs;
 		}
 	}
 
 	/* function call without parentheses */
 	if (lhs->kind == ADECLREF
 	&&  lhs->u.declref->kind == DFUNCTION
 	&&  isatomnode(getkind(source))) {
 		lhs = tokennode(source, lhs);
 		lhs->kind = OCALL;
 
 		lhs->rhs = exprlist(source, false, NULL);
 		source->lastis = savedis; /* @note is this correct? */
 	}
 
 	return lhs;
 }
 
 // }}}
 
 // @sub-section read expression {{{
 
 static Node *
 readexpr(Source *source, int minprec)
 {
 	Node *lhs = readatom(source, 0), *last = NULL;
 
 	/* only binary expr */
 	while (getprec(getkind(source)) >= minprec) {
 		lhs = tokennode(source, lhs);
 		gettok(source);
 		skipnewline(source);
 
 		lhs->rhs = readexpr(
 			source,
 			getprec(lhs->kind) + !israssoc(lhs->kind)
 		);
 
 		switch (getprec(lhs->kind)) {
 		case PRELAT:
 			if (last) {
 				lhs = tokennode(source, lhs);
 
 				lhs->rhs = lhs->lhs;
 				lhs->kind = OLAND;
 
 				lhs->lhs = lhs->rhs->lhs;
 				lhs->rhs->lhs = last->rhs; /* copy */
 				last = lhs->rhs;
 			} else {
 				last = lhs;
 			}
 
 			break;
 
 		default:
 			last = NULL;
 			break;
 		}
 	}
 
 	return lhs;
 }
 
 #if 0
 static Node *
 todeclaration(Node *curr, Node **ty)
 {
 	if (*ty) {
 		if (curr->kind == IDENT) {
 			Node *decl = makenode(curr, *ty);
 			curr->kind = ADECL;
 			decl->rhs = curr;
 			curr = decl;
 		} else if (curr->kind == OASS &&
 		           curr->lhs && curr->lhs->kind == IDENT)
 		{
 			curr->kind = ADECL;
 			curr->u.payload = curr->rhs;
 			curr->rhs = curr->lhs;
 			curr->lhs = *ty;
 		}
 	}
 
 	if (curr->kind == ADECL)
 		*ty = curr->lhs;
 
 	return curr;
 }
 #endif
 
 /* @todo this is stupid! There should be a simpler way to parse the
  *              comma-expressions (comma-operator, param-list, declaration-list,
  *              type-tuples and expression-tuples) */
 static Node *
 exprlist(Source *source, bool isparam, Type *paramtype)
 {
 	Node *lhs;
 	bool isdeclaration, typetuple;
 
 	/* tail = todeclaration(tail, &paramtype); */
 
 	if (paramtype && getkind(source) == IDENT) {
 		lhs = declaration(source, paramtype, false);
 	} else {
 		lhs = readexpr(source, PASSIGN);
 	}
 
 	isdeclaration = lhs->kind == ADECL;
 
 	if (isdeclaration)
 		paramtype = lhs->type;
 	else if (isparam)
 		error(getloc(source), "expected declaration");
 
 	typetuple = lhs->kind == TYPE;
 
 	while (getkind(source) == COMMADELIM) {
 		Node *rhs = NULL;
 
 		if (lhs->kind == ACOMMA &&
 		    lhs->lhs->kind == TYPE &&
 		    lhs->rhs->kind == TYPE)
 		{
 			lhs->type = maketype(&lhs->loc, primitive(TTUPLE),
 					lhs->lhs->type);
 			lhs->type->u.rtarget = lhs->rhs->type;
 
 			lhs->lhs->type = NULL;
 			lhs->rhs->type = NULL;
 			deletenode(lhs->lhs);
 			deletenode(lhs->rhs);
 
 			lhs->lhs = NULL;
 			lhs->rhs = NULL;
 			lhs->kind = TYPE;
 		}
 
 		lhs = tokennode(source, lhs);
 		lhs->kind = ACOMMA;
 		gettok(source);
 
 		if (getkind(source) == IDENT && isdeclaration) {
 			rhs = declaration(source, paramtype, true);
 			typetuple = false;
 		} else {
 			rhs = readexpr(source, PASSIGN);
 			typetuple &= rhs->kind == TYPE;
 			/* rhs = todeclaration(curr, &paramtype); */
 		}
 
 		if ((paramtype || isparam) && rhs->kind != ADECL)
 			error(getloc(source), "expected declaration");
 
 		if (rhs->kind == ADECL) {
 			paramtype = rhs->type;
 			isdeclaration = true;
 		}
 
 		lhs->rhs = rhs;
 	}
 
 	source->lastis = NULL;
 	return lhs;
 }
 
 // }}}
 
 
 
 // }}}
 
 // @section type-checking & folding {{{
 
 static bool
 isinttype(Type *ty)
 {
 	switch (ty->kind) {
 	case TINFER: case TUINFER:
 	case TS8:    case TU8:
 	case TS16:   case TU16:
 	case TS32:   case TU32:
 	case TS64:   case TU64:
 	case TERRTYPE: /* avoiding error-reporting on error-type */
 		return true;
 
 	/* FIXME(m21c): This *just* tests wether a tuple only contains types of
 	 *               certain kinds. In order to check wether two tuple-types
 	 *               are compatible (for casting), another function has to
 	 *               be implemented. */
 	case TTUPLE:
 		return isinttype(ty->target)
 		    && isinttype(ty->u.rtarget);
 
 	default:
 		return false;
 	}
 }
 
 static bool
 isintorbooltype(Type *ty)
 {
 	switch (ty->kind) {
 	case TBOOL:
 	case TINFER: case TUINFER:
 	case TS8:    case TU8:
 	case TS16:   case TU16:
 	case TS32:   case TU32:
 	case TS64:   case TU64:
 	case TERRTYPE: /* avoiding error-reporting on error-type */
 		return true;
 
 	/* FIXME(m21c): This *just* tests wether a tuple only contains types of
 	 *               certain kinds. In order to check wether two tuple-types
 	 *               are compatible (for casting), another function has to
 	 *               be implemented. */
 	case TTUPLE:
 		return isintorbooltype(ty->target)
 		    && isintorbooltype(ty->u.rtarget);
 
 	default:
 		return false;
 	}
 }
 
 static bool
 isfloattype(Type *ty)
 {
 	switch (ty->kind) {
 	case TF32: case TF64:
 	case TERRTYPE: /* avoiding error-reporting on error-type */
 		return true;
 
 	/* FIXME(m21c): This *just* tests wether a tuple only contains types of
 	 *               certain kinds. In order to check wether two tuple-types
 	 *               are compatible (for casting), another function has to
 	 *               be implemented. */
 	case TTUPLE:
 		return isfloattype(ty->target)
 		    && isfloattype(ty->u.rtarget);
 
 	default:
 		return false;
 	}
 }
 
 static bool
 isarithtype(Type *ty)
 {
 	switch (ty->kind) {
 	case TBOOL:
 	case TINFER: case TUINFER:
 	case TS8:    case TU8:
 	case TS16:   case TU16:
 	case TS32:   case TU32:
 	case TS64:   case TU64:
 	case TF32:   case TF64:
 	case TERRTYPE: /* avoiding error-reporting on error-type */
 		return true;
 
 	/* FIXME(m21c): This *just* tests wether a tuple only contains types of
 	 *               certain kinds. In order to check wether two tuple-types
 	 *               are compatible (for casting), another function has to
 	 *               be implemented. */
 	case TTUPLE:
 		return isarithtype(ty->target)
 		    && isarithtype(ty->u.rtarget);
 
 	default:
 		return false;
 	}
 }
 
 static bool
 isunsignedtype(Type *ty)
 {
 	switch (ty->kind) {
 	case TBOOL:
 	case TUINFER:
 	case TU8:   case TU16:
 	case TU32:  case TU64:
 	case TERRTYPE: /* avoiding error-reporting on error-type */
 		return true;
 
 	/* FIXME(m21c): This *just* tests wether a tuple only contains types of
 	 *               certain kinds. In order to check wether two tuple-types
 	 *               are compatible (for casting), another function has to
 	 *               be implemented. */
 	case TTUPLE:
 		return isunsignedtype(ty->target)
 		    && isunsignedtype(ty->u.rtarget);
 
 	default:
 		return false;
 	}
 }
 
 static bool
 islvalue(Node *node)
 {
 	assert(node);
 
 	switch (node->kind) {
 	case ADECLREF:
 	case ADEREF:
 	case ADECL:
 	case ODISP: /* only for member fields. @todo evaluate for properties. */
 	case TERRTYPE: /* avoiding error-reporting on error-type */
 		return true;
 
 	case ACOMMA:
 		return islvalue(node->lhs) && islvalue(node->rhs);
 
 	default:
 		return false;
 	}
 }
 
 /* @todo also mask int/float values in the tokenizer */
 static uintmax_t
 maskint(int size, uintmax_t value)
 {
 	if (size == 1) return value & 0xfful;
 	if (size == 2) return value & 0xfffful;
 	if (size == 4) return value & 0xfffffffful;
 
 	return value;
 }
 
 static double
 maskfloat(int size, double value)
 {
 	if (size == 4) return (double) (float) value;
 
 	return value;
 }
 
 static uintmax_t
 convint(int srcsize, bool srcsigned, uintmax_t value)
 {
 	if (!srcsigned) return value;
 	if (srcsize == 1) return (uintmax_t) (int8_t ) value;
 	if (srcsize == 2) return (uintmax_t) (int16_t) value;
 	if (srcsize == 4) return (uintmax_t) (int32_t) value;
 
 	return value;
 }
 
 static Node *
 conv(Node *node);
 
 static Node *
 wrap(Type *type, Node *node)
 {
 	Type *nodetype = node->type;
 
 	assert(type);
 
 	// @todo add error-reporting | refactor
 	if (!nodetype) {
 		printf("node has no type\n");
 	}
 
 	assert(nodetype);
 
 	/* @todo do proper type-check */
 	if (type->kind == nodetype->kind)
 		return node;
 
 	if (node->kind == NUMBER) {
 		/* @todo layout correct type-conversions ? */
 		if (isfloattype(nodetype)) {
 			if (isfloattype(type)) {
 				node->u.d = maskfloat(
 					type->size,
 					node->u.d
 				);
 
 			} else if (isintorbooltype(type)) {
 				node->u.u = maskint(
 					type->size,
 					(intmax_t) node->u.d
 				);
 			}
 		} else if (isintorbooltype(nodetype)) {
 			if (isfloattype(type)) {
 				node->u.d = maskfloat(
 					type->size, (double)
 					(intmax_t) convint(node->type->size,
 						!isunsignedtype(node->type),
 						node->u.u
 					)
 				);
 
 			} else if (isintorbooltype(type)) {
 				node->u.u = maskint(
 					type->size,
 					convint(
 						nodetype->size,
 						!isunsignedtype(nodetype),
 						node->u.u
 					)
 				);
 			}
 		}
 
 		node->type = type;
 		return node;
 	}
 
 	/* @note no implicit (de-)referencing if the wrap-type is bool */
 	if (type->kind == TBOOL)
 		goto doconversion;
 
 	/* @todo skip implicit (de-)referencing on arithmetic
 	 *              conversion, also skip if called from conv() */
 
 	/* implicit referencing: */
 	if (type->kind == TPTR && type->target->kind == nodetype->kind) {
 		node = makenode(node, node);
 		node->kind = OADDR;
 		node->type = type->target;
 
 		/* @todo check for lvalue & maybe do further
 		 *              type-checks*/
 		return node;
 	}
 
 	/* implicit de-referencing: */
 	if (nodetype->kind == TPTR && nodetype->target->kind == type->kind) {
 		node = makenode(node, node);
 		node->kind = ODEREF;
 		node->type = type;
 
 		/* @todo maybe do further type-checks*/
 		return node;
 	}
 
 doconversion:
 	node = makenode(node, node);
 	node->kind = ACONV;
 	node->type = type;
 
 	return node;
 }
 
 static Node *
 conv(Node *node)
 {
 	Type *ty = node->type;
 
 	assert(ty);
 
 	if (ty->kind == TINFER)
 		return wrap(primitive(TINT), node);
 
 	if (ty->kind == TUINFER)
 		return wrap(primitive(TUINT), node);
 
 	return node;
 }
 
 
 static bool
 arithtuplereorder(Env *env, Node *expr, int numops)
 {
 	Node *tmp;
 
 	(void) env;
 
 	if (numops == 2) {
 		if (expr->lhs->kind != ACOMMA)
 			return false;
 
 		if (expr->rhs->kind != ACOMMA)
 			return false;
 
 		/* (a, b) OP (x, y)  ==>  (a OP x, b OP y) */
 		expr->lhs->kind = expr->kind;
 		expr->rhs->kind = expr->kind;
 		expr->kind = ACOMMA;
 
 		tmp = expr->lhs->rhs;
 		expr->lhs->rhs = expr->rhs->lhs;
 		expr->rhs->lhs = tmp;
 
 		return true;
 	}
 
 	if (numops == 1) {
 		if (expr->lhs->kind != ACOMMA)
 			return false;
 
 		/* OP (a, b)  ==>  (OP a, OP b) */
 		expr->lhs->kind = expr->kind;
 
 		tmp = expr->rhs;
 		expr->rhs = makenode(expr, expr->lhs->rhs);
 		expr->lhs->rhs = tmp; /* @note some unary nodes may have a rhs? */
 		expr->rhs->rhs = tmp; /* @todo make a copy */
 		expr->kind = ACOMMA;
 
 		return true;
 	}
 
 	return false;
 }
 
 static Type *
 typecheckdecl(Env *env, Decl *decl)
 {
 	if (decl->kind == DPARAM || decl->kind == DVAR) {
 		if (!decl->u.content)
 			return decl->type;
 
 		decl->u.content = typecheck(env, decl->u.content);
 
 		if (decl->type->kind == TINFER) {
 			decl->u.content = conv(decl->u.content);
 			decl->type = decl->u.content->type;
 		} else {
 			decl->u.content = wrap(decl->type, decl->u.content);
 		}
 	} else if (decl->kind == DFUNCTION) {
 		if (!decl->u.content)
 			return decl->type;
 
 		assert(decl->contentenv);
 		if (decl->contentenv->pending)
 			return decl->type;
 
 		decl->u.content = typecheck(env, decl->u.content);
 	}
 
 	return decl->type;
 }
 
 static Node *
 substitutedispatch(Env *env, Node *expr)
 {
 #if 0
 	/* This is wrong (tuple != comma-operator)*/
 	assert(expr->u.declref);
 	assert(expr->type == expr->u.declref->type);
 
 	expr->kind = ACOMMA;
 	expr->type = maketype(&expr->loc, primitive(TTUPLE), expr->lhs->type);
 
 	expr->rhs->kind = ADECLREF;
 	expr->rhs->u.declref = expr->u.declref;
 	expr->rhs->type = expr->type;
 
 	expr->type->u.rtarget = expr->lhs->type;
 	return expr;
 #else
 	Node *result = makenode(expr, NULL);
 	result->kind = ADECLREF;
 	result->u.declref = expr->u.declref;
 	result->type = expr->type;
 
 	/* @fixme delete doesnt work (self is used multiple times) */
 	/* deletenode(expr); */
 	return result;
 #endif
 }
 
 static Node *
 substitutedispatchcall(Env *env, Node *expr)
 {
 	expr->lhs = substitutedispatch(env, expr->lhs);
 
 	return expr;
 }
 
 static Node *
 selfdispatchcall(Env *env, Node *expr)
 {
 	Node *self, *probe, *insert;
 
 	assert(expr && expr->kind == OCALL);
 
 	if (expr->lhs->kind != ASELFDISP)
 		return expr;
 
 	self = expr->lhs->lhs;
 	assert(self);
 	assert(self->type);
 
 	if (self->type->kind == TSTRUCT || self->type->kind == TUNION) {
 		self = makenode(self, self);
 		self->kind = OADDR;
 		self->type = maketype(&self->loc, primitive(TINT), self->type);
 	} else if (self->type->kind != TPTR) {
 		error(&self->loc, "expected struct or union or pointer type");
 	} else if (self->type->target->kind != TSTRUCT &&
 	           self->type->target->kind != TUNION) {
 		error(&self->loc, "expected pointer to struct or union type");
 	}
 
 	if (!expr->rhs) {
 		expr->rhs = self;
 		return substitutedispatchcall(env, expr);
 	}
 
 	if (expr->rhs->kind != ACOMMA) {
 		insert = makenode(expr->rhs, self);
 		insert->kind = ACOMMA;
 		insert->rhs = expr->rhs;
 		expr->rhs = insert;
 
 		return substitutedispatchcall(env, expr);
 	}
 
 	probe = expr->rhs;
 	while (probe->lhs && probe->lhs->kind == ACOMMA)
 		probe = probe->lhs;
 
 	insert = makenode(probe, self);
 	insert->rhs = probe->lhs;
 	probe->lhs = insert;
 
 	return substitutedispatchcall(env, expr);
 }
 
 static Node *
 resolvepending(Env *env, Node *expr)
 {
 	Decl *decl;
 
 	assert(expr->kind == IDENT);
 
 	decl = finddeclaration(NULL, env, expr->u.key);
 
 	if (!decl) {
 		error(&expr->loc, "'%s' undeclared",
 			getstring(idents, expr->u.key));
 
 		return expr;
 	}
 
 	if (decl->kind != DVAR && decl->kind != DFUNCTION) {
 		error(&expr->loc, "'%s' is not a variable nor a function",
 			getstring(idents, expr->u.key));
 
 		return expr;
 	}
 
 	expr->kind = ADECLREF;
 	expr->u.declref = decl;
 	expr->type = decl->type;
 
 	return typecheck(env, expr);
 }
 
 static Node *
 dispatch(Node *expr, Node *parent)
 {
 	Type *type;
 	Decl *field;
 
 	/* @note might change in future */
 	assert(expr->lhs);
 	type = expr->lhs->type;
 	assert(type);
 
 	/* @todo maybe do implicit dereference */
 	if (type->kind == TPTR) {
 		Node *lhs = makenode(expr->lhs, expr->lhs);
 		lhs->kind = ADEREF;
 		lhs->type = type->target;
 
 		type = type->target;
 		expr->lhs = lhs;
 	}
 
 	if (type->kind != TSTRUCT && type->kind != TUNION) {
 		error(&expr->lhs->loc, "expected struct or union type");
 		return expr;
 	}
 
 	/* @note might change in future */
 	assert(expr->rhs);
 	assert(expr->rhs->kind == IDENT);
 
 	/* @note improvised for now */
 	assert(type->module->contentenv);
 	field = finddeclinenv(expr->rhs->u.key, type->module->contentenv);
 
 	if (!field) {
 		const char *typekind = type->kind == TSTRUCT ? "struct" : "union";
 		const char *modulename = getstring(idents, type->module->key);
 		const char *fieldname = getstring(idents, expr->rhs->u.key);
 		error(&expr->rhs->loc, "%s '%s' has no field '%s'",
 			typekind, modulename, fieldname);
 		expr->type = primitive(TERRTYPE);
 		return expr;
 	}
 
 	expr->type = field->type;
 	expr->u.declref = field;
 
 	return expr;
 }
 
 static void
 forloop(Env *env, Node *expr, Node *header)
 {
 	if (header->kind == AFORSTEP) {
 		Node *init = header->lhs;
 		if (init->kind == ADECL) {
 			Decl *it = init->u.declref;
 			if (!it->u.content) {
 				if (!isarithtype(it->type)) {
 					error(&it->loc, "for loop variable must be initialized");
 					return;
 				}
 				it->u.content = makenode(header, NULL);
 				it->u.content->kind = NUMBER;
 				it->u.content->type = it->type;
 				it->u.content->u.u = 0;
 			}
 
 			header->lhs = conv(typecheck(env, header->lhs));
 		}
 
 		/* @todo do proper typechecking */
 		header->rhs = wrap(header->lhs->type, typecheck(env, header->rhs));
 		header->u.payload = wrap(header->lhs->type, typecheck(env, header->u.payload));
 		return;
 	}
 
 	if (header->kind == AFOREACH) {
 
 		return;
 	}
 
 	header = expr->u.payload = conv(typecheck(env, header));
 
 	if (isarithtype(header->type)) {
 		Decl *it;
 		Node *forstep;
 		
 
 		it = makedecl2(&header->loc, env,
 			getstringkey(&idents, "it", 2), DVAR);
 		it->type = header->type;
 		it->u.content = makenode(header, NULL);
 		it->u.content->kind = NUMBER;
 		it->u.content->type = header->type;
 		it->u.content->u.u = 0;
 
 		forstep = makenode(header, NULL);
 		forstep->kind = AFORSTEP;
 		forstep->type = header->type;
 
 		forstep->lhs = makenode(header, NULL);
 		forstep->lhs->kind = ADECL;
 		forstep->lhs->u.declref = it;
 
 		forstep->rhs = header;
 
 		forstep->u.payload = makenode(header, NULL);
 		forstep->u.payload->kind = NUMBER;
 		forstep->u.payload->type = header->type;
 		/* @todo handle negative step when possible
 		 *       (i.e. when header is signed and constant) */
 		if (isfloattype(header->type))
 			forstep->u.payload->u.d = 1.0;
 		else
 			forstep->u.payload->u.u = 1;
 	
 		expr->u.payload = forstep;
 		return;
 	}
 
 	/* @todo handle other cases (e.g. arrays/strings/lists/iterators) */
 	error(&expr->loc, "invalid loop header");
 }
 
 Node *parentnodes[1024];
 int parenttop = 0;
 
 static Node *
 typecheck(Env *env, Node *expr)
 {
 	#define return return --parenttop, 
 
 	Node *lhs = expr->lhs, *rhs = expr->rhs;
 
 	parentnodes[parenttop++] = expr;
 
 	#define errortype(condition) do { \
 		if (condition) { \
 			expr->type = primitive(TERRTYPE); \
 			return expr; \
 		} \
 	} while (0)
 
 	#define reporton(condition, loc, errormsg) do { \
 		if (condition) { \
 			error((loc), (errormsg)); \
 			expr->type = primitive(TERRTYPE); \
 			return expr; \
 		} \
 	} while (0)
 
 	switch (getnumops(expr->kind)) {
 	case 2:
 		assert(rhs);
 		errortype(rhs->type->kind == TERRTYPE);
 		rhs = typecheck(env, rhs);
 		/* FALLTHROUGH */
 	case 1:
 		assert(lhs);
 		errortype(lhs->type->kind == TERRTYPE);
 		lhs = typecheck(env, lhs);
 
 		if (arithtuplereorder(env, expr, getnumops(expr->kind)))
 			goto joincomma;
 	}
 
 	if (expr->type && expr->type->kind == TERRTYPE)
 		return expr;
 
 	switch (expr->kind) {
 	case ODISP:
 	case ASELFDISP:
 		lhs = typecheck(env, lhs);
 		expr->lhs = conv(lhs);
 
 		if (parenttop > 1)
 			return dispatch(expr, parentnodes[parenttop - 2]);
 
 		return dispatch(expr, NULL);
 
 	case OCALL:
 		reporton(lhs->type->kind == TPTR && lhs->type->target->kind != TFUNCTION,
 			&expr->loc, "operand is not a pointer to function");
 		
 		reporton(lhs->type->kind != TPTR && lhs->type->kind != TFUNCTION,
 			&expr->loc, "operand is not a function");
 
 		if (lhs->type->kind == TFUNCTION)
 			expr->type = lhs->type->u.rtarget;
 		else
 			expr->type = lhs->type->target->u.rtarget;
 		
 		expr = selfdispatchcall(env, expr);
 		expr->rhs = typecheck(env, expr->rhs);
 		return expr;
 	
 	case OARRAY:
 		expr->lhs = conv(lhs);
 		reporton(lhs->type->kind != TARRAY && lhs->type->kind != TPTR,
 			&expr->loc, "operand is not an array or pointer");
 
 		expr->rhs = typecheck(env, rhs);
 
 		/* @todo handle negative indices when possible (use unsigned) */
 		reporton(!isinttype(rhs->type),
 			&rhs->loc, "array index is not an integer");
 
 		expr->rhs = wrap(primitive(TUSIZE), expr->rhs);
 		
 		expr->type = lhs->type->target;
 		return expr;
 
 	case OINC: case ODEC: case OSUFINC: case OSUFDEC:
 		reporton(!islvalue(lhs),
 			&expr->loc, "operand is not an lvalue");
 
 		expr->lhs = conv(lhs);
 		expr->type = lhs->type;
 		return expr;
 
 	case ODEREF:
 		expr->type = lhs->type;
 
 		reporton(expr->type->kind != TPTR,
 			&expr->loc, "operand is not a pointer");
 
 		expr->type = expr->type->target;
 		return expr;
 
 	case OADDR:
 		reporton(!islvalue(lhs),
 			&expr->loc, "operand is not an lvalue");
 
 		expr->type = maketype(&expr->loc, primitive(TPTR), lhs->type);
 		return expr;
 
 	case OPLUS: case OMINUS:
 		/*
 		reporton(!isarithtype(lhs->type),
 			&lhs->loc, "expression is not of arithmetic type");
 		*/
 
 		expr->lhs = conv(lhs);
 		expr->type = lhs->type;
 		return expr;
 
 	case OBNOT:
 		reporton(!isintorbooltype(lhs->type),
 			&lhs->loc, "expression is not of integer type");
 
 		expr->lhs = conv(lhs);
 		expr->type = lhs->type;
 		return expr;
 
 	case OLNOT:
 		reporton(!isarithtype(lhs->type),
 			&lhs->loc, "expression is not of arithmetic type");
 
 		expr->type = primitive(TBOOL);
 		expr->lhs = conv(lhs); /* cannot be wrap(expr->type, lhs) */
 		return expr;
 
 	case OCAST:
 		/*
 		assert(rhs);
 		assert(lhs->kind == TYPE);
 		*/
 
 		if (arithtuplereorder(env, expr, 1))
 			goto joincomma;
 
 		/* expr->type = expr->lhs->type; */
 		return expr;
 
 	case OMUL: case ODIV: case OMOD:
 	case OADD: case OSUB:
 		reporton(!isarithtype(lhs->type) || !isarithtype(rhs->type),
 			&expr->loc, "expression is not of arithmetic type");
 
 		/* usual arithmetic conversion */
 		if (lhs->type->kind < rhs->type->kind)
 			expr->type = rhs->type;
 		else
 			expr->type = lhs->type;
 
 		expr->lhs = wrap(expr->type, lhs);
 		expr->rhs = wrap(expr->type, rhs);
 		return expr;
 
 	case OBAND: case OBOR: case OXOR:
 		reporton(!isintorbooltype(lhs->type) || !isintorbooltype(rhs->type),
 			&expr->loc, "expression is not of integer type");
 
 		/* usual arithmetic conversion */
 		if (lhs->type->kind < rhs->type->kind)
 			expr->type = rhs->type;
 		else
 			expr->type = lhs->type;
 
 		expr->lhs = wrap(expr->type, lhs);
 		expr->rhs = wrap(expr->type, rhs);
 		return expr;
 
 	case OLSH: case ORSH: case OARSH:
 		reporton(!isinttype(lhs->type) || !isinttype(rhs->type),
 			&expr->loc, "expression is not of integer type");
 
 		expr->lhs = conv(lhs);
 		expr->rhs = wrap(primitive(TINT), rhs);
 		expr->type = lhs->type;
 		return expr;
 
 	case OEQU: case ONEQ:
 	case OLET: case OLEQ:
 	case OGRT: case OGEQ:
 		reporton(!isarithtype(lhs->type) || !isarithtype(rhs->type),
 			&expr->loc, "expression is not of arithmetic type");
 
 		expr->lhs = conv(lhs);
 		expr->rhs = conv(rhs);
 		expr->type = primitive(TBOOL);
 		return expr;
 
 	case OLAND: case OLOR:
 		reporton(!isarithtype(lhs->type) || !isarithtype(rhs->type),
 			&expr->loc, "expression is not of arithmetic type");
 
 		expr->type = primitive(TBOOL);
 		expr->lhs = wrap(expr->type, lhs);
 		expr->rhs = wrap(expr->type, rhs);
 		return expr;
 
 	case OMULA: case ODIVA: case OMODA:
 	case OADDA: case OSUBA:
 		reporton(!isarithtype(lhs->type) || !isarithtype(rhs->type),
 			&expr->loc, "expression is not of arithmetic type");
 		goto joinassign;
 
 	case OLSHA: case ORSHA: case OARSHA:
 	case OANDA:
 	case OORA: case OXORA:
 		reporton(!isinttype(lhs->type) || !isinttype(rhs->type),
 			&expr->loc, "expression is not of integer type");
 		/* FALLTHROUGH */
 
 	case OASS:
 	joinassign:
 		reporton(!islvalue(lhs),
 			&expr->loc, "left-hand-side is not an lvalue");
 
 		expr->lhs = conv(lhs);
 		expr->type = lhs->type;
 		expr->rhs = wrap(expr->type, rhs);
 		return expr;
 
 	case KIF:
 	case KWHILE:
 	case KUNTIL:
 		assert(expr->u.payload);
 		expr->u.payload = typecheck(env, expr->u.payload);
 		expr->u.payload = wrap(primitive(TBOOL), expr->u.payload);
 
 		if (lhs)
 			expr->lhs = typecheck(env, lhs);
 
 		if (rhs)
 			expr->rhs = typecheck(env, rhs);
 
 		/* @todo find a way how we do type-checking for the
 		 *              last expression in a statement-list, which
 		 *              might be needed by the enclosed statement-list
 		 */
 
 		expr->type = primitive(TVOID);
 		return expr;
 
 	case KFOR:
 		assert(expr->u.payload);
 		forloop(env, expr, expr->u.payload);
 
 		if (lhs)
 			expr->lhs = typecheck(env, lhs);
 
 		if (rhs)
 			expr->rhs = typecheck(env, rhs);
 
 		/* @todo infer type of the for-loop like in the case above. */
 
 		expr->type = primitive(TVOID);
 		return expr;
 
 	case AENV:
 	case ASCOPE:
 		assert(lhs);
 		assert(expr->u.env);
 
 		expr->lhs = typecheck(expr->u.env, lhs);
 		return expr;
 
 	case ASTMT:
 		rhs = expr;
 	advancestmt:
 		lhs = typecheck(env, lhs);
 		rhs->lhs = lhs;
 
 		if (rhs->rhs) {
 			assert(rhs->rhs->kind == ASTMT);
 			rhs = rhs->rhs, lhs = rhs->lhs;
 			goto advancestmt;
 		}
 		return expr;
 
 	case ADECL:
 		expr->type = typecheckdecl(env, expr->u.declref);
 		return expr;
 	
 	case ADECLREF:
 		/* @note propagate type changes from ADECL to ADECLREF */
 		expr->type = expr->u.declref->type;
 		return expr;
 
 	case AADDR:
 	case ADEREF:
 		assert(lhs);
 		lhs = typecheck(env, lhs);
 
 		expr->lhs = conv(lhs);
 		return expr;
 
 	case ACOMPOUND:
 		assert(lhs);
 		assert(rhs);
 
 		expr->lhs = typecheck(env, lhs);
 		expr->type = lhs->type;
 		expr->rhs = typecheck(env, rhs);
 		return expr;
 
 	case AFIELDINIT:
 		assert(expr->rhs);
 		expr->rhs = typecheck(env, rhs);
 		return expr;
 
 	case IDENT:
 		return resolvepending(env, expr);
 
 	joincomma:
 		lhs = expr->lhs;
 		rhs = expr->rhs;
 		/* FALLTHROUGH */
 	case ACOMMA:
 		assert(lhs);
 		assert(rhs);
 
 		/* @todo make sure that typechecking is done
 		 *              correctly, since comma might be re-
 		 *              ordered:
 		 *                  - check that maketype is NOT called
 		 *                    multiple times and/or discarded on
 		 *                    the same node.
 		 *                  - check wether the resulting type
 		 *                    does account for nesting on rhs */
 		errortype(lhs->type->kind == TERRTYPE);
 		errortype(rhs->type->kind == TERRTYPE);
 
 		lhs = typecheck(env, lhs);
 		rhs = typecheck(env, rhs);
 
 		/* @note converting nodes may be uneccessary */
 		expr->lhs = conv(lhs);
 		expr->rhs = conv(rhs);
 
 		expr->type = maketype(&expr->loc, primitive(TTUPLE), lhs->type);
 		expr->type->u.rtarget = rhs->type;
 		return expr;
 
 	case KBITCAST:
 		assert(lhs);
 		assert(rhs);
 
 		expr->lhs = lhs = typecheck(env, lhs);
 
 		errortype(lhs->type->kind == TERRTYPE);
 		errortype(rhs->type->kind == TERRTYPE);
 		reporton(rhs->kind != TYPE, &rhs->loc, "expected type");
 
 		expr->type = rhs->type;
 		return expr;
 
 	case KSIZEOF:
 	case KALIGNOF:
 	case KLENGTHOF:
 		assert(lhs);
 
 		expr->lhs = lhs = typecheck(env, lhs);
 		errortype(lhs->type->kind == TERRTYPE);
 
 		expr->type = primitive(TUSIZE);
 		return expr;
 
 	case KRETURN:
 		rhs = expr->rhs;
 
 		if (rhs) {
 			expr->rhs = rhs = typecheck(env, rhs);
 			errortype(rhs->type->kind == TERRTYPE);
 		}
 
 		do {
 			Env *funcenv = getfuncenv(env);
 			Type *functype;
 
 			reporton(!funcenv,
 				&expr->loc, "return statement is not inside a function");
 
 			assert(funcenv->envdecl);
 			assert(funcenv->envdecl->type);
 
 			functype = funcenv->envdecl->type;
 
 			assert(functype->kind == TFUNCTION);
 			assert(functype->u.rtarget);
 
 			expr->type = functype->u.rtarget;
 		} while (0);
 
 		reporton(expr->type->kind == TVOID &&
 		         rhs && rhs->type->kind != TVOID,
 			&expr->loc, "expected no return value");
 
 		reporton(expr->type->kind != TVOID &&
 		         (!rhs || rhs->type->kind == TVOID),
 			&expr->loc, "expected return value");
 
 		if (rhs)
 			expr->lhs = wrap(expr->type, rhs);
 
 		return expr;
 
 	default:
 		return expr;
 	}
 
 	#undef errortype
 	#undef reporton
 	#undef return
 }
 
 static Node *
 foldexpr(Env *env, Node *expr);
 
 static Node *
 folddeclaration(Env *env, Node *expr)
 {
 	Decl *decl = expr->u.declref;
 
 	assert(decl);
 
 	if (decl->kind == DFUNCTION) {
 		if (decl->u.content)
 			/* @todo make sure the correct env is used */
 			decl->u.content = foldexpr(env, decl->u.content);
 
 	} else if (decl->kind == DPARAM || decl->kind == DVAR) {
 
 		/* @todo remove condition. it is only for testing structs.
 		 *       content may not be NULL otherwise (needs validation) */
 		if (decl->u.content)
 			decl->u.content = foldexpr(env, decl->u.content);
 	}
 
 	return expr;
 }
 
 static Node *
 foldexpr(Env *env, Node *expr)
 {
 	Node *lhs = expr->lhs, *rhs = expr->rhs;
 	Type *ty = expr->type;
 
 
 	#define evalbinary(op) do { \
 			expr->kind = NUMBER; \
 			if (isfloattype(ty)) \
 				expr->u.d = maskfloat(ty->size, \
 					maskfloat(ty->size, lhs->u.d)  op \
 					maskfloat(ty->size, rhs->u.d) \
 				); \
 			else if (isintorbooltype(ty)) \
 				expr->u.u = maskint(ty->size, \
 					maskint(ty->size, lhs->u.u) op \
 					maskint(ty->size, rhs->u.u) \
 				); \
 			deletenode(lhs); \
 			deletenode(rhs); \
 		} while (0)
 
 	#define isvalue(expr, value) (expr->kind == NUMBER && \
 		((expr->u.u == value && isintorbooltype(ty)) || \
 		 (expr->u.d == value && isarithtype(ty))))
 
 	/* @todo maybe modify getnumops() in such a way, that it
 		*              will behave properly for non-operator nodes too */
 	switch (getnumops(expr->kind)) {
 	case 2:
 		rhs = foldexpr(env, rhs);
 		/* FALLTHROUGH */
 	case 1:
 		lhs = foldexpr(env, lhs);
 	}
 
 	switch ((int) expr->kind) {
 	case OADD: case OSUB:
 		if (lhs->kind == NUMBER && rhs->kind == NUMBER) {
 			if (expr->kind == OADD) evalbinary(+);
 			else evalbinary(-);
 		} else if (isvalue(lhs, 0)) {
 			if (expr->kind == OADD) {
 				*expr = *rhs;
 				deletenode(lhs);
 				deletenode(rhs);
 			} else {
 				expr->kind = OMINUS;
 				expr->lhs = rhs;
 				deletenode(lhs);
 			}
 		} else if (isvalue(rhs, 0)) {
 			*expr = *lhs;
 			deletenode(lhs); deletenode(rhs);
 		}
 
 		return expr;
 
 	case OMUL: case ODIV: case OMOD:
 		if (lhs->kind == NUMBER && rhs->kind == NUMBER) {
 			if (expr->kind == OMUL) {
 				evalbinary(*);
 			} else  {
 				if (rhs->u.u == 0 && isintorbooltype(ty)) {
 					error(
 						&expr->loc,
 						"division by zero"
 					);
 				} else if (expr->kind == ODIV) {
 					evalbinary(/);
 				} else {
 					evalbinary(/); /* @todo implement modulus for float-types */
 				}
 			}
 		} else if (isvalue(lhs, 0)) {
 			*expr = *lhs;
 			deletenode(lhs);
 			deletenode(rhs);
 		} else if (expr->kind == OMUL && isvalue(rhs, 0)) {
 			*expr = *rhs;
 			deletenode(lhs);
 			deletenode(rhs);
 		} else if (isvalue(rhs, 0)) {
 			if (rhs->u.u == 0 && isintorbooltype(ty))
 				error(&expr->loc, "division by zero");
 			*expr = *rhs;
 			deletenode(lhs);
 			deletenode(rhs);
 		} else if (isvalue(lhs, 1)) {
 			*expr = *rhs;
 			deletenode(lhs);
 			deletenode(rhs);
 		} else if (expr->kind == OMUL && isvalue(rhs, 1)) {
 			*expr = *lhs;
 			deletenode(lhs);
 			deletenode(rhs);
 		}
 
 		return expr;
 
 	case OPLUS:
 		*expr = *lhs;
 
 		deletenode(lhs);
 		return expr;
 
 	case OMINUS:
 		if (lhs->kind == NUMBER) {
 			if (isfloattype(ty)) {
 				expr->kind = NUMBER;
 				expr->u.d = maskfloat(ty->size, -lhs->u.d);
 				deletenode(lhs);
 			} else if (isintorbooltype(ty)) {
 				expr->kind = NUMBER;
 				expr->u.u = maskint(ty->size, -lhs->u.u);
 				deletenode(lhs);
 			}
 		} else if (lhs->kind == OMINUS && lhs->lhs) {
 			*expr = *lhs->lhs;
 			deletenode(lhs);
 		}
 
 		return expr;
 
 	case OBAND: case OBOR: case OXOR:
 		if (lhs->kind == NUMBER && rhs->kind == NUMBER) {
 			assert(isintorbooltype(lhs->type));
 			assert(isintorbooltype(rhs->type));
 			lhs->u.u = maskint(ty->size, lhs->u.u);
 			rhs->u.u = maskint(ty->size, rhs->u.u);
 			if (expr->kind == OBAND)
 				expr->u.u = lhs->u.u & rhs->u.u;
 			else if (expr->kind == OBOR)
 				expr->u.u = lhs->u.u | rhs->u.u;
 			else
 				expr->u.u = lhs->u.u ^ rhs->u.u;
 			expr->kind = NUMBER;
 			expr->u.u = maskint(ty->size, expr->u.u);
 		}
 
 		return expr;
 
 	case ASCOPE:
 		assert(expr->lhs);
 		assert(expr->u.env);
 
 		expr->lhs = foldexpr(expr->u.env, expr->lhs);
 		return expr;
 
 	case ASTMT:
 		rhs = expr;
 	advancestmt:
 		lhs = foldexpr(env, lhs);
 		rhs->lhs = lhs;
 
 		if (rhs->rhs) {
 			assert(rhs->rhs->kind == ASTMT);
 			rhs = rhs->rhs, lhs = rhs->lhs;
 			goto advancestmt;
 		}
 
 		return expr;
 
 	case ACOMMA:
 		expr->lhs = foldexpr(env, lhs);
 		expr->rhs = foldexpr(env, rhs);
 		return expr;
 
 	case KSIZEOF:
 	case KALIGNOF:
 	case KLENGTHOF:
 		assert(lhs);
 
 		expr->lhs = NULL;
 		if (expr->kind == KSIZEOF) {
 			expr->u.u = lhs->type->size;
 
 		} else if (expr->kind == KALIGNOF) {
 			expr->u.u = lhs->type->align;
 
 		} else /* if (expr->kind == KLENGTHOF) */ {
 
 			/* @todo add case for slice */
 			if (lhs->type->kind == TARRAY)
 				expr->u.u = lhs->type->u.array.length;
 			else if (lhs->type->kind == TPTR) {
 				expr->u.u = 1;
 			} else {
 				expr->u.u = 0;
 			}
 		}
 
 		deletenode(lhs);
 		/* @todo delete type */
 		expr->type = prim + TUSIZE;
 		expr->kind = NUMBER;
 		return expr;
 
 	case ACONV:
 		/* @todo implement this properly! */
 		lhs = foldexpr(env, lhs);
 		if (lhs->type->kind == expr->type->kind)
 			*expr = *lhs, deletenode(lhs);
 
 		return expr;
 
 	case ADECL:
 		return folddeclaration(env, expr);
 
 	case TYPE:
 		error(&expr->loc, "exptected expression, not type");
 		/* FALLTHROUGH */
 
 	default:
 		return expr;
 	}
 }
 
 
 
 // }}}
 
 // @section data-flow analysis {{{
 
 /*
 In order to do DFA, we divide the code of a scope into sections.
 For each section there will be a DF-Conduct associated with it.
 
 */
 
 Block blockbuf[1024*8];
 int blocktop;
 
 Conduct conductbuf[1024*8];
 int conducttop;
 
 Gist gistbuf[1024*8];
 int gisttop;
 
 static Block *
 makeblock(BlockKind kind, Env *env)
 {
 	Block *block = unpool(blockbuf, blocktop);
 
 	block->kind = kind;
 	block->env  = env;
 
 	return block;
 }
 
 static Conduct *
 makeconduct(ConductKind kind, Node *label)
 {
 	Conduct *conduct = unpool(conductbuf, conducttop);
 
 	conduct->kind  = kind;
 	conduct->label = label;
 
 	return conduct;
 }
 
 static void
 transfergists(Conduct *source, Conduct *dest);
 
 static void
 appendconduct(Block *parent, ConductKind kind, Node *label)
 {
 	Conduct *conduct = makeconduct(kind, label);
 
 	if (!parent)
 		return;
 
 	conduct->parent = parent;
 
 	listappend(parent, conduct);
 
 	if (conduct->prev)
 		transfergists(conduct->prev, conduct);
 }
 
 static void
 appendblock(Conduct *parent, BlockKind kind, Env *env)
 {
 	Block *block = makeblock(kind, env);
 
 	appendconduct(block, CSCOPE, NULL);
 
 	if (!parent)
 		return;
 
 	block->parent = parent;
 
 	listappend(parent, block);
 
 	transfergists(parent, block->tail);
 }
 
 static Gist *
 makegist(Decl *decl, Node *where, bool init)
 {
 	Gist *gist = unpool(gistbuf, gisttop);
 
 	gist->decl = decl;
 	gist->where = where;
 	gist->init = init;
 
 	return gist;
 }
 
 static void
 appendgist(Conduct *conduct, Gist *info)
 {
 	info->parent = conduct;
 
 	listappendex(conduct, info, gists.head, gists.tail, prev, next);
 }
 
 static void
 transfergists(Conduct *source, Conduct *dest)
 {
 	Gist *info;
 
 	for (info = source->gists.head; info; info = info->next) {
 		Gist *copy = makegist(NULL, NULL, false);
 
 		*copy = *info;
 
 		appendgist(dest, copy);
 	}
 }
 
 static Gist *
 getgist(Conduct *conduct, Decl *decl)
 {
 	Gist *probe;
 	assert(conduct);
 
 	for (probe = conduct->gists.head; probe; probe = probe->next) {
 		if (probe->decl == decl)
 			return probe;
 	}
 
 	return NULL;
 }
 
 static void
 gistread(Conduct *conduct, Node *node)
 {
 	const char *name;
 	Decl *decl;
 	Gist *info;
 
 	if (!node || (node->kind != ADECLREF && node->kind != ADECL))
 		return;
 
 	decl = node->u.declref;
 
 	/* @note additional checks require that this moves
 	 *              somewhere else. */
 	if ( decl->kind == DPARAM ||
 	    (decl->kind == DVAR   &&
 	     decl->parentenv      &&
 	     decl->parentenv->kind == STOPLEVEL))
 		return;
 
 	name = getstring(idents, decl->key);
 	info = getgist(conduct, decl);
 
 	if (info) {
 		Node *where = info->where;
 
 		if (info->init)
 			return;
 
 		assert(where);
 		error(&node->loc, "use of un-initialized '%s'.", name);
 		/* @todo change to notice or similiar,
 		 *              instead of warn */
 		warn(&where->loc, "last use of '%s' was here.", name);
 	} else {
 		error(&node->loc, "use of un-initialized '%s'.", name);
 	}
 }
 
 static void
 gistwrite(Conduct *conduct, Node *node, bool init)
 {
 	Decl *decl;
 	Gist *info;
 
 	if (!node || (node->kind != ADECLREF && node->kind != ADECL))
 		return;
 
 	decl = node->u.declref;
 
 	info = getgist(conduct, decl);
 	if (!info) {
 		info = makegist(decl, node, init);
 		appendgist(conduct, info);
 		return;
 	}
 
 	info->init = init;
 	info->where = node;
 }
 
 static void
 fetchblocks(Block *block, Node *expr);
 
 static void
 fetchscoped(Conduct *conduct, Node *expr, BlockKind kind)
 {
 	if (expr && expr->kind == ASCOPE) {
 		appendblock(conduct, kind, expr->u.env);
 		fetchblocks(conduct->tail, expr->lhs);
 
 	} else if (expr) {
 		assert(conduct->parent);
 		assert(conduct->parent->env);
 
 		appendblock(conduct, kind, conduct->parent->env);
 		fetchblocks(conduct->tail, expr);
 	}
 }
 
 static void
 fetchblocks(Block *block, Node *expr)
 {
 	Node *lhs, *rhs;
 
 	assert(expr);
 	assert(block);
 	assert(block->tail);
 
 	lhs = expr->lhs;
 	rhs = expr->rhs;
 
 	switch (expr->kind) {
 	/* unary read */
 	case ODEREF:
 	case OPLUS: case OMINUS:
 	case OBNOT:
 	case OLNOT:
 	case OCAST:
 		fetchblocks(block, lhs);
 		gistread(block->tail, lhs);
 		return;
 
 	/* unary read/write */
 	case OINC: case ODEC:
 	case OSUFINC: case OSUFDEC:
 		fetchblocks(block, lhs);
 		gistread(block->tail, lhs);
 		gistwrite(block->tail, lhs, true);
 		return;
 
 	/* binary read */
 	case OMUL: case ODIV: case OMOD:
 	case OADD: case OSUB:
 	case OBAND: case OBOR: case OXOR:
 	case OLSH: case ORSH: case OARSH:
 	case OEQU: case ONEQ:
 	case OLET: case OLEQ:
 	case OGRT: case OGEQ:
 	case OLAND: case OLOR:
 		fetchblocks(block, lhs);
 		gistread(block->tail, lhs);
 
 		fetchblocks(block, rhs);
 		gistread(block->tail, rhs);
 		return;
 
 
 	/* binary write */
 	case OASS:
 		fetchblocks(block, rhs);
 		gistread(block->tail, rhs);
 
 		fetchblocks(block, lhs);
 		gistwrite(block->tail, lhs, true);
 		return;
 
 	/* binary read/write */
 	case OMULA: case ODIVA: case OMODA:
 	case OADDA: case OSUBA:
 	case OLSHA: case ORSHA: case OARSHA:
 	case OANDA:
 	case OORA: case OXORA:
 		fetchblocks(block, rhs);
 		gistread(block->tail, rhs);
 
 		fetchblocks(block, lhs);
 		gistread(block->tail, lhs);
 		gistwrite(block->tail, lhs, true);
 		return;
 
 	case ASTMT:
 	advancestmt:
 		assert(lhs);
 
 		fetchblocks(block, lhs);
 
 		if (expr->rhs) {
 			assert(expr->rhs->kind == ASTMT);
 			expr = expr->rhs, lhs = expr->lhs;
 			goto advancestmt;
 		}
 		return;
 
 	case ADECL:
 		assert(expr->u.declref);
 		lhs = expr->u.declref->u.content;
 
 		if (expr->u.declref->kind == DFUNCTION) {
 			fetchscoped(block->tail, lhs, BFUNCTION);
 			appendconduct(block, CSCOPE, NULL);
 		} else if (lhs) {
 			appendblock(block->tail, BSCOPE, expr->u.env);
 			fetchblocks(block->tail->tail, lhs);
 			appendconduct(block, CSCOPE, NULL);
 		}
 
 		gistwrite(block->tail, expr, !!lhs);
 		return;
 
 	case ASCOPE:
 		assert(lhs);
 
 		appendblock(block->tail, BSCOPE, expr->u.env);
 		fetchblocks(block->tail->tail, lhs);
 		appendconduct(block, CSCOPE, NULL);
 		return;
 
 	case ACOMMA:
 		assert(lhs);
 		assert(rhs);
 
 		/* @note is this correct? */
 		fetchblocks(block, lhs);
 		fetchblocks(block, rhs);
 		return;
 
 	case KIF:
 		assert(lhs);
 		assert(expr->u.payload);
 
 		fetchscoped(block->tail, lhs, BIF);
 		if (rhs)
 			fetchscoped(block->tail, rhs, BELSE);
 
 		appendconduct(block, CSCOPE, NULL);
 		return;
 
 	case KDO:
 		return;
 
 	case KLOOP:
 		return;
 
 	case ALOOPUNTIL:
 		return;
 
 	case KBREAK:
 		block->tail->doesbreak = true;
 		goto joinctrltransfer;
 
 	case KCONTINUE:
 		block->tail->doescontinue = true;
 		goto joinctrltransfer;
 
 	case KRETURN:
 		block->tail->doesreturn = true;
 		goto joinctrltransfer;
 
 	case KGOTO:
 		block->tail->doesjump = true;
 	joinctrltransfer:
 		appendconduct(block, CUNREACH, NULL);
 		return;
 
 	default:
 	case OADDR:
 		return;
 	}
 }
 
 #if 0
 static void
 debugprintconduct(Conduct *conduct, int indent);
 
 static void
 debugprintblock(Block *block, int indent)
 {
 	Block *curr;
 	assert(block);
 
 	for (curr = block; curr; curr = curr->next) {
 		int i;
 
 		for (i = 0; i < indent; ++i) {
 			printf("\t");
 		}
 
 		switch (curr->kind) {
 		case BTOPLEVEL: printf("\x1b[31mblock<toplevel>\x1b[0m\n"); break;
 		case BFUNCTION: printf("\x1b[31mblock<function>\x1b[0m\n"); break;
 		case BSCOPE: printf("\x1b[31mblock<scope>\x1b[0m\n"); break;
 		case BIF: printf("\x1b[31mblock<if>\x1b[0m\n"); break;
 		case BLOOP: printf("\x1b[31mblock<loop>\x1b[0m\n"); break;
 		case BWHILELOOP: printf("\x1b[31mblock<while-loop>\x1b[0m\n"); break;
 		case BLOOPUNTIL: printf("\x1b[31mblock<loop-until>\x1b[0m\n"); break;
 		case BFORLOOP: printf("\x1b[31mblock<for-loop>\x1b[0m\n"); break;
 		case BELSE: printf("\x1b[31mblock<else>\x1b[0m\n"); break;
 		}
 
 		if (curr->head)
 			debugprintconduct(curr->head, indent);
 	}
 }
 
 static void
 debugprintconduct(Conduct *conduct, int indent)
 {
 	Conduct *curr;
 	assert(conduct);
 
 	for (curr = conduct; curr; curr = curr->next) {
 		int i;
 
 		for (i = 0; i < indent; ++i) {
 			printf("\t");
 		}
 
 		switch (curr->kind) {
 		case CUNREACH: printf("\x1b[34mconduct<unreach>\x1b[0m\n"); break;
 		case CSCOPE: printf("\x1b[34mconduct<scope>\x1b[0m\n"); break;
 		case CLABEL: printf("\x1b[34mconduct<label>\x1b[0m\n"); break;
 		case CBLOCK:
 			break;
 		}
 
 		if (curr->head)
 			debugprintblock(curr->head, indent + 1);
 	}
 }
 #else
 static void
 debugprintblock(Block *block, int indent)
 {
 	(void) block;
 	(void) indent;
 }
 #endif
 
 static void
 dataflow(Block *block, Node *expr)
 {
 	assert(expr);
 
 	fetchblocks(block, expr);
 
 	debugprintblock(block, 0);
 }
 
 
 
 /* @section data-flow analysis version 2 */
 
 #if 0
 
 static void
 fetchsections(Analysis *analysis, Node *expr)
 {
 	Node *lhs, *rhs;
 
 nextnode:
 	switch (expr->kind) {
 	default:
 		break;
 	}
 }
 
 static void
 dataflow2(Analysis *analysis, Node *expr)
 {
 	assert(expr);
 
 	fetchsections(analysis, expr);
 }
 
 #endif
 
 
 
 // }}}
 
 
 // @section extract nested functions {{{
 
 Node *extracted[1024 * 4];
 int extractedtop = 0;
 
 static bool
 isnestedfunction(Env *startenv)
 {
 	Env *env;
 	int n = 0;
 
 	for (env = startenv; env; env = env->below) {
 		if (env->kind == SFUNCTION)
 			++n;
 	}
 	
 	return n > 1;
 }
 
 static void
 extractnfs(Env *env, Node *expr);
 
 static void
 substituenfs(Env *env, Node *expr)
 {
 	Decl *decl = expr->u.declref;
 	Node *enlist = NULL;
 
 	assert(decl);
 
 	if (decl->u.content) {
 		env = decl->contentenv ? decl->contentenv : env;
 		extractnfs(env, decl->u.content);
 	}
 
 	if (decl->kind == DFUNCTION && isnestedfunction(decl->contentenv)) {
 		enlist = makenode(expr, NULL);
 		expr->kind = ADECLREF;
 
 		assert(extractedtop < lengthof(extracted));
 		extracted[extractedtop++] = enlist;
 	}
 }
 
 static void
 extractnfs(Env *env, Node *expr)
 {
 advance:
 	assert(expr);
 
 	if (isoperator(expr->kind)) {
 		switch (getnumops(expr->kind)) {
 		case 3:
 			assert(expr->u.payload);
 			extractnfs(env, expr->u.payload);
 			/* FALLTHROUGH */
 		case 2:
 			assert(expr->rhs);
 			extractnfs(env, expr->rhs);
 			/* FALLTHROUGH */
 		case 1:
 			assert(expr->lhs);
 			extractnfs(env, expr->lhs);
 		}
 		return;
 	}
 
 	switch (expr->kind) {
 	case KRETURN:
 	case KIF:
 	case KCASE:
 	case KOF:
 	case KDO:
 	case KFOR:
 	case KLOOP:
 	case KWHILE:
 	case KUNTIL:
 	case AFORSTEP:
 	case AFOREACH:
 	case ALOOPUNTIL:
 		if (expr->u.payload)
 			extractnfs(env, expr->u.payload);
 		if (expr->lhs)
 			extractnfs(env, expr->lhs);
 		if (expr->rhs) 
 			extractnfs(env, expr->rhs);
 		break;
 	case ADEREF:
 	case ACONV:
 	case ASELFDISP:
 		assert(expr->lhs);
 		extractnfs(env, expr->lhs);
 		break;
 	case ACOMMA:
 		assert(expr->lhs);
 		assert(expr->rhs);
 		extractnfs(env, expr->lhs);
 		extractnfs(env, expr->rhs);
 		break;
 	case ASTMT:
 		assert(expr->lhs);
 		extractnfs(env, expr->lhs);
 		if (expr->rhs) {
 			expr = expr->rhs;
 			goto advance;
 		}
 		break;
 	case ADECL:
 		substituenfs(env, expr);
 		break;
 	case AENV:
 	case ASCOPE:
 		assert(expr->lhs);
 		assert(expr->u.env);
 		extractnfs(expr->u.env, expr->lhs);
 		break;
 	case TYPE: /* @note is this correct? */
 	case CHAR:
 	case NUMBER:
 	case STRING:
 	case ADECLREF:
 	case IDENT: /* @note is this correct? */
 		break;
 
 	case ACOMPOUND:
 		/* @todo extract within type (lhs)? */
 		assert(expr->rhs);
 		extractnfs(env, expr->lhs);
 		break;
 	
 	case AFIELDINIT:
 		assert(expr->rhs);
 		extractnfs(env, expr->rhs);
 		break;
 
 	case KSTRUCT:
 	case KUNION:
 		assert(expr->rhs);
 		extractnfs(env, expr->rhs);
 		break;
 
 	case KBREAK:
 	case KCONTINUE:
 	case KGOTO:
 		break;
 
 	case KSIZEOF:
 	case KALIGNOF:
 		/* @todo check for nested functions and report error */
 		break;
 
 	default:
 		error(&expr->loc, "internal error: unknown expression kind"
 			" (%s).", nodestrings[expr->kind]);
 		break;
 	}
 }
 
 static Node *
 extractnestedfunctions(Env *env, Node *expr)
 {
 	extractedtop = 0;
 
 	extractnfs(env, expr);
 
 	assert(extractedtop < lengthof(extracted));
 	extracted[extractedtop++] = expr;
 	return expr;
 }
 
 // }}}
 
 // @section c code generation {{{
 
 typedef struct CodeGen CodeGen;
 
 struct CodeGen {
 	FILE *out;
 
 	Env *env;
 	int indent, commacount;
 	bool needsvalue, hasclause;
 	const char *valuename;
 };
 
 static void
 codegen(CodeGen *cg, Node *expr);
 
 static void
 cgindent(CodeGen *cg)
 {
 	int i;
 
 	for (i = 0; i < cg->indent; ++i) {
 		fprintf(cg->out, "\t");
 	}
 }
 
 static void
 cgprintf(CodeGen *cg, const char *fmt, ...)
 {
 	va_list ap;
 
 	(void) cg;
 	va_start(ap, fmt);
 	vfprintf(cg->out, fmt, ap);
 	va_end(ap);
 }
 
 static void
 cginit(CodeGen *cg, Env *toplevel, FILE *out)
 {
 	cg->out = out;
 	cg->env = toplevel;
 	cg->indent = 0;
 	cg->commacount = 0;
 	cg->needsvalue = false;
 	cg->hasclause = false;
 	cg->valuename = NULL;
 
 	assert(cg->out);
 	assert(cg->env);
 
 	cgprintf(cg, "#include <assert.h>\n");
 	cgprintf(cg, "#include <stdarg.h>\n");
 	cgprintf(cg, "#include <stdbool.h>\n");
 	cgprintf(cg, "#include <stdint.h>\n");
 	cgprintf(cg, "#include <stdio.h>\n");
 	cgprintf(cg, "#include <stdlib.h>\n");
 	cgprintf(cg, "#include <string.h>\n");
 
 	cgprintf(cg, "typedef int16_t s16;\n");
 	cgprintf(cg, "typedef uint16_t u16;\n");
 	cgprintf(cg, "typedef unsigned int uint;\n");
 	cgprintf(cg, "typedef int64_t s64;\n");
 	cgprintf(cg, "typedef uint64_t u64;\n");
 
 	cgprintf(cg, "\n");
 }
 
 static void
 cgtoplevel(Source *source, Node *ast, CodeGen *cg)
 {
 	if (source->haspendingenv) {
 		assert(source->pendingcount < 512);
 		source->pendingnodes[source->pendingcount++] = ast;
 		source->haspendingenv = false;
 	} else {
 		codegen(cg, ast);
 		if (ast->kind != ADECL || ast->u.declref->kind != DFUNCTION)
 			cgprintf(cg, ";\n");
 		else
 			cgprintf(cg, "\n");
 		/* deletenode(ast); */
 	}
 }
 
 static void
 cgtoplevelfinish(Source *source, CodeGen *cg)
 {
 	int i;
 
 	for (i = 0; i < source->pendingcount; ++i) {
 		Node *ast = source->pendingnodes[i];
 
 		codegen(cg, ast);
 		if (ast->kind != ADECL || ast->u.declref->kind != DFUNCTION)
 			cgprintf(cg, ";\n");
 		else
 			cgprintf(cg, "\n");
 		/* deletenode(ast); */
 	}
 }
 
 #if 0
 static void
 cgtypetail(CodeGen *cg, Type *type)
 {
 	if (!type)
 		return;
 
 	if (type->kind == TFUNCTION) {
 		cgtypetail(cg, type->u.rtarget);
 		cgprintf(cg, " function(");
 		if (type->target)
 			cgtypetail(cg, type->target);
 		cgprintf(cg, ")");
 		return;
 	}
 
 	if (type->kind != TTUPLE && type->target &&
 	    type->target->kind == TTUPLE)
 	{
 		cgprintf(cg, "(");
 		cgtypetail(cg, type->target);
 		cgprintf(cg, ")");
 	} else {
 		cgtypetail(cg, type->target);
 	}
 
 	if (type->module) {
 		cgprintf(cg, "%s", getstring(idents, type->module->key));
 		return;
 	}
 
 	switch (type->kind) {
 	case TARRAY:
 		cgprintf(cg, "[");
 
 		/* @note the value may be always set in the future */
 		if (type->u.val)
 			codegen(cg, type->u.val);
 
 		cgprintf(cg, "]");
 		break;
 
 	case TTUPLE:
 		cgprintf(cg, ", ");
 		if (type->u.rtarget && type->u.rtarget->kind == TTUPLE) {
 			cgprintf(cg, "(");
 			cgtypetail(cg, type->u.rtarget);
 			cgprintf(cg, ")");
 		} else {
 			cgtypetail(cg, type->u.rtarget);
 		}
 
 		break;
 
 	default:;
 	}
 
 	return;
 }
 
 static void
 cgbasetype(CodeGen *cg, Type *type)
 {
 	while (type->target)
 		type = type->target;
 
 	switch (type->kind) {
 	#define typecase(type, str) \
 		case type: cgprintf(cg, str); break
 	typecase(TERRTYPE,   "<error-type>");
 	typecase(TUNDEFINED, "<undefined-type>");
 	typecase(TPTR,       "*");
 	typecase(TVOID,      "void" ); typecase(TBOOL,   "bool"  );
 	typecase(TINFER,     "infer"); typecase(TUINFER, "uinfer");
 	typecase(TS8,        "char" ); typecase(TU8,     "uchar" );
 	typecase(TS16,       "s16"  ); typecase(TU16,    "u16"   );
 	typecase(TS32,       "int"  ); typecase(TU32,    "uint"  );
 	typecase(TS64,       "s64"  ); typecase(TU64,    "u64"   );
 	typecase(TF32,       "float"); typecase(TF64,    "double");
 	#undef typecase
 	default:
 		cgprintf(cg, "<unknown-type-%d>", type->kind);
 	}
 }
 #endif
 
 static void
 cgtype(CodeGen *cg, Type *type, Decl *decl);
 
 static void
 cgnamedparams(CodeGen *cg, Decl *decl)
 {
 	Decl *param, *head = NULL;
 
 	cgprintf(cg, "(");
 
 	if (decl->contentenv) {
 		head = decl->contentenv->head;
 	}
 
 	for (param = head; param; param = param->next) {
 		if (param->kind != DPARAM)
 			break;
 
 		if (param != head) {
 			cgprintf(cg, ", ");
 		}
 
 		++cg->indent;
 		cgtype(cg, param->type, param);
 		--cg->indent;
 	}
 
 	cgprintf(cg, ")");
 }
 
 static void
 cgdeclmodule(CodeGen *cg, Decl *module)
 {
 	if (module->module)
 		cgdeclmodule(cg, module->module);
 
 	cgprintf(cg, "%s_", getstring(idents, module->key));
 }
 
 static void
 cgdeclname(CodeGen *cg, Decl *decl)
 {
 	if (decl->module)
 		cgdeclmodule(cg, decl->module);
 
 	cgprintf(cg, "%s", getstring(idents, decl->key));
 }
 
 static void
 cgbasetype(CodeGen *cg, Type *type)
 {
 	switch (type->kind) {
 	#define typecase(type, str) \
 		case type: cgprintf(cg, str); break
 	typecase(TERRTYPE,   "<error-type>");
 	typecase(TUNDEFINED, "<undefined-type>");
 	typecase(TPTR,       "*");
 	typecase(TVOID,      "void" ); typecase(TBOOL,   "bool"  );
 	typecase(TINFER,     "infer"); typecase(TUINFER, "uinfer");
 	typecase(TS8,        "char" ); typecase(TU8,     "uchar" );
 	typecase(TS16,       "s16"  ); typecase(TU16,    "u16"   );
 	typecase(TS32,       "int"  ); typecase(TU32,    "uint"  );
 	typecase(TS64,       "s64"  ); typecase(TU64,    "u64"   );
 	typecase(TF32,       "float"); typecase(TF64,    "double");
 	#undef typecase
 
 	case TUNION:
 		cgprintf(cg, "union ");
 		goto joinstruct;
 
 	case TSTRUCT:
 		cgprintf(cg, "struct ");
 	joinstruct:
 		assert(type->module);
 		cgdeclname(cg, type->module);
 		break;
 
 	default:
 		cgprintf(cg, "<unknown-type-%d>", type->kind);
 	}
 }
 
 static void
 cgtype(CodeGen *cg, Type *type, Decl *decl)
 {
 	Type *stack[64];
 	Type *post[64];
 	int top = 0, pcount = 0;
 
 	while (type->target || type->kind == TFUNCTION) {
 		assert(top < lengthof(stack));
 		stack[top++] = type;
 		if (type->kind == TFUNCTION) {
 			assert(type->u.rtarget);
 			type = type->u.rtarget;
 		} else {
 			type = type->target;
 		}
 	}
 
 	if (cg->commacount)
 		goto decorate;
 
 	cgbasetype(cg, type);
 	cgprintf(cg, " ");
 
 decorate:
 	while (top > 0) {
 		Type *curr = stack[--top];
 		if (curr->kind == TPTR) {
 			Type *target = curr->target;
 			if (target->kind != TPTR && target->target) {
 				cgprintf(cg, "(*");
 				assert(pcount < lengthof(post));
 				post[pcount++] = curr;
 			} else {
 				cgprintf(cg, "*");
 			}
 #if 0
 			if (target->isconst)
 				cgprintf(cg, "const ");
 #endif
 		} else {
 			assert(pcount < lengthof(post));
 			post[pcount++] = curr;
 		}
 	}
 
 	if (decl)
 		cgdeclname(cg, decl);
 
 
 	while (pcount > 0) {
 		Type *curr = post[--pcount];
 		switch (curr->kind) {
 		case TPTR:
 			cgprintf(cg, ")");
 			continue;
 		case TARRAY:
 			cgprintf(cg, "[");
 			codegen(cg, curr->u.val);
 			cgprintf(cg, "]");
 			continue;
 		case TFUNCTION:
 			if (decl && decl->kind == DFUNCTION) {
 				/* print named or empty parameter list */
 				cgnamedparams(cg, decl);
 				/* Only the innermost function is referred
 				 * by decl. So we can set decl to NULL. */
 				decl = NULL;
 			} else if (curr->target
 			       &&  curr->target->kind == TTUPLE) {
 				Type *tuple = curr->target;
 				/* print anonymous parameter list */
 				cgprintf(cg, "(");
 				for (;;) {
 					assert(tuple->target);
 					cgtype(cg, tuple->target, NULL);
 					cgprintf(cg, ", ");
 
 					assert(tuple->u.rtarget);
 					tuple = tuple->u.rtarget;
 					if (tuple->kind != TTUPLE) {
 						cgtype(cg, tuple, NULL);
 						break;
 					}
 				}
 				cgprintf(cg, ")");
 			} else {
 				/* print empty parameter list */
 				cgprintf(cg, "()");
 			}
 		default:
 			continue;
 		}
 	}
 }
 
 static void
 cgnumber(CodeGen *cg, Node *expr)
 {
 	switch (expr->type->kind) {
 	case TF32: case TF64:
 	/* case TLDOUBLE: */
 		cgprintf(cg, "%f", expr->u.d);
 		if (expr->type->kind == TF32)
 			cgprintf(cg, "f");
 		break;
 
 	case TINFER:
 	case TS8:  case TS16: case TS32: case TS64:
 		cgprintf(cg, "%lli", expr->u.s);
 		break;
 
 	case TUINFER:
 	case TU8:  case TU16: case TU32: case TU64:
 		cgprintf(cg, "%llu", expr->u.s);
 		break;
 
 	case TBOOL:
 		if (expr->u.u == 0)
 			cgprintf(cg, "false");
 		else if (expr->u.u == 1)
 			cgprintf(cg, "true");
 		else
 			cgprintf(cg, "((bool) 0x%016llx)", expr->u.u);
 		break;
 
 	case TPTR:
 		if (expr->u.u == 0)
 			cgprintf(cg, "NULL");
 		else
 			cgprintf(cg, "((void *) 0x%016llx)", expr->u.u);
 		break;
 
 	case TVOID:
 	default:
 		cgprintf(cg, "---");
 		break;
 
 	}
 
 }
 
 static void
 cgdeclaration(CodeGen *cg, Node *expr)
 {
 	Decl *decl = expr->u.declref;
 
 	assert(decl);
 	assert(expr->type);
 
 	cgtype(cg, expr->type, decl);
 
 	if (decl->kind == DFUNCTION) {
 		if (!decl->u.content)
 			return;
 
 		cgprintf(cg, "\n");
 		cgindent(cg);
 		cgprintf(cg, "{\n");
 		
 		++cg->indent;
 		codegen(cg, decl->contentenv->stmts);
 		--cg->indent;
 		
 		cgindent(cg);
 		cgprintf(cg, "}\n");
 		cg->hasclause = true;
 	} else if (decl->kind == DPARAM || decl->kind == DVAR) {
 		if (decl->parentenv->kind == SUNION
 		||  decl->parentenv->kind == SSTRUCT)
 			return;
 		cgprintf(cg, " = ");
 
 		/* @todo remove condition. it is only for testing structs.
 		 *       content may not be NULL otherwise (needs validation) */
 		if (decl->u.content)
 			codegen(cg, decl->u.content);
 	}
 }
 
 static void
 cgsubexpr(CodeGen *cg, Node *expr)
 {
 	if (isatomnode(expr->kind)) {
 		codegen(cg, expr);
 		return;
 	}
 
 	cgprintf(cg, "(");
 	codegen(cg, expr);
 	cgprintf(cg, ")");
 }
 
 static void
 cgunaryprefixop(CodeGen *cg, Node *expr, const char *op)
 {
 	cgprintf(cg, "%s", op);
 	cgsubexpr(cg, expr->lhs);
 }
 
 static void
 cgbinaryop(CodeGen *cg, Node *expr, const char *op)
 {
 	cgsubexpr(cg, expr->lhs);
 	cgprintf(cg, " %s ", op);
 	cgsubexpr(cg, expr->rhs);
 }
 
 static void
 cgprintclause(CodeGen *cg, Node *clause)
 {
 	cgprintf(cg, " {\n");
 	++cg->indent;
 	codegen(cg, clause);
 	--cg->indent;
 	cgindent(cg);
 	cgprintf(cg, "}");
 	cg->hasclause = true;
 }
 
 static void
 codegen(CodeGen *cg, Node *expr)
 {
 	assert(expr);
 
 	switch (expr->kind) {
 	case IDENT:
 		cgprintf(cg, "%s", getstring(idents, expr->u.key));
 		break;
 	case CHAR:
 		/* @todo print char value properly */
 		cgprintf(cg, "'%c'", (uchar) expr->u.u);
 		break;
 	case TYPE:
 		break;
 	case NUMBER:
 		cgnumber(cg, expr);
 		break;
 	case STRING:
 		cgprintf(cg, "\"");
 		do {
 			const int length = getlength(strings, expr->u.key);
 			const char *string = getstring(strings, expr->u.key);
 
 			int i;
 
 			/* @note string must have at least one char
 			 * (null-char at the end) which is not printed */
 			assert(length);
 			for (i = 0; i < length - 1; ++i) {
 				switch (string[i]) {
 				case '\\':
 					cgprintf(cg, "\\\\");
 					break;
 				case '"':
 					cgprintf(cg, "\\\"");
 					break;
 				case '\n':
 					cgprintf(cg, "\\n");
 					break;
 				case '\t':
 					cgprintf(cg, "\\t");
 					break;
 				case '\r':
 					cgprintf(cg, "\\r");
 					break;
 				case '\b':
 					cgprintf(cg, "\\b");
 					break;
 				case '\f':
 					cgprintf(cg, "\\f");
 					break;
 				case '\v':
 					cgprintf(cg, "\\v");
 					break;
 				case '\0':
 					cgprintf(cg, "\\0");
 					break;
 				default:
 					cgprintf(cg, "%c", string[i]);
 					break;
 				}
 			}
 		} while (0);
 		cgprintf(cg, "\"");
 		break;
 	case ACOMPOUND:
 		cgprintf(cg, "((");
 		cgbasetype(cg, expr->type);
 		cgprintf(cg, ") {");
 		++cg->indent;
 		codegen(cg, expr->rhs);
 		--cg->indent;
 		cgindent(cg);
 		cgprintf(cg, "})");
 		break;
 	case AFIELDINIT:
 		codegen(cg, expr->rhs);
 		break;
 	case KTRUE:
 		cgprintf(cg, "true");
 		break;
 	case KFALSE:
 		cgprintf(cg, "false");
 		break;
 	case KNULL:
 		cgprintf(cg, "NULL");
 		break;
 	case KSIZEOF:
 		break;
 	case KALIGNOF:
 		break;
 	case KLENGTHOF:
 		break;
 	case ADECLREF:
 		cgdeclname(cg, expr->u.declref);
 		break;
 	case ALABEL:
 	case ASWITCH:
 	case ACASE:
 		break;
 	case ACONV:
 		codegen(cg, expr->lhs);
 		break;
 	case ASCOPE:
 		do {
 			Node *curr = expr->lhs;
 			while (curr) {
 				cgindent(cg);
 				codegen(cg, curr);
 				if (curr->kind == ASTMT)
 					curr = curr->rhs;
 				else
 					break;
 			}
 		} while (0);
 		break;
 	case AENV:
 		assert(expr->lhs);
 		codegen(cg, expr->lhs);
 		break;
 	case ASTMT:
 		cg->hasclause = false;
 		codegen(cg, expr->lhs);
 		if (!cg->hasclause)
 			cgprintf(cg, "; /* statement */\n");
 		cg->hasclause = false;
 		break;
 	case ADECL:
 		cgdeclaration(cg, expr);
 		break;
 	case OSUFINC:
 		cgsubexpr(cg, expr->lhs);
 		cgprintf(cg, "++");
 		break;
 	case OSUFDEC:
 		cgsubexpr(cg, expr->lhs);
 		cgprintf(cg, "++");
 		break;
 	case OARRAY:
 		cgsubexpr(cg, expr->lhs);
 		cgprintf(cg, "[");
 		codegen(cg, expr->rhs);
 		cgprintf(cg, "]");
 		break;
 	case ODISP:
 		cgsubexpr(cg, expr->lhs);
 		cgprintf(cg, ".");
 		codegen(cg, expr->rhs);
 		break;
 	case OCALL:
 		cgsubexpr(cg, expr->lhs);
 		cgprintf(cg, "(");
 		if (expr->rhs)
 			codegen(cg, expr->rhs);
 		cgprintf(cg, ")");
 		break;
 	case OADDR:
 	case AADDR:
 		cgunaryprefixop(cg, expr, "&");
 		break;
 	case ODEREF:
 	case ADEREF:
 		cgunaryprefixop(cg, expr, "*");
 		break;
 	case OINC:
 		cgunaryprefixop(cg, expr, "++");
 		break;
 	case ODEC:
 		cgunaryprefixop(cg, expr, "--");
 		break;
 	case OBNOT:
 		cgunaryprefixop(cg, expr, "~");
 		break;
 	case OLNOT:
 		cgunaryprefixop(cg, expr, "!");
 		break;
 	case OPLUS:
 		cgunaryprefixop(cg, expr, "+");
 		break;
 	case OMINUS:
 		cgunaryprefixop(cg, expr, "-");
 		break;
 	case OCAST:
 		/* @todo implement c version correctly */
 		cgprintf(cg, "(");
 		codegen(cg, expr->lhs);
 		cgprintf(cg, ")");
 		break;
 	case OMUL:
 		cgbinaryop(cg, expr, "*");
 		break;
 	case ODIV:
 		cgbinaryop(cg, expr, "/");
 		break;
 	case OMOD:
 		cgbinaryop(cg, expr, "%");
 		break;
 	case OBAND:
 		cgbinaryop(cg, expr, "&");
 		break;
 	case OLSH:
 		cgbinaryop(cg, expr, "<<");
 		break;
 	case OARSH:
 		/* @todo implement c version correctly */
 		cgbinaryop(cg, expr, ">>>");
 		break;
 	case ORSH:
 		cgbinaryop(cg, expr, ">>");
 		break;
 	case OADD:
 		cgbinaryop(cg, expr, "+");
 		break;
 	case OSUB:
 		cgbinaryop(cg, expr, "-");
 		break;
 	case OBOR:
 		cgbinaryop(cg, expr, "|");
 		break;
 	case OXOR:
 		cgbinaryop(cg, expr, "^");
 		break;
 	case OFLIP:
 	case ORANGE:
 		/* @todo implement c version correctly */
 		cgbinaryop(cg, expr, "~");
 		break;
 	case OLEQ:
 		cgbinaryop(cg, expr, "<=");
 		break;
 	case OLET:
 		cgbinaryop(cg, expr, "<");
 		break;
 	case OGEQ:
 		cgbinaryop(cg, expr, ">=");
 		break;
 	case OGRT:
 		cgbinaryop(cg, expr, ">");
 		break;
 	case ONEQ:
 		cgbinaryop(cg, expr, "!=");
 		break;
 	case OEQU:
 		cgbinaryop(cg, expr, "==");
 		break;
 	case OIDENT:
 		/* @todo implement c version correctly */
 		cgbinaryop(cg, expr, "==");
 		break;
 	case OLAND:
 		cgbinaryop(cg, expr, "&&");
 		break;
 	case OLOR:
 		cgbinaryop(cg, expr, "||");
 		break;
 	case OASS:
 		cgbinaryop(cg, expr, "=");
 		break;
 	case OMULA:
 		cgbinaryop(cg, expr, "*=");
 		break;
 	case ODIVA:
 		cgbinaryop(cg, expr, "/=");
 		break;
 	case OMODA:
 		cgbinaryop(cg, expr, "%=");
 		break;
 	case OLSHA:
 		cgbinaryop(cg, expr, "<<=");
 		break;
 	case OARSHA:
 		/* @todo implement c version correctly */
 		cgbinaryop(cg, expr, ">>>=");
 		break;
 	case ORSHA:
 		cgbinaryop(cg, expr, ">>=");
 		break;
 	case OANDA:
 		cgbinaryop(cg, expr, "&=");
 		break;
 	case OADDA:
 		cgbinaryop(cg, expr, "+=");
 		break;
 	case OSUBA:
 		cgbinaryop(cg, expr, "-=");
 		break;
 	case OXORA:
 		cgbinaryop(cg, expr, "^=");
 		break;
 	case OORA:
 		cgbinaryop(cg, expr, "|=");
 		break;
 	case KBREAK:
 		cgprintf(cg, "break");
 		break;
 	case KCONTINUE:
 		cgprintf(cg, "continue");
 		break;
 	case KGOTO:
 		cgprintf(cg, "goto %s", getstring(idents, expr->u.key));
 		break;
 	case KRETURN:
 		cgprintf(cg, "return ");
 		if (expr->rhs)
 			codegen(cg, expr->rhs);
 		break;
 	case KWHILE:
 		cgprintf(cg, "while (");
 		goto joinif;
 	case KFOR:
 		cgprintf(cg, "for (");
 		goto joinif;
 	case KIF:
 		cgprintf(cg, "if (");
 	joinif:
 		if (expr->u.payload)
 			codegen(cg, expr->u.payload);
 		cgprintf(cg, ") ");
 		if (expr->lhs)
 			cgprintclause(cg, expr->lhs);
 		if (expr->rhs) {
 			cgprintf(cg, " else ");
 			cgprintclause(cg, expr->rhs);
 		}
 		cgprintf(cg, "\n");
 		break;
 	case AFORSTEP:
 		assert(expr->lhs);
 		assert(expr->rhs);
 		assert(expr->u.payload);
 		assert(expr->lhs->kind == ADECL || expr->lhs->kind == ADECLREF);
 		codegen(cg, expr->lhs);
 		cgprintf(cg, "; %s < (", getstring(idents, expr->lhs->u.declref->key));
 		codegen(cg, expr->rhs);
 		cgprintf(cg, "); %s += (", getstring(idents, expr->lhs->u.declref->key));
 		codegen(cg, expr->u.payload);
 		cgprintf(cg, ")");
 		break;
 	case AFOREACH:
 		break;
 	case KLOOP:
 		cgprintf(cg, "for (;;) ");
 		if (expr->lhs)
 			cgprintclause(cg, expr->lhs);
 		/* @todo implement else-case properly? */
 		/* @note else-clause might be useless for an infinite loop */
 		/*
 		if (expr->rhs) {
 			cgprintf(cg, " else ");
 			cgprintclause(cg, expr->rhs);
 		}
 		*/
 		cgprintf(cg, "\n");
 		break;
 	case ALOOPUNTIL:
 		cgprintf(cg, "do ");
 		if (expr->lhs)
 			cgprintclause(cg, expr->lhs);
 		cgprintf(cg, " while (!(");
 		if (expr->u.payload)
 			codegen(cg, expr->u.payload);
 		cgprintf(cg, "));\n");
 		/* @todo implement else-case properly */
 		/*
 		if (expr->rhs) {
 			cgprintf(cg, " else ");
 			cgprintclause(cg, expr->rhs);
 		}
 		*/
 		break;
 	case KCASE:
 	case KOF:
 	case KDO:
 	case KUNTIL:
 		/* @todo implement c version correctly */
 		break;
 	case ACOMMA:
 		codegen(cg, expr->lhs);
 		cgprintf(cg, ", ");
 		++cg->commacount;
 		codegen(cg, expr->rhs);
 		--cg->commacount;
 		break;
 	case KUNION:
 		cgprintf(cg, "union ");
 		goto joinstruct;
 	case KSTRUCT:
 		cgprintf(cg, "struct ");
 
 	joinstruct:
 		assert(expr->type);
 		if (expr->type->module)
 			cgdeclname(cg, expr->type->module);
 
 		cgprintf(cg, " {\n");
 		++cg->indent;
 		if (expr->rhs)
 			codegen(cg, expr->rhs);
 		--cg->indent;
 		cgindent(cg);
 		cgprintf(cg, "}");
 		break;
 	case INVALID:
 	case LINEDELIM:
 	case SEMIDELIM:
 	case COMMADELIM:
 	case COLONDELIM:
 	case LCURLDELIM:
 	case LSQRDELIM:
 	case LPARDELIM:
 	case RCURLDELIM:
 	case RSQRDELIM:
 	case RPARDELIM:
 	case ANNOT:
 	case KVOID:
 	case KBOOL:
 	case KU8:
 	case KS8:
 	case KU16:
 	case KS16:
 	case KU32:
 	case KS32:
 	case KU64:
 	case KS64:
 	case KF32:
 	case KF64:
 	case KUCHAR:
 	case KCHAR:
 	case KUSHORT:
 	case KSHORT:
 	case KUINT:
 	case KINT:
 	case KULONG:
 	case KLONG:
 	case KULLONG:
 	case KLLONG:
 	case KFLOAT:
 	case KDOUBLE:
 	case KLDOUBLE:
 	case KUSIZE:
 	case KSSIZE:
 	case KUSE:
 	case KNOT:
 	case KAND:
 	case KOR:
 	case KIS:
 	case KBITCAST:
 	case KEXTERN:
 	case KINTERN:
 	case KSTATIC:
 	case KCONST:
 	case KVAR:
 	case KELSE:
 	case MAXKINDS:
 	case ENDOFFILE:
 		cgprintf(cg, "<not implemented: '%s' ", nodestrings[expr->kind]);
 		if (expr->lhs)
 			codegen(cg, expr->lhs);
 		cgprintf(cg, " ");
 		if (expr->rhs)
 			codegen(cg, expr->rhs);
 		cgprintf(cg, ">");
 		break;
 	}
 }
 
 
 
 // }}}
 
 // @section print ast {{{
 
 static void
 promptenvpath(Env* currenv)
 {
 	const char *envstring = "environment";
 
 	if (currenv && currenv->kind != STOPLEVEL) {
 		promptenvpath(currenv->below);
 
 		switch (currenv->kind) {
 		case SFUNCTION:
 		case SPARAMLIST:
 			envstring = "function";
 			break;
 		case SSTRUCT:
 			envstring = "struct";
 			break;
 		case SUNION:
 			envstring = "union";
 			break;
 		case SSCOPE:
 			envstring = "scope";
 			break;
 		case SIF:
 			envstring = "if";
 			break;
 		case SELSE:
 			envstring = "else";
 			break;
 		case SDO:
 			envstring = "do";
 			break;
 		case SLOOP:
 			envstring = "loop";
 			break;
 		case SWHILE:
 			envstring = "while";
 			break;
 		default:
 			break;
 		}
 
 		if (currenv->envdecl) {
 			int key = currenv->envdecl->key;
 			envstring = getstring(idents, key);
 		}
 
 		fprintf(stdout, "# scope: %s/", envstring);
 	}
 }
 
 static void
 tryprompt(Source *source, const char ch)
 {
 	if (source->handlereplprompt) {
 		Env *currenv = source->currenv;
 
 		if (ch == '.' && currenv && currenv->kind != STOPLEVEL) {
 			fputs("\x1b[1;30m", stdout);
 			promptenvpath(currenv);
 			fprintf(stdout, "\n\x1b[35m%c \x1b[0m", ch);
 		} else {
 			fprintf(stdout, "\x1b[35m%c \x1b[0m", ch);
 		}
 
 	} else if (source->filein == stdin) {
 		source->handlereplprompt = true;
 	}
 }
 
 typedef
 enum Highlight {
 	HLNONE = 0,
 	HLDELIM = 1,
 	HLUNKNOWN = 2,
 	HLKEYWORD = 3,
 	HLNUMBER = 4,
 	HLSTRING = 5,
 	HLTYPE = 6,
 	HLFUNCTION = 7,
 	HLPARAM = 8,
 	#if 0
 	HLFUNCTIONDECL = 9,
 	HLPARAMDECL = 10,
 	HLDECL = 11,
 	#endif
 	HLSPECIAL = 12,
 	HLINFO = 13,
 	HLPROMPT = 14
 } Highlight;
 
 #define HLFUNCTIONDECL HLFUNCTION
 #define HLPARAMDECL HLPARAM
 #define HLDECL HLIDENT
 
 #define HLOP HLDELIM
 #define HLCHAR HLSTRING
 #define HLIDENT HLNONE
 
 Highlight lasthighlight;
 
 static int
 highlight(FILE *out, Highlight kind)
 {
 	int n = 0;
 
 	if (out != stdout)
 		return 0;
 
 	if (lasthighlight == kind)
 		return 0;
 
 	if (kind == HLNONE)
 		return lasthighlight = kind, fprintf(out, "\x1b[0m");
 
 	if (lasthighlight == HLDELIM || kind == HLDELIM ||
 	    lasthighlight == HLFUNCTION || kind == HLFUNCTION ||
 	    lasthighlight == HLPARAM || kind == HLPARAM ||
 	    #if 0
 	    lasthighlight == HLFUNCTIONDECL || kind == HLFUNCTIONDECL ||
 	    lasthighlight == HLPARAMDECL || kind == HLPARAMDECL ||
 	    lasthighlight == HLDECL || kind == HLDECL ||
 	    #endif
 	    lasthighlight == HLSPECIAL ||
 	    lasthighlight == HLUNKNOWN || kind == HLUNKNOWN)
 		n += fprintf(out, "\x1b[0m");
 
 	switch (kind) {
 	case HLDELIM:
 		n += fprintf(out, "\x1b[2m");
 		break;
 
 	case HLUNKNOWN:
 		n += fprintf(out, "\x1b[41;30m");
 		break;
 
 	case HLKEYWORD:
 		n += fprintf(out, "\x1b[35m");
 		break;
 
 	case HLNUMBER:
 		n += fprintf(out, "\x1b[36m");
 		break;
 
 	case HLSTRING:
 		n += fprintf(out, "\x1b[31m");
 		break;
 
 	case HLTYPE:
 		n += fprintf(out, "\x1b[34m");
 		break;
 
 	case HLFUNCTION:
 		n += fprintf(out, "\x1b[1;3m");
 		break;
 
 	case HLPARAM:
 		n += fprintf(out, "\x1b[3m");
 		break;
 
 	#if 0
 	case HLFUNCTIONDECL:
 		n += fprintf(out, "\x1b[1;4;3m");
 		break;
 
 	case HLPARAMDECL:
 		n += fprintf(out, "\x1b[4;3m");
 		break;
 
 	case HLDECL:
 		n += fprintf(out, "\x1b[4m");
 		break;
 	#endif
 
 	case HLSPECIAL:
 		n += fprintf(out, "\x1b[3;36m");
 		break;
 
 	case HLINFO:
 		n += fprintf(out, "\x1b[33m");
 		break;
 
 	case HLPROMPT:
 		n += fprintf(out, "\x1b[35m");
 		break;
 	default:
 		break;
 	}
 
 	lasthighlight = kind;
 	return n;
 }
 
 static int
 printexpr(FILE *out, Node *expr, int indent);
 
 static int
 printtypetail(FILE *out, Type *type, int indent)
 {
 	int n = 0;
 
 	if (!type)
 		return 0;
 
 	if (type->kind == TFUNCTION) {
 		n += printtypetail(out, type->u.rtarget, indent);
 		n += fprintf(out, " function(");
 		if (type->target)
 			n += printtypetail(out, type->target, indent);
 		n += fprintf(out, ")");
 		return n;
 	}
 
 	if (type->kind != TTUPLE && type->target &&
 	    type->target->kind == TTUPLE)
 	{
 		n += fprintf(out, "(");
 		n += printtypetail(out, type->target, indent);
 		n += fprintf(out, ")");
 	} else {
 		n += printtypetail(out, type->target, indent);
 	}
 
 	if (type->module) {
 		n += fprintf(out, "%s", getstring(idents, type->module->key));
 		return n;
 	}
 
 	switch (type->kind) {
 	case TARRAY:
 		n += fprintf(out, "[");
 
 		/* @note the value may be always set in the future */
 		if (type->u.val)
 			n += printexpr(out, type->u.val, indent);
 
 		n += fprintf(out, "]");
 		break;
 
 	case TTUPLE:
 		n += fprintf(out, ", ");
 		if (type->u.rtarget && type->u.rtarget->kind == TTUPLE) {
 			n += fprintf(out, "(");
 			n += printtypetail(out, type->u.rtarget, indent);
 			n += fprintf(out, ")");
 		} else {
 			n += printtypetail(out, type->u.rtarget, indent);
 		}
 
 		break;
 
 	#define typecase(type, str) \
 		case type: n += fprintf(out, str); break
 
 	typecase(TERRTYPE,   "<error-type>");
 	typecase(TUNDEFINED, "<undefined-type>");
 	typecase(TPTR,       "*");
 	typecase(TVOID,      "void" ); typecase(TBOOL,   "bool"  );
 	typecase(TINFER,     "infer"); typecase(TUINFER, "uinfer");
 	typecase(TS8,        "char" ); typecase(TU8,     "uchar" );
 	typecase(TS16,       "s16"  ); typecase(TU16,    "u16"   );
 	typecase(TS32,       "int"  ); typecase(TU32,    "uint"  );
 	typecase(TS64,       "s64"  ); typecase(TU64,    "u64"   );
 	typecase(TF32,       "float"); typecase(TF64,    "double");
 
 	#undef typecase
 	default:;
 	}
 
 	return n;
 }
 
 static int
 printtype(FILE *out, Type *type, int indent)
 {
 	if (type && type->kind == TTUPLE) {
 		int n = 0;
 
 		n += fprintf(out, "(");
 		n += printtypetail(out, type, indent);
 
 		return n + fprintf(out, ")");
 	}
 
 	return printtypetail(out, type, indent);
 }
 
 static int
 printtypesuffix(FILE *out, Type *type)
 {
 	int n = 0;
 
 	if (!type)
 		return 0;
 
 	switch (type->kind) {
 	#define typecase(type, str) \
 		case type: n += fprintf(out, str); break
 
 	typecase(TINFER,     "i"    ); typecase(TUINFER, "u"     );
 	typecase(TS8,        "s8"   ); typecase(TU8,     "u8"    );
 	typecase(TS16,       "s16"  ); typecase(TU16,    "u16"   );
 	typecase(TS32,       "s32"  ); typecase(TU32,    "u32"   );
 	typecase(TS64,       "s64"  ); typecase(TU64,    "u64"   );
 	typecase(TF32,       "f32"  ); typecase(TF64,    "f64"   );
 
 	#undef typecase
 	default:;
 	}
 
 	return n;
 }
 
 static bool
 isclauseorempty(Node *expr)
 {
 	Kind kind;
 
 	while (expr && (expr->kind == ASCOPE || expr->kind == ASTMT))
 		expr = expr->lhs;
 
 	if (!expr)
 		return true;
 
 	kind = expr->kind;
 	return kind == KDO   || kind == KIF     || kind == KFOR   ||
 	       kind == KGOTO || kind == KRETURN || kind == KBREAK ||
 	       kind == KCONTINUE;
 }
 
 static int
 printclause(FILE *out, Node *expr, int indent)
 {
 	int n = 0;
 
 	if (!expr)
 		return 0;
 
 	if (isclauseorempty(expr)) {
 		n += fprintf(out, " ");
 		n += printexpr(out, expr, indent);
 	} else {
 		n += fprintf(out, "\n");
 		n += printexpr(out, expr, indent + 1);
 	}
 
 	return n;
 }
 
 static int
 printstring(FILE *out, Node *string)
 {
 	const char *str = getstring(strings, string->u.key);
 	int len = getlength(strings, string->u.key);
 	int i, n = fprintf(out, "\"");
 
 	for (i = 0; i < len; ++i) {
 		switch (str[i]) {
 		case '\\':
 			n += fprintf(out, "\\\\");
 			break;
 
 		case '\n':
 			n += fprintf(out, "\\n");
 			break;
 
 		case '\r':
 			n += fprintf(out, "\\r");
 			break;
 
 		case '\t':
 			n += fprintf(out, "\\t");
 			break;
 
 		case '\"':
 			n += fprintf(out, "\\\"");
 			break;
 
 		case '\'':
 			n += fprintf(out, "\\\'");
 			break;
 
 		case 0:
 			n += fprintf(out, "\\0");
 			break;
 
 		default:
 			putc(str[i], out);
 			++n;
 		}
 	}
 
 	return n + fprintf(out, "\"");
 }
 
 static int
 printoperant(FILE *out, Node *expr, int opprec, bool braceequalprec, int indent)
 {
 	int prec, n = 0;
 
 	if (!expr)
 		return 0;
 
 	prec = getprec(expr->kind);
 	if (!isatomnode(expr->kind) && (!getnumops(expr->kind) ||
 	     prec < opprec ||
 	    (braceequalprec && prec == opprec))) {
 		n += highlight(out, HLDELIM);
 
 		n += fprintf(out, "(");
 		n += highlight(out, HLNONE);
 		n += printexpr(out, expr, indent);
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, ")");
 
 		n += highlight(out, HLNONE);
 	} else {
 		n += printexpr(out, expr, indent);
 	}
 
 	return n;
 }
 
 static int
 printsubexpr(FILE *out, Node *expr, bool islhs, int indent)
 {
 	int n = 0;
 
 	if (!expr)
 		return 0;
 
 	if ((islhs && expr->kind == ACOMMA) || expr->kind == ADECL)
 		n += printexpr(out, expr, indent);
 	else
 		n += printoperant(out, expr, PSTART, !islhs, indent);
 
 	return n;
 }
 
 static int
 printdeclmodule(FILE *out, Decl *module)
 {
 	int n = 0;
 
 	if (module->module)
 		printdeclmodule(out, module->module);
 
 	if (module->kind == DTYPE) {
 		n += highlight(out, HLTYPE);
 		fprintf(out, "%s", getstring(idents, module->key));
 		n += highlight(out, HLDELIM);
 	} else {
 		n += highlight(out, HLDELIM);
 		fprintf(out, "%s", getstring(idents, module->key));
 	}
 	n += fprintf(out, ".");
 
 	return n;
 }
 
 static int
 printdeclname(FILE *out, Decl *decl, bool isdecl)
 {
 	int n = 0;
 
 	if (decl->module)
 		printdeclmodule(out, decl->module);
 
 	if (isdecl) {
 		n += highlight(out,
 			decl->kind == DFUNCTION ? HLFUNCTIONDECL :
 			decl->kind == DPARAM ? (
 				decl->flags & MSPECIAL ? HLSPECIAL : HLPARAMDECL
 			) : HLDECL);
 	} else {
 		n += highlight(out, decl->kind == DFUNCTION ?
 			HLFUNCTION : decl->kind == DPARAM ? (
 				decl->flags & MSPECIAL ? HLSPECIAL : HLPARAM
 			) : HLIDENT);
 	}
 	n += fprintf(out, "%s", getstring(idents, decl->key));
 
 	return n;
 }
 
 static int
 printdeclaration(FILE *out, Decl *decl, int indent)
 {
 	int n = 0;
 
 	assert(decl);
 
 	n += highlight(out, HLTYPE);
 	if (decl->kind == DFUNCTION) {
 		n += printtype(out, decl->type->u.rtarget, indent);
 	} else {
 		n += printtype(out, decl->type, indent);
 	}
 
 	n += fprintf(out, " ");
 	printdeclname(out, decl, true);
 
 	if (decl->kind == DFUNCTION) {
 		Decl *param, *head = NULL;
 
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, "(");
 
 		if (decl->contentenv) {
 			head = decl->contentenv->head;
 		}
 
 		for (param = head; param; param = param->next) {
 			if (param->kind != DPARAM)
 				break;
 
 			if (param != head) {
 				n += highlight(out, HLDELIM);
 				n += fprintf(out, ", ");
 			}
 
 			n += printdeclaration(out, param, indent + 1);
 		}
 
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, ")");
 
 		if (decl->u.content) {
 			n += fprintf(out, "\n");
 			n += printexpr(out, decl->u.content, indent + 1);
 		}
 	} else if (decl->u.content) {
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, " = ");
 		n += printoperant(out, decl->u.content, PASSIGN, false, indent);
 	}
 
 	return n;
 }
 
 static int
 printexpr(FILE *out, Node *expr, int indent)
 {
 	int n = 0;
 
 	if (expr->kind == 0) {
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "_");
 		return 0;
 	}
 
 	if (getnumops(expr->kind) == 2) {
 		n += printoperant(out, expr->lhs,
 			getprec(expr->kind),
 			israssoc(expr->kind),
 			indent);
 
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, " %s ", nodestrings[expr->kind]);
 
 		n += printoperant(out, expr->rhs,
 			getprec(expr->kind),
 			!israssoc(expr->kind),
 			indent);
 		goto finish;
 	}
 	
 	if (getnumops(expr->kind) == 1) {
 		if (getprec(expr->kind) == PUNSUF) {
 			printoperant(out, expr->lhs, PUNSUF, false, indent);
 
 			switch (expr->kind) {
 			case OARRAY:
 			case OCALL:
 				n += highlight(out, HLDELIM);
 				n += fprintf(out, "%c", nodestrings[expr->kind][0]);
 
 				if (expr->rhs)
 					n += printexpr(out, expr->rhs, indent);
 
 				n += highlight(out, HLDELIM);
 				n += fprintf(out, "%c", nodestrings[expr->kind][1]);
 				break;
 
 			case ODISP:
 				n += highlight(out, HLDELIM);
 				n += fprintf(out, ".");
 				if (expr->rhs && expr->rhs->kind == IDENT) {
 					n += highlight(out, HLIDENT);
 					n += fprintf(out, "%s",
 						getstring(idents, expr->rhs->u.key));
 				} else {
 					/* @note this might be unnecessary */
 					n += printexpr(out, expr->rhs, indent);
 				}
 				break;
 
 			default:
 				n += highlight(out, HLDELIM);
 				n += fprintf(out, "%s", nodestrings[expr->kind]);
 			}
 
 		} else {
 			switch (expr->kind) {
 			case OCAST:
 				n += highlight(out, HLDELIM);
 				putc('(', out), ++n;
 				n += highlight(out, HLTYPE);
 				n += printtype(out, expr->type, indent);
 				n += highlight(out, HLDELIM);
 				putc(')', out), ++n;
 				break;
 
 			default:
 				n += highlight(out, HLDELIM);
 				n += fprintf(out, "%s", nodestrings[expr->kind]);
 
 				if (getprec(expr->lhs->kind) == PUNARY &&
 					expr->kind != ODEREF &&
 					expr->kind != OADDR)
 				{
 					putc(' ', out), ++n;
 				}
 			}
 
 			n += printoperant(out, expr->lhs, PUNARY, false, indent);
 		}
 
 		goto finish;
 	}
 	
 	switch (expr->kind) {
 	case IDENT:
 		n += highlight(out, HLUNKNOWN);
 		n += fprintf(out, "%s?", getstring(idents, expr->u.key));
 		n += highlight(out, HLNONE);
 		break;
 
 	case NUMBER:
 		n += highlight(out, HLNUMBER);
 
 		switch (expr->type->kind) {
 		case TF32: case TF64:
 		/* case TLDOUBLE: */
 			n += fprintf(out, "%f", expr->u.d);
 			n += printtypesuffix(out, expr->type);
 			break;
 
 		case TINFER:
 		case TS8:  case TS16: case TS32: case TS64:
 			n += fprintf(out, "%lli", expr->u.s);
 			n += printtypesuffix(out, expr->type);
 			break;
 
 		case TUINFER:
 		case TU8:  case TU16: case TU32: case TU64:
 			n += fprintf(out, "%llu", expr->u.s);
 			n += printtypesuffix(out, expr->type);
 			break;
 
 		case TBOOL:
 			if (expr->u.u == 0)
 				n += fprintf(out, "false");
 			else if (expr->u.u == 1)
 				n += fprintf(out, "true");
 			else
 				n += fprintf(out, "0x%016llx", expr->u.u);
 
 			break;
 
 		case TPTR:
 			if (expr->u.u == 0)
 				n += fprintf(out, "null");
 			else
 				n += fprintf(out, "0x%016llx", expr->u.u);
 			break;
 
 		case TVOID:
 		default:
 			n += fprintf(out, "---");
 			break;
 
 		}
 
 		break;
 
 	case CHAR:
 		/* @todo print chars correctly */
 		n += highlight(out, HLCHAR);
 		n += fprintf(out, "'%c'", (uchar) expr->u.u);
 		break;
 
 	case STRING:
 		n += highlight(out, HLSTRING);
 		n += printstring(out, expr);
 		break;
 
 	case TYPE:
 		/* @note might be unnecessary (only used for ACOMPOUND) */
 		n += highlight(out, HLTYPE);
 		n += printtype(out, expr->type, indent);
 		break;
 
 	case ADECLREF:
 		printdeclname(out, expr->u.declref, false);
 		break;
 	
 	case ADECL:
 		n += printdeclaration(out, expr->u.declref, indent);
 		break;
 
 	case ACOMMA:
 		n += printsubexpr(out, expr->lhs, true, indent);
 		n += highlight(out, HLDELIM);
 		n += printf(", ");
 		n += printsubexpr(out, expr->rhs, false, indent);
 		break;
 
 	case KSIZEOF:
 	case KALIGNOF:
 	case KLENGTHOF:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "%s", nodestrings[expr->kind]);
 		n += highlight(out, HLDELIM);
 
 		n += fprintf(out, "(");
 		n += printexpr(out, expr->lhs, indent);
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, ")");
 		break;
 
 	case KBITCAST:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "bitcast");
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, "(");
 
 		n += highlight(out, HLTYPE);
 		n += printtype(out, expr->rhs->type, indent);
 		n += highlight(out, HLDELIM);
 
 		n += fprintf(out, ") (");
 		n += printexpr(out, expr->lhs, indent);
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, ")");
 		break;
 
 	case KRETURN:
 		n += highlight(out, HLKEYWORD);
 		if (expr->rhs) {
 			n += fprintf(out, "return ");
 			n += printexpr(out, expr->rhs, indent);
 		} else {
 			n += fprintf(out, "return");
 		}
 		break;
 
 	case KBREAK:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "break");
 		break;
 
 	case KCONTINUE:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "continue");
 		break;
 	case KWHILE:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "while ");
 		goto joinifbody;
 
 	case KFOR:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "for ");
 		goto joinifbody;
 	
 	case AFORSTEP:
 		n += printexpr(out, expr->lhs, indent);
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, " to ");
 		n += printexpr(out, expr->rhs, indent);
 
 		assert(expr->u.payload);
 		if (expr->u.payload->kind == NUMBER && false) {
 			if (isfloattype(expr->u.payload->type)
 			&&  expr->u.payload->u.d == 1.0)
 				break;
 			if (isinttype(expr->u.payload->type)
 			&&  expr->u.payload->u.u == 1)
 				break;
 		}
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, " step ");
 		n += printexpr(out, expr->u.payload, indent);
 		break;
 
 	case KIF:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "if ");
 		/* FALLTHROUGH */
 	joinifbody:
 		n += printexpr(out, expr->u.payload, indent);
 		n += printclause(out, expr->lhs, indent);
 
 		if (expr->rhs) {
 			int i;
 
 			n += fprintf(out, "\n");
 
 			for (i = 0; i < indent; ++i)
 				n += fprintf(out, "\t");
 
 			n += highlight(out, HLKEYWORD);
 			n += fprintf(out, "else");
 			n += printclause(out, expr->rhs, indent);
 		}
 		break;
 
 	case KLOOP:
 	case ALOOPUNTIL:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "loop");
 		n += printclause(out, expr->lhs, indent);
 		if (expr->kind == KLOOP)
 			break;
 
 		do {
 			int i;
 			n += fprintf(out, "\n");
 
 			for (i = 0; i < indent; ++i)
 				n += fprintf(out, "\t");
 
 		} while (0);
 
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "until ");
 		n += printexpr(out, expr->u.payload, indent);
 
 		if (expr->rhs) {
 			n += highlight(out, HLKEYWORD);
 			n += fprintf(out, " else");
 			n += printclause(out, expr->rhs, indent);
 		}
 		break;
 
 
 	case KDO:
 		n += highlight(out, HLKEYWORD);
 		n += fprintf(out, "do");
 		n += printclause(out, expr->lhs, indent);
 		break;
 
 	case KUNION:
 	case KSTRUCT:
 		n += highlight(out, HLKEYWORD);
 
 		n += fprintf(out,
 			expr->kind == KSTRUCT ? "struct" : "union");
 
 		if (expr->lhs && expr->lhs->kind == IDENT) {
 			n += highlight(out, HLTYPE);
 			n += fprintf(out, " %s",
 				getstring(idents, expr->lhs->u.key));
 		}
 
 		if (expr->rhs)
 			n += printclause(out, expr->rhs, indent);
 
 		break;
 
 	case ASTMT:
 	advancestmt:
 		do {
 			int i;
 
 			for (i = 0; i < indent; ++i)
 				n += fprintf(out, "\t");
 		} while (0);
 
 		n += printexpr(out, expr->lhs, indent);
 
 		if (expr->rhs) {
 			assert(expr->rhs->kind == ASTMT);
 			n += fprintf(out, "\n");
 			expr = expr->rhs;
 			goto advancestmt;
 		}
 
 		break;
 
 	case ASCOPE:
 		/* @todo improve this piece of code */
 		if (expr->lhs                      &&
 			expr->lhs->kind == ASTMT       &&
 			expr->u.env                    &&
 			expr->u.env->kind != SFUNCTION &&
 			expr->u.env->kind != SSTRUCT)
 		{
 			Node *stmt = expr->lhs;
 
 			if (!stmt->rhs && isclauseorempty(stmt)) {
 				n += printexpr(out, stmt->lhs, indent);
 				break;
 			}
 		}
 		n += printexpr(out, expr->lhs, indent);
 		// n += fprintf(out, "\n"); /* blank line */
 		break;
 	
 	case AENV:
 		n += printexpr(out, expr->lhs, indent);
 		break;
 
 	case ACONV:
 		n += highlight(out, HLNUMBER);
 		n += fprintf(out, "conv(");
 
 		n += highlight(out, HLTYPE);
 		n += printtype(out, expr->type, indent);
 		n += highlight(out, HLDELIM);
 
 		n += fprintf(out, ") ");
 		n += printoperant(out, expr->lhs, PUNARY, false, indent);
 		break;
 
 	case AADDR:
 		n += highlight(out, HLDELIM);
 		n += fputs("&{", out);
 		n += printoperant(out, expr->lhs, PUNARY, false, indent);
 		n += highlight(out, HLDELIM);
 		n += fputs("}", out);
 		break;
 
 	case ADEREF:
 		n += highlight(out, HLDELIM);
 		n += fputs("*{", out);
 		n += printoperant(out, expr->lhs, PUNARY, false, indent);
 		n += highlight(out, HLDELIM);
 		n += fputs("}", out);
 		break;
 
 	case ACOMPOUND:
 		n += highlight(out, HLTYPE);
 		n += printtype(out, expr->type, indent);
 		n += highlight(out, HLDELIM);
 		n += fputs("{", out);
 		n += printexpr(out, expr->rhs, indent);
 		n += highlight(out, HLDELIM);
 		n += fputs("}", out);
 		break;
 
 	case AFIELDINIT:
 		if (expr->lhs) {
 			n += highlight(out, HLDELIM);
 			n += fprintf(out, "%s: ", getstring(idents, expr->u.key));
 		}
 		n += printexpr(out, expr->rhs, indent);
 		break;
 
 	case ASELFDISP:
 		n += printexpr(out, expr->lhs, indent);
 		n += highlight(out, HLNONE);
 		/* @todo use printexpr when typechecked */
 		n += fprintf(out, ":%s", getstring(idents, expr->rhs->u.key));
 		break;
 
 	default:
 		n += highlight(out, HLINFO);
 		n += fprintf(out, "node(%u)", expr->kind);
 
 		if (expr->lhs) {
 			n += fprintf(out, " -> ");
 			n += printsubexpr(out, expr->lhs, true, indent);
 		}
 		if (expr->rhs) {
 			n += highlight(out, HLINFO);
 			n += fprintf(out, " => ");
 			n += printsubexpr(out, expr->rhs, false, indent);
 		}
 
 		break;
 	}
 
 finish:
 	#if 0
 	if (expr->kind == ASTMT && expr->next) {
 		n += fprintf(out, "\n");
 	} else if (expr->next) {
 		n += highlight(out, HLDELIM);
 		n += fprintf(out, ", ");
 	}
 	#endif
 
 	return n;
 }
 
 
 
 // }}}
 
 // @section toplevel bundle & use {{{
 
 #if 0
 typedef struct String String;
 struct String {
 	char *string;
 	int length;
 };
 
 static String
 makestring(char *string)
 {
 	String result;
 
 	result.string = string;
 	result.length = strlen(string);
 
 	return result;
 }
 
 static bool
 endswithcase(String name, String ending)
 {
 	const int delta = name.length - ending.length;
 	int i;
 
 	if (name.length < ending.length)
 		return false;
 
 	for (i = 0; i < ending.length; ++i) {
 		const int j = i + delta;
 		if (tolower(name.string[j]) != ending.string[i])
 			return false;
 	}
 
 	return true;
 }
 
 static bool
 beginswith(String name, String beginning)
 {
 	int i;
 
 	if (name.length < beginning.length)
 		return false;
 
 	for (i = 0; i < beginning.length; ++i) {
 		if (name.string[i] != beginning.string[i])
 			return false;
 	}
 
 	return true;
 }
 
 static String
 duplicatestring(String s)
 {
 	String copy;
 
 	copy.string = (char *) calloc(s.length + 1, sizeof*(s.string));
 	copy.length = s.length;
 
 	assert(copy.string);
 	strncpy(copy.string, s.string, s.length);
 
 	return copy;
 }
 #endif
 
 // }}}
 
 // @section init source {{{
 
 static void
 initsource(Source *source, const char *filename, FILE *file)
 {
 	source->filein = file;
 	source->currloc.filename = filename;
 	source->tok.loc.filename = filename;
 	source->tabwidth = 8;
 	source->haspendingenv = false;
 	source->handlereplprompt = false;
 
 	source->pendingcount = 0;
 
 	source->implicitenv = envbuf + envtop++;
 
 	gettok(source);
 	if (getkind(source) == LINEDELIM)
 		gettok(source);
 }
 
 
 
 // }}}
 
 // @section main-routine {{{
 
 const char *
 isolatecommand(char **string)
 {
 	char *commandline = *string;
 	const char *command;
 
 	while (isspace(*commandline))
 		++commandline;
 
 	command = commandline;
 
 	while (!isspace(*commandline) && *commandline)
 		++commandline;
 
 	if (*commandline)
 		*commandline = 0, ++commandline;
 
 	*string = commandline;
 
 	return command;
 }
 
 static bool
 processcommand(Source *source)
 {
 	char *commandline = source->line + 1;
 
 	const char *command = isolatecommand(&commandline);
 
 	if (!strcmp(command, "exit")) {
 		source->line[0] = 0;
 		return false;
 	}
 
 	if (!strcmp(command, "memory")) {
 		int i;
 
 		printf("ast-nodes:    %5u, deletes: %5u, total: %5u\n",
 			nodetop, poolednodecount, totalnodecount);
 
 		printf("type-nodes:   %5u\n", typetop);
 		printf("declarations: %5u\n", decltop);
 		printf("environments: %5u\n", envtop);
 
 		for (i = 0; i < nodetop; ++i) {
 			if (nodebuf[i].kind == 0)
 				continue;
 
 			highlight(stdout, HLINFO);
 			printf("node[%u]:\n", i);
 			printexpr(stdout, nodebuf + i, 0);
 			printf("\n");
 		}
 
 		goto finish;
 	}
 
 	if (!strcmp(command, "delete")) {
 		command = isolatecommand(&commandline);
 
 		if (!strcmp(command, "node")     ||
 		    !strcmp(command, "ast-node") ||
 		     isdigit(*command))
 		{
 			int i;
 
 			if (!isdigit(*command))
 				command = isolatecommand(&commandline);
 
 			i = atoi(command);
 
 			if (i < 4096 && i >= 0) {
 				Node *node = nodebuf + i;
 
 				if (node->kind != 0)
 					deletenode(node);
 				else
 					printf("already deleted.\n");
 			} else {
 				fprintf(stderr, "error: invalid number.\n");
 			}
 		} else {
 			fprintf(stderr, "error: unknown argument '%s'.\n",
 				command);
 		}
 
 		goto finish;
 	}
 
 	fprintf(stderr, "error: unknown command '%s'.\n", command);
 finish:
 	return mygetline(source);
 }
 
 static void
 handlelineending(Source *source);
 
 char bundlenamebuffer[1024 * 4];
 int bundlenamelength = 0;
 
 static bool
 processtopleveluse(Source *source, SrcLoc *loc, const int bundlepath[], int count)
 {
 	static const char prefix[] = "arialib/";
 	static const char suffix[] = ".co";
 
 	FILE *importfile = NULL;
 	const char *filename = NULL;
 
 	int i;
 
 	if (sizeof(prefix) - 1 > sizeof(bundlenamebuffer) - 1)
 		goto errorlength;
 
 	bundlenamelength = sizeof(prefix) - 1;
 	memcpy(bundlenamebuffer, prefix, sizeof(prefix) - 1);
 
 	for (i = 0; i < count; ++i) {
 		const int key = bundlepath[i];
 		const char *string = getstring(idents, key);
 		const int length = getlength(idents, key);
 
 		if (length + bundlenamelength > sizeof(bundlenamebuffer) - 1)
 			goto errorlength;
 
 		memcpy(bundlenamebuffer + bundlenamelength, string, length);
 		bundlenamelength += length;
 
 		if (i >= count - 1)
 			continue;
 
 		if (bundlenamelength + 1 > sizeof(bundlenamebuffer) - 1)
 			goto errorlength;
 		
 		bundlenamebuffer[bundlenamelength++] = '/';
 	}
 
 	if (bundlenamelength + sizeof(suffix) - 1 > sizeof(bundlenamebuffer) - 1)
 		goto errorlength;
 
 	memcpy(bundlenamebuffer + bundlenamelength, suffix, sizeof(suffix) - 1);
 	bundlenamelength += sizeof(suffix) - 1;
 	bundlenamebuffer[bundlenamelength] = '\0';
 
 	filename = calloc(bundlenamelength + 1, sizeof*(bundlenamebuffer));
 
 	if (!filename) {
 		error(loc, "out of memory");
 		return false;
 	}
 
 	memcpy(filename, bundlenamebuffer, bundlenamelength);
 
 	importfile = fopen(filename, "r");
 
 	if (!importfile) {
 		error(loc, "could not open bundle file '%s'", filename);
 		return false;
 	}
 
 	warn(loc, "using bundle '%s'", filename);
 
 	fclose(importfile);
 	free(filename);
 
 	return true;
 
 errorlength:
 	error(loc, "bundle path is too long");
 	return false;
 }
 
 static Node *
 toplevel(Source *source, Block *block)
 {
 	Node *ast;
 
 redo:
 	readannots(source);
 	if (getkind(source) == KBUNDLE) {
 		SrcLoc loc = *getloc(source);
 #if 0
 		int bundlekey = 0;
 		gettok(source);
 		while (getkind(source) == IDENT) {
 			char *name = getstring(idents, source->tok.u.key);
 			int length = getlength(idents, source->tok.u.key);
 
 			/* @fixme check name length */
 			memcpy(bundlenamebuffer + bundlenamelength, name, length);
 			bundlenamelength += length;
 			gettok(source);
 			bundlenamebuffer[bundlenamelength] = '\0';
 
 			if (getkind(source) != ODISP)
 				break;
 
 			gettok(source);
 			bundlenamebuffer[bundlenamelength++] = '_';
 			bundlenamebuffer[bundlenamelength] = '\0';
 		}
 
 		if (bundlenamelength) {
 			bundlekey = getstringkey(&idents, bundlenamebuffer,
 				bundlenamelength);
 			assert(source->currenv);
 			source->currenv->bundle = makedecl(source, bundlekey,
 				DBUNDLE);
 			source->currenv->loc = loc;
 		}
 #else
 		Decl *bundle = NULL;
 		gettok(source);
 		while (getkind(source) == IDENT) {
 			const int bundlekey = source->tok.u.key;
 
 			assert(source->currenv);
 			bundle = makebundle(source, bundlekey, bundle);
 
 			gettok(source);
 
 			if (getkind(source) != ODISP)
 				break;
 
 			gettok(source);
 		}
 
 		if (bundle) {
 			source->currenv->bundle = bundle;
 			source->currenv->loc = loc;
 		} else {
 			/* @note is this correct? */
 			source->currenv->bundle = NULL;
 		}
 #endif
 
 		handlelineending(source);
 		goto redo;
 	}
 
 	if (getkind(source) == KUSE) {
 		int bundlepath[64];
 		int bundlepathtop = 0;
 
 		SrcLoc loc = *getloc(source);
 
 		gettok(source);
 		while (getkind(source) == IDENT) {
 			const int bundlekey = source->tok.u.key;
 
 			bundlepath[bundlepathtop++] = bundlekey;
 
 			gettok(source);
 
 			if (getkind(source) != ODISP)
 				break;
 
 			gettok(source);
 		}
 
 		handlelineending(source);
 
 		processtopleveluse(source, &loc, bundlepath, bundlepathtop);
 		goto redo;
 	}
 	ast = exprlist(source, false, NULL);
 	/* ast = readexpr(source, PSTART); */
 	/*
 	printast(ast, 0);
 	printf("\n");
 	*/
 	if (ast->kind != ADECL ||
 		!ast->u.payload     ||
 		ast->u.payload->kind != ASCOPE)
 	{
 		ast = typecheck(source->currenv, ast);
 		ast = foldexpr(source->currenv, ast);
 		dataflow(block, ast);
 	}
 	ast = extractnestedfunctions(source->currenv, ast);
 
 	return ast;
 }
 
 static void
 processpendingenvs(Source *source, Block *block)
 {
 	Env *p;
 
 	for (p = source->pendingenvhead; p; p = p->pendingnext) {
 		if (p->stmts) {
 			p->stmts = typecheck(source->currenv, p->stmts);
 			p->stmts = foldexpr(source->currenv, p->stmts);
 			dataflow(block, p->stmts);
 
 			/* debug prints: */
 			highlight(stdout, HLINFO);
 			printf("statements:\n");
 			highlight(stdout, HLNONE);
 			printexpr(stdout, p->stmts, 1);
 
 			highlight(stdout, HLINFO);
 			fputs(" : ", stdout);
 			printtype(stdout, p->stmts->type, 0);
 			highlight(stdout, HLNONE);
 
 			printf("\n");
 		}
 	}
 
 }
 
 static void
 handlelineending(Source *source)
 {
 	if (getkind(source) == LINEDELIM) {
 		if (source->filein == stdin) {
 			highlight(stdout, HLPROMPT);
 			printf("> ");
 			highlight(stdout, HLNONE);
 			source->handlereplprompt = false;
 		}
 		gettok(source);
 	} else if (getkind(source) == SEMIDELIM) {
 		gettok(source);
 	}
 
 	if (source->lastkind != SEMIDELIM && source->lastkind != LINEDELIM){
 		error(getloc(source), "expected new line");
 		while (getkind(source) != SEMIDELIM &&
 		       getkind(source) != LINEDELIM &&
 		       getkind(source) != 0)
 		{
 			gettok(source);
 		}
 
 		if (source->filein == stdin) {
 			highlight(stdout, HLPROMPT);
 			printf("> ");
 			highlight(stdout, HLNONE);
 			source->handlereplprompt = false;
 		}
 
 		if (getkind(source) != 0)
 			gettok(source);
 	}
 }
 
 static void
 processfile(Source *source)
 {
 	Block *block;
 	Decl *intrinsic;
 
 	CodeGen cg = {0};
 
 	pushenv(source, STOPLEVEL);
 	block = makeblock(BTOPLEVEL, source->currenv);
 	appendconduct(block, CSCOPE, NULL);
 
 	intrinsic = makedecl(source, getstringkey(&idents, "printf", 6), DFUNCTION);
 	intrinsic->type = maketype(&source->tok.loc, primitive(TFUNCTION), NULL);
 	intrinsic->type->u.rtarget = primitive(TINT);
 
 	cginit(&cg, source->currenv, fopen("out.c", "wb"));
 	while (getkind(source) != 0) {
 		/* printf("token:%i:%i: %c '%.*s'\n", lastline, lastcol + 1,
 				tok.u.id, currcol - lastcol, line + lastcol);*/
 		Node *ast = toplevel(source, block);
 
 		highlight(stdout, HLINFO);
 		printf("number of nested functions: %u\n", extractedtop - 1);
 		highlight(stdout, HLNONE);
 
 		if (source->filein == stdin) {
 			highlight(stdout, HLINFO);
 			fputs("= ", stdout);
 			highlight(stdout, HLNONE);
 		}
 
 		printexpr(stdout, ast, 0);
 		highlight(stdout, HLNONE);
 
 		if (source->filein == stdin) {
 			highlight(stdout, HLINFO);
 			fputs(" : ", stdout);
 			printtype(stdout, ast->type, 0);
 			highlight(stdout, HLNONE);
 		}
 		printf("\n");
 
 		cgtoplevel(source, ast, &cg);
 		handlelineending(source);
 	}
 
 	highlight(stdout, HLINFO);
 	puts("dump pending environments ...");
 	highlight(stdout, HLNONE);
 
 	processpendingenvs(source, block);
 	cgtoplevelfinish(source, &cg);
 	/* dfpopconduct(); */
 	popenv(source);
 
 	highlight(stdout, HLINFO);
 	printf("exiting with %u errors and %u warnings ...\x1b[0m\n",
 		errorcount, warningcount);
 
 	fclose(cg.out);
 }
 
 int
 main(int argc, char **argv)
 {
 	Source *source = &testsource;
 
 	initkeywords();
 	initstrmap(&idents);
 	initstrmap(&strings);
 
 	auxthen = getstringkey(&idents, "then", 4);
 	auxin   = getstringkey(&idents, "in", 2);
 	auxto   = getstringkey(&idents, "to", 2);
 	auxstep = getstringkey(&idents, "step", 4);
 
 	auxself = getstringkey(&idents, "self", 4);
 
 	if (argc >= 2) {
 		initsource(source, argv[1], fopen(argv[1], "rb"));
 		assert(source->filein);
 	} else {
 		highlight(stdout, HLPROMPT);
 		printf("> ");
 		highlight(stdout, HLNONE);
 		initsource(source, "<stdin>", stdin);
 	}
 
 	processfile(source);
 
 	/* fclose(source->filein); */
 	/* disposestrmap(&strings); */
 	/* disposestrmap(&idents); */
 
 	return !!errorcount;
 }
 
 // }}}