diff --git a/il65/compile.py b/il65/compile.py
index 4df3a8da1..ae92ecca1 100644
--- a/il65/compile.py
+++ b/il65/compile.py
@@ -16,7 +16,7 @@ from .plyparse import parse_file, ParseError, Module, Directive, Block, Subrouti
     SymbolName, Dereference, AddressOf
 from .plylex import SourceRef, print_bold
 from .optimize import optimize
-from .datatypes import DataType, STRING_DATATYPES
+from .datatypes import DataType, VarType, STRING_DATATYPES
 
 
 class CompileError(Exception):
@@ -97,7 +97,7 @@ class PlyParser:
         for block, parent in module.all_scopes():
             parentname = (parent.name + ".") if parent else ""
             blockname = parentname + block.name
-            if  blockname in encountered_blocks:
+            if blockname in encountered_blocks:
                 raise ValueError("block names not unique:", blockname)
             encountered_blocks.add(blockname)
             for node in block.nodes:
@@ -429,6 +429,7 @@ class Zeropage:
 
     def allocate(self, vardef: VarDef) -> int:
         assert not vardef.name or vardef.name not in {a[0] for a in self.allocations.values()}, "var name is not unique"
+        assert vardef.vartype == VarType.VAR, "can only allocate var"
 
         def sequential_free(location: int) -> bool:
             return all(location + i in self.free for i in range(size))
diff --git a/il65/generateasm.py b/il65/generateasm.py
index 72cdaf48c..96ed01c27 100644
--- a/il65/generateasm.py
+++ b/il65/generateasm.py
@@ -245,7 +245,7 @@ class AssemblyGenerator:
 
         self.p("_il65_init_block\v; (re)set vars to initial values")
         float_inits = {}
-        string_inits = []
+        string_inits = []   # type: List[VarDef]
         prev_value_a, prev_value_x = None, None
         vars_by_datatype = defaultdict(list)  # type: Dict[DataType, List[VarDef]]
         for vardef in block.scope.filter_nodes(VarDef):
diff --git a/il65/handwritten/__init__.py b/il65/handwritten/__init__.py
deleted file mode 100644
index 5bb534f79..000000000
--- a/il65/handwritten/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# package
diff --git a/il65/handwritten/exprparse.py b/il65/handwritten/exprparse.py
deleted file mode 100644
index 421cbfa8b..000000000
--- a/il65/handwritten/exprparse.py
+++ /dev/null
@@ -1,284 +0,0 @@
-"""
-Programming Language for 6502/6510 microprocessors
-This is the expression parser/evaluator.
-
-Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-"""
-
-import ast
-import attr
-from typing import Union, Optional, List, Tuple, Any
-from .symbols import FLOAT_MAX_POSITIVE, FLOAT_MAX_NEGATIVE, SourceRef, SymbolTable, SymbolError, PrimitiveType
-
-
-class ParseError(Exception):
-    def __init__(self, message: str, sourcetext: Optional[str], sourceref: SourceRef) -> None:
-        self.sourceref = sourceref
-        self.msg = message
-        self.sourcetext = sourcetext
-
-    def __str__(self):
-        return "{} {:s}".format(self.sourceref, self.msg)
-
-
-class SourceLine:
-    def __init__(self, text: str, sourceref: SourceRef) -> None:
-        self.sourceref = sourceref
-        self.text = text.strip()
-
-    def to_error(self, message: str) -> ParseError:
-        return ParseError(message, self.text, self.sourceref)
-
-    def preprocess(self) -> str:
-        # transforms the source text into valid Python syntax by bending some things, so ast can parse it.
-        # $d020      ->  0xd020
-        # %101001    ->  0xb101001
-        # #something ->  __ptr@something   (matmult operator)
-        text = ""
-        quotes_stack = ""
-        characters = enumerate(self.text + " ")
-        for i, c in characters:
-            if c in ("'", '"'):
-                if quotes_stack and quotes_stack[-1] == c:
-                    quotes_stack = quotes_stack[:-1]
-                else:
-                    quotes_stack += c
-                text += c
-                continue
-            if not quotes_stack:
-                if c == '%' and self.text[i + 1] in "01":
-                    text += "0b"
-                    continue
-                if c == '$' and self.text[i + 1] in "0123456789abcdefABCDEF":
-                    text += "0x"
-                    continue
-                if c == '&':
-                    if i > 0:
-                        text += " "
-                    text += "__ptr@"
-                    continue
-            text += c
-        return text
-
-
-def parse_arguments(text: str, sourceref: SourceRef) -> List[Tuple[str, PrimitiveType]]:
-    src = SourceLine(text, sourceref)
-    text = src.preprocess()
-    try:
-        nodes = ast.parse("__func({:s})".format(text), sourceref.file, "eval")
-    except SyntaxError as x:
-        raise src.to_error(str(x))
-
-    args = []   # type: List[Tuple[str, Any]]
-    if isinstance(nodes, ast.Expression):
-        for arg in nodes.body.args:
-            reprvalue = astnode_to_repr(arg)
-            args.append((None, reprvalue))
-        for kwarg in nodes.body.keywords:
-            reprvalue = astnode_to_repr(kwarg.value)
-            args.append((kwarg.arg, reprvalue))
-        return args
-    else:
-        raise TypeError("ast.Expression expected")
-
-
-def parse_expr_as_comparison(text: str, sourceref: SourceRef) -> Tuple[str, str, str]:
-    src = SourceLine(text, sourceref)
-    text = src.preprocess()
-    try:
-        node = ast.parse(text, sourceref.file, mode="eval")
-    except SyntaxError as x:
-        raise src.to_error(str(x))
-    if not isinstance(node, ast.Expression):
-        raise TypeError("ast.Expression expected")
-    if isinstance(node.body, ast.Compare):
-        if len(node.body.ops) != 1:
-            raise src.to_error("only one comparison operator at a time is supported")
-        operator = {
-            "Eq": "==",
-            "NotEq": "!=",
-            "Lt": "<",
-            "LtE": "<=",
-            "Gt": ">",
-            "GtE": ">=",
-            "Is": None,
-            "IsNot": None,
-            "In": None,
-            "NotIn": None
-        }[node.body.ops[0].__class__.__name__]
-        if not operator:
-            raise src.to_error("unsupported comparison operator")
-        left = text[node.body.left.col_offset:node.body.comparators[0].col_offset].rstrip()[:-len(operator)]
-        right = text[node.body.comparators[0].col_offset:]
-        return left.strip(), operator, right.strip()
-    left = astnode_to_repr(node.body)
-    return left, "", ""
-
-
-def parse_expr_as_int(text: str, context: Optional[SymbolTable], ppcontext: Optional[SymbolTable], sourceref: SourceRef, *,
-                      minimum: int=0, maximum: int=0xffff) -> int:
-    result = parse_expr_as_primitive(text, context, ppcontext, sourceref, minimum=minimum, maximum=maximum)
-    if isinstance(result, int):
-        return result
-    src = SourceLine(text, sourceref)
-    raise src.to_error("int expected, not " + type(result).__name__)
-
-
-def parse_expr_as_number(text: str, context: Optional[SymbolTable], ppcontext: Optional[SymbolTable], sourceref: SourceRef, *,
-                         minimum: float=FLOAT_MAX_NEGATIVE, maximum: float=FLOAT_MAX_POSITIVE) -> Union[int, float]:
-    result = parse_expr_as_primitive(text, context, ppcontext, sourceref, minimum=minimum, maximum=maximum)
-    if isinstance(result, (int, float)):
-        return result
-    src = SourceLine(text, sourceref)
-    raise src.to_error("int or float expected, not " + type(result).__name__)
-
-
-def parse_expr_as_string(text: str, context: Optional[SymbolTable], ppcontext: Optional[SymbolTable], sourceref: SourceRef) -> str:
-    result = parse_expr_as_primitive(text, context, ppcontext, sourceref)
-    if isinstance(result, str):
-        return result
-    src = SourceLine(text, sourceref)
-    raise src.to_error("string expected, not " + type(result).__name__)
-
-
-def parse_expr_as_primitive(text: str, context: Optional[SymbolTable], ppcontext: Optional[SymbolTable], sourceref: SourceRef, *,
-                            minimum: float = FLOAT_MAX_NEGATIVE, maximum: float = FLOAT_MAX_POSITIVE) -> PrimitiveType:
-    src = SourceLine(text, sourceref)
-    text = src.preprocess()
-    try:
-        node = ast.parse(text, sourceref.file, mode="eval")
-    except SyntaxError as x:
-        raise src.to_error(str(x))
-    if isinstance(node, ast.Expression):
-        result = ExpressionTransformer(src, context, ppcontext).evaluate(node)
-    else:
-        raise TypeError("ast.Expression expected")
-    if isinstance(result, bool):
-        return int(result)
-    if isinstance(result, (int, float)):
-        if minimum <= result <= maximum:
-            return result
-        raise src.to_error("number too large")
-    if isinstance(result, str):
-        return result
-    raise src.to_error("int or float or string expected, not " + type(result).__name__)
-
-
-class EvaluatingTransformer(ast.NodeTransformer):
-    def __init__(self, src: SourceLine, context: SymbolTable, ppcontext: SymbolTable) -> None:
-        super().__init__()
-        self.src = src
-        self.context = context
-        self.ppcontext = ppcontext
-
-    def error(self, message: str, column: int=0) -> ParseError:
-        ref = attr.evolve(self.src.sourceref, column=column)
-        return ParseError(message, self.src.text, ref)
-
-    def evaluate(self, node: ast.Expression) -> PrimitiveType:
-        node = self.visit(node)
-        code = compile(node, self.src.sourceref.file, mode="eval")
-        if self.context:
-            globals = None
-            locals = self.context.as_eval_dict(self.ppcontext)
-        else:
-            globals = {"__builtins__": {}}
-            locals = None
-        try:
-            result = eval(code, globals, locals)        # XXX unsafe...
-        except Exception as x:
-            raise self.src.to_error(str(x)) from x
-        else:
-            if type(result) is bool:
-                return int(result)
-            return result
-
-
-class ExpressionTransformer(EvaluatingTransformer):
-    def _dotted_name_from_attr(self, node: ast.Attribute) -> str:
-        if isinstance(node.value, ast.Name):
-            return node.value.id + '.' + node.attr
-        if isinstance(node.value, ast.Attribute):
-            return self._dotted_name_from_attr(node.value) + '.' + node.attr
-        raise self.error("dotted name error")
-
-    def visit_Name(self, node: ast.Name):
-        # convert true/false names to True/False constants
-        if node.id == "true":
-            return ast.copy_location(ast.NameConstant(True), node)
-        if node.id == "false":
-            return ast.copy_location(ast.NameConstant(False), node)
-        return node
-
-    def visit_UnaryOp(self, node):
-        if isinstance(node.operand, ast.Num):
-            if isinstance(node.op, ast.USub):
-                node = self.generic_visit(node)
-                return ast.copy_location(ast.Num(-node.operand.n), node)
-            if isinstance(node.op, ast.UAdd):
-                node = self.generic_visit(node)
-                return ast.copy_location(ast.Num(node.operand.n), node)
-            if isinstance(node.op, ast.Invert):
-                if isinstance(node.operand, ast.Num):
-                    node = self.generic_visit(node)
-                    return ast.copy_location(ast.Num(~node.operand.n), node)
-                else:
-                    raise self.error("can only bitwise invert a number")
-            raise self.error("expected unary + or - or ~")
-        elif isinstance(node.operand, ast.UnaryOp):
-            # nested unary ops, for instance: "~-2" = invert(minus(2))
-            node = self.generic_visit(node)
-            return self.visit_UnaryOp(node)
-        else:
-            print(node.operand)
-            raise self.error("expected constant numeric operand for unary operator")
-
-    def visit_BinOp(self, node):
-        node = self.generic_visit(node)
-        if isinstance(node.op, ast.MatMult):
-            if isinstance(node.left, ast.Name) and node.left.id == "__ptr":
-                if isinstance(node.right, ast.Attribute):
-                    symbolname = self._dotted_name_from_attr(node.right)
-                elif isinstance(node.right, ast.Name):
-                    symbolname = node.right.id
-                else:
-                    raise self.error("can only take address of a named variable")
-                try:
-                    address = self.context.get_address(symbolname)
-                except SymbolError as x:
-                    raise self.error(str(x))
-                else:
-                    return ast.copy_location(ast.Num(address), node)
-            else:
-                raise self.error("invalid MatMult/Pointer node in AST")
-        return node
-
-
-def astnode_to_repr(node: ast.AST) -> str:
-    if isinstance(node, ast.Name):
-        return node.id
-    if isinstance(node, ast.Num):
-        return repr(node.n)
-    if isinstance(node, ast.Str):
-        return repr(node.s)
-    if isinstance(node, ast.BinOp):
-        if node.left.id == "__ptr" and isinstance(node.op, ast.MatMult):    # type: ignore
-            return '&' + astnode_to_repr(node.right)
-        else:
-            print("error", ast.dump(node))
-            raise TypeError("invalid arg ast node type", node)
-    if isinstance(node, ast.Attribute):
-        return astnode_to_repr(node.value) + "." + node.attr
-    if isinstance(node, ast.UnaryOp):
-        if isinstance(node.op, ast.USub):
-            return "-" + astnode_to_repr(node.operand)
-        if isinstance(node.op, ast.UAdd):
-            return "+" + astnode_to_repr(node.operand)
-        if isinstance(node.op, ast.Invert):
-            return "~" + astnode_to_repr(node.operand)
-        if isinstance(node.op, ast.Not):
-            return "not " + astnode_to_repr(node.operand)
-    if isinstance(node, ast.List):
-        # indirect values get turned into a list...
-        return "[" + ",".join(astnode_to_repr(elt) for elt in node.elts) + "]"
-    raise TypeError("invalid arg ast node type", node)
diff --git a/il65/handwritten/optimize.py b/il65/handwritten/optimize.py
deleted file mode 100644
index 0368eab4d..000000000
--- a/il65/handwritten/optimize.py
+++ /dev/null
@@ -1,154 +0,0 @@
-"""
-Programming Language for 6502/6510 microprocessors
-This is the code to optimize the parse tree.
-
-Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-"""
-
-from typing import List
-from .parse import ParseResult
-from .symbols import Block, AugmentedAssignmentStmt, IntegerValue, FloatValue, AssignmentStmt, CallStmt, \
-    Value, MemMappedValue, RegisterValue, AstNode
-
-
-class Optimizer:
-    def __init__(self, parseresult: ParseResult) -> None:
-        self.parsed = parseresult
-
-    def optimize(self) -> ParseResult:
-        print("\noptimizing parse tree")
-        for block in self.parsed.all_blocks():
-            self.remove_augmentedassign_incrdecr_nops(block)
-            self.remove_identity_assigns(block)
-            self.combine_assignments_into_multi(block)
-            self.optimize_multiassigns(block)
-            self.remove_unused_subroutines(block)
-            self.optimize_compare_with_zero(block)
-        return self.parsed
-
-    def remove_augmentedassign_incrdecr_nops(self, block: Block) -> None:
-        have_removed_stmts = False
-        for index, stmt in enumerate(list(block.statements)):
-            if isinstance(stmt, AugmentedAssignmentStmt):
-                if isinstance(stmt.right, (IntegerValue, FloatValue)):
-                    if stmt.right.value == 0 and stmt.operator in ("+=", "-=", "|=", "<<=", ">>=", "^="):
-                        print("{}: removed statement that has no effect".format(stmt.sourceref))
-                        have_removed_stmts = True
-                        block.statements[index] = None
-                    if stmt.right.value >= 8 and stmt.operator in ("<<=", ">>="):
-                        print("{}: shifting that many times always results in zero".format(stmt.sourceref))
-                        new_stmt = AssignmentStmt(stmt.leftvalues, IntegerValue(0, stmt.sourceref), stmt.sourceref)
-                        block.statements[index] = new_stmt
-        if have_removed_stmts:
-            # remove the Nones
-            block.statements = [s for s in block.statements if s is not None]
-
-    def optimize_compare_with_zero(self, block: Block) -> None:
-        # a conditional goto that compares a value to zero will be simplified
-        # the comparison operator and rvalue (0) will be removed and the if-status changed accordingly
-        for stmt in block.statements:
-            if isinstance(stmt, CallStmt):
-                cond = stmt.condition
-                if cond and isinstance(cond.rvalue, (IntegerValue, FloatValue)) and cond.rvalue.value == 0:
-                    simplified = False
-                    if cond.ifstatus in ("true", "ne"):
-                        if cond.comparison_op == "==":
-                            # if_true something == 0   ->  if_not something
-                            cond.ifstatus = "not"
-                            cond.comparison_op, cond.rvalue = "", None
-                            simplified = True
-                        elif cond.comparison_op == "!=":
-                            # if_true something != 0  -> if_true something
-                            cond.comparison_op, cond.rvalue = "", None
-                            simplified = True
-                    elif cond.ifstatus in ("not", "eq"):
-                        if cond.comparison_op == "==":
-                            # if_not something == 0   ->  if_true something
-                            cond.ifstatus = "true"
-                            cond.comparison_op, cond.rvalue = "", None
-                            simplified = True
-                        elif cond.comparison_op == "!=":
-                            # if_not something != 0  -> if_not something
-                            cond.comparison_op, cond.rvalue = "", None
-                            simplified = True
-                    if simplified:
-                        print("{}: simplified comparison with zero".format(stmt.sourceref))
-
-    def combine_assignments_into_multi(self, block: Block) -> None:
-        # fold multiple consecutive assignments with the same rvalue into one multi-assignment
-        statements = []   # type: List[AstNode]
-        multi_assign_statement = None
-        for stmt in block.statements:
-            if isinstance(stmt, AssignmentStmt) and not isinstance(stmt, AugmentedAssignmentStmt):
-                if multi_assign_statement and multi_assign_statement.right == stmt.right:
-                    multi_assign_statement.leftvalues.extend(stmt.leftvalues)
-                    print("{}: joined with previous line into multi-assign statement".format(stmt.sourceref))
-                else:
-                    if multi_assign_statement:
-                        statements.append(multi_assign_statement)
-                    multi_assign_statement = stmt
-            else:
-                if multi_assign_statement:
-                    statements.append(multi_assign_statement)
-                    multi_assign_statement = None
-                statements.append(stmt)
-        if multi_assign_statement:
-            statements.append(multi_assign_statement)
-        block.statements = statements
-
-    def optimize_multiassigns(self, block: Block) -> None:
-        # optimize multi-assign statements.
-        for stmt in block.statements:
-            if isinstance(stmt, AssignmentStmt) and len(stmt.leftvalues) > 1:
-                # remove duplicates
-                lvalues = list(set(stmt.leftvalues))
-                if len(lvalues) != len(stmt.leftvalues):
-                    print("{}: removed duplicate assignment targets".format(stmt.sourceref))
-                # change order: first registers, then zp addresses, then non-zp addresses, then the rest (if any)
-                stmt.leftvalues = list(sorted(lvalues, key=_value_sortkey))
-
-    def remove_identity_assigns(self, block: Block) -> None:
-        have_removed_stmts = False
-        for index, stmt in enumerate(list(block.statements)):
-            if isinstance(stmt, AssignmentStmt):
-                stmt.remove_identity_lvalues()
-                if not stmt.leftvalues:
-                    print("{}: removed identity assignment statement".format(stmt.sourceref))
-                    have_removed_stmts = True
-                    block.statements[index] = None
-        if have_removed_stmts:
-            # remove the Nones
-            block.statements = [s for s in block.statements if s is not None]
-
-    def remove_unused_subroutines(self, block: Block) -> None:
-        # some symbols are used by the emitted assembly code from the code generator,
-        # and should never be removed or the assembler will fail
-        never_remove = {"c64.FREADUY", "c64.FTOMEMXY", "c64.FADD", "c64.FSUB",
-                        "c64flt.GIVUAYF", "c64flt.copy_mflt", "c64flt.float_add_one", "c64flt.float_sub_one",
-                        "c64flt.float_add_SW1_to_XY", "c64flt.float_sub_SW1_from_XY"}
-        discarded = []
-        for sub in list(block.symbols.iter_subroutines()):
-            usages = self.parsed.subroutine_usage[(sub.blockname, sub.name)]
-            if not usages and sub.blockname + '.' + sub.name not in never_remove:
-                block.symbols.remove_node(sub.name)
-                discarded.append(sub.name)
-        if discarded:
-            print("{}: discarded {:d} unused subroutines from block '{:s}'".format(block.sourceref, len(discarded), block.name))
-
-
-def _value_sortkey(value: Value) -> int:
-    if isinstance(value, RegisterValue):
-        num = 0
-        for char in value.register:
-            num *= 100
-            num += ord(char)
-        return num
-    elif isinstance(value, MemMappedValue):
-        if value.address is None:
-            return 99999999
-        if value.address < 0x100:
-            return 10000 + value.address
-        else:
-            return 20000 + value.address
-    else:
-        return 99999999
diff --git a/il65/handwritten/parse.py b/il65/handwritten/parse.py
deleted file mode 100644
index 3e669e280..000000000
--- a/il65/handwritten/parse.py
+++ /dev/null
@@ -1,1365 +0,0 @@
-"""
-Programming Language for 6502/6510 microprocessors
-This is the hand-written parser of the IL65 code, that generates a parse tree.
-
-Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-"""
-
-import re
-import os
-import sys
-import shutil
-from collections import defaultdict
-from .exprparse import ParseError, parse_expr_as_int, parse_expr_as_number, parse_expr_as_primitive,\
-    parse_expr_as_string, parse_arguments, parse_expr_as_comparison
-from .symbols import *
-
-
-class ProgramFormat(enum.Enum):
-    PRG = "prg"
-    RAW = "raw"
-
-
-class ParseResult:
-    def __init__(self, sourcefile: str) -> None:
-        self.format = ProgramFormat.RAW
-        self.with_sys = False
-        self.sourcefile = sourcefile
-        self.clobberzp = False
-        self.restorezp = False
-        self.start_address = 0
-        self.blocks = []          # type: List[Block]
-        self.subroutine_usage = defaultdict(set)    # type: Dict[Tuple[str, str], Set[str]]
-        self.zeropage = Zeropage()
-        self.preserve_registers = False
-
-    def all_blocks(self) -> Generator[Block, None, None]:
-        for block in self.blocks:
-            yield block
-            for sub in block.symbols.iter_subroutines(True):
-                yield sub.sub_block
-
-    def add_block(self, block: Block, position: Optional[int]=None) -> None:
-        if position is not None:
-            self.blocks.insert(position, block)
-        else:
-            self.blocks.append(block)
-
-    def merge(self, parsed: 'ParseResult') -> None:
-        existing_blocknames = set(block.name for block in self.blocks)
-        other_blocknames = set(block.name for block in parsed.blocks)
-        overlap = existing_blocknames & other_blocknames
-        if overlap != {"<header>"}:
-            raise SymbolError("double block names: {}".format(overlap))
-        for block in parsed.blocks:
-            if block.name != "<header>":
-                self.blocks.append(block)
-
-    def find_block(self, name: str) -> Block:
-        for block in self.blocks:
-            if block.name == name:
-                return block
-        raise KeyError("block not found: " + name)
-
-    def sub_used_by(self, sub: SubroutineDef, sourceref: SourceRef) -> None:
-        self.subroutine_usage[(sub.blockname, sub.name)].add(str(sourceref))
-
-
-class Parser:
-    def __init__(self, filename: str, outputdir: str, existing_imports: Set[str], parsing_import: bool = False,
-                 sourcelines: List[Tuple[int, str]] = None, ppsymbols: SymbolTable = None, sub_usage: Dict=None) -> None:
-        self.result = ParseResult(filename)
-        if sub_usage is not None:
-            # re-use the (global) subroutine usage tracking
-            self.result.subroutine_usage = sub_usage
-        self.sourceref = SourceRef(filename, -1, 0)   # type: ignore
-        if sourcelines:
-            self.lines = sourcelines
-        else:
-            self.lines = self.load_source(filename)
-        self.outputdir = outputdir
-        self.parsing_import = parsing_import     # are we parsing a import file?
-        self._cur_lineidx = -1      # used to efficiently go to next/previous line in source
-        self.cur_block = None  # type: Block
-        self.root_scope = SymbolTable("<root>", None, None)
-        self.root_scope.set_zeropage(self.result.zeropage)
-        self.ppsymbols = ppsymbols  # symboltable from preprocess phase
-        self.print_block_parsing = True
-        self.existing_imports = existing_imports
-        self.parse_errors = 0
-
-    def load_source(self, filename: str) -> List[Tuple[int, str]]:
-        with open(filename, "rU") as source:
-            sourcelines = source.readlines()
-        # store all lines that aren't empty
-        # comments are kept (end-of-line comments are stripped though)
-        lines = []
-        for num, line in enumerate(sourcelines, start=1):
-            line = line.rstrip()
-            if line.lstrip().startswith(';'):
-                lines.append((num, line.lstrip()))
-            else:
-                line2, sep, comment = line.rpartition(';')
-                if sep:
-                    line = line2.rstrip()
-                if line:
-                    lines.append((num, line))
-        return lines
-
-    def parse(self) -> Optional[ParseResult]:
-        # start the parsing
-        try:
-            result = self.parse_file()
-        except ParseError as x:
-            self.handle_parse_error(x)
-        except Exception as x:
-            if sys.stderr.isatty():
-                print("\x1b[1m", file=sys.stderr)
-            print("\nERROR: internal parser error: ", x, file=sys.stderr)
-            if self.cur_block:
-                print("    file:", self.sourceref.file, "block:", self.cur_block.name, "line:", self.sourceref.line, file=sys.stderr)
-            else:
-                print("    file:", self.sourceref.file, file=sys.stderr)
-            if sys.stderr.isatty():
-                print("\x1b[0m", file=sys.stderr, end="", flush=True)
-            raise
-        if self.parse_errors:
-            self.print_bold("\nNo output; there were {:d} errors in file {:s}\n".format(self.parse_errors, self.sourceref.file))
-            raise SystemExit(1)
-        return result
-
-    def handle_parse_error(self, exc: ParseError) -> None:
-        self.parse_errors += 1
-        if sys.stderr.isatty():
-            print("\x1b[1m", file=sys.stderr)
-        if exc.sourcetext:
-            print("\t" + exc.sourcetext, file=sys.stderr)
-            if exc.sourceref.column:
-                print("\t" + ' ' * exc.sourceref.column + '             ^', file=sys.stderr)
-        if self.parsing_import:
-            print("Error (in imported file):", str(exc), file=sys.stderr)
-        else:
-            print("Error:", str(exc), file=sys.stderr)
-        if sys.stderr.isatty():
-            print("\x1b[0m", file=sys.stderr, end="", flush=True)
-
-    def parse_file(self) -> ParseResult:
-        print("\nparsing", self.sourceref.file)
-        self._parse_1()
-        self._parse_import_file("il65lib")      # compiler support library is always imported.
-        self._parse_2()
-        return self.result
-
-    def print_warning(self, text: str, sourceref: SourceRef=None) -> None:
-        self.print_bold("warning: {}: {:s}".format(sourceref or self.sourceref, text))
-
-    def print_bold(self, text: str) -> None:
-        if sys.stdout.isatty():
-            print("\x1b[1m" + text + "\x1b[0m", flush=True)
-        else:
-            print(text)
-
-    def _parse_comments(self) -> None:
-        while True:
-            line = self.next_line().lstrip()
-            if line.startswith(';'):
-                self.cur_block.statements.append(Comment(line, self.sourceref))
-                continue
-            self.prev_line()
-            break
-
-    def _parse_1(self) -> None:
-        self.cur_block = Block("<header>", self.sourceref, self.root_scope, self.result.preserve_registers)
-        self.result.add_block(self.cur_block)
-        self.parse_header()
-        if not self.parsing_import:
-            self.result.zeropage.configure(self.result.clobberzp)
-        while True:
-            self._parse_comments()
-            next_line = self.peek_next_line().lstrip()
-            if next_line.startswith("~"):
-                block = self.parse_block()
-                if block:
-                    self.result.add_block(block)
-            elif next_line.startswith(("%import ", "%import\t")):
-                self.parse_import()
-            else:
-                break
-        line = self.next_line()
-        if line:
-            raise self.PError("invalid statement or characters, block expected")
-        if not self.parsing_import:
-            # check if we have a proper main block to contain the program's entry point
-            main_found = False
-            for block in self.result.blocks:
-                if block.name == "main":
-                    main_found = True
-                    if "start" not in block.label_names:
-                        self.sourceref.line = block.sourceref.line
-                        self.sourceref.column = 0
-                        raise self.PError("block 'main' should contain the program entry point 'start'")
-                    self._check_return_statement(block, "'main' block")
-                for sub in block.symbols.iter_subroutines(True):
-                    self._check_return_statement(sub.sub_block, "subroutine '{:s}'".format(sub.name))
-            if not main_found:
-                raise self.PError("a block 'main' must be defined and contain the program's entry point label 'start'")
-
-    def _check_return_statement(self, block: Block, message: str) -> None:
-        # find last statement that isn't a comment
-        for stmt in reversed(block.statements):
-            if isinstance(stmt, Comment):
-                continue
-            if isinstance(stmt, ReturnStmt) or isinstance(stmt, CallStmt) and stmt.is_goto:
-                return
-            if isinstance(stmt, InlineAsm):
-                # check that the last asm line is a jmp or a rts
-                for asmline in reversed(stmt.asmlines):
-                    if asmline.strip().replace(' ', '').startswith(";returns"):
-                        return
-                    if asmline.lstrip().startswith(';'):
-                        continue
-                    if " rts" in asmline or "\trts" in asmline or " jmp" in asmline or "\tjmp" in asmline:
-                        return
-                    if asmline.strip():
-                        if asmline.split()[0].isidentifier():
-                            continue
-                    break
-            break
-        self.print_warning("{:s} doesn't end with a return statement".format(message), block.sourceref)
-
-    _immediate_floats = {}  # type: Dict[float, Tuple[str, str]]
-    _immediate_string_vars = {}  # type: Dict[str, Tuple[str, str]]
-
-    def _parse_2(self) -> None:
-        # parsing pass 2 (not done during preprocessing!)
-        self.cur_block = None
-        self.sourceref = SourceRef(self.sourceref.file, -1)   # type: ignore
-
-        def imm_string_to_var(stmt: AssignmentStmt, containing_block: Block) -> None:
-            if stmt.right.name or not isinstance(stmt.right, StringValue):
-                return
-            if stmt.right.value in self._immediate_string_vars:
-                blockname, stringvar_name = self._immediate_string_vars[stmt.right.value]
-                if blockname:
-                    stmt.right.name = blockname + '.' + stringvar_name
-                else:
-                    stmt.right.name = stringvar_name
-            else:
-                stringvar_name = "il65_str_{:d}".format(id(stmt))
-                value = stmt.right.value
-                containing_block.symbols.define_constant(stringvar_name, stmt.sourceref, DataType.STRING, value=value)
-                stmt.right.name = stringvar_name
-                self._immediate_string_vars[stmt.right.value] = (containing_block.name, stringvar_name)
-
-        def desugar_immediate_strings(stmt: AstNode, containing_block: Block) -> None:
-            if isinstance(stmt, CallStmt):
-                for s in stmt.desugared_call_arguments:
-                    self.sourceref = s.sourceref
-                    imm_string_to_var(s, containing_block)
-                for s in stmt.desugared_output_assignments:
-                    self.sourceref = s.sourceref
-                    imm_string_to_var(s, containing_block)
-            if isinstance(stmt, AssignmentStmt):
-                self.sourceref = stmt.sourceref
-                imm_string_to_var(stmt, containing_block)
-
-        def desugar_immediate_floats(stmt: AstNode, containing_block: Block) -> None:
-            if isinstance(stmt, (InplaceIncrStmt, InplaceDecrStmt)):
-                howmuch = stmt.value.value
-                if howmuch is None:
-                    assert stmt.value.name
-                    return
-                if howmuch in (0, 1) or type(howmuch) is int:
-                    return      # 1 is special cased in the code generator
-                rom_floats = {
-                    1: "c64.FL_FONE",
-                    .25: "c64.FL_FR4",
-                    .5: "c64.FL_FHALF",
-                    -.5: "c64.FL_NEGHLF",
-                    10: "c64.FL_TENC",
-                    -32768: "c64.FL_N32768",
-                    1e9: "c64.FL_NZMIL",
-                    math.pi: "c64.FL_PIVAL",
-                    math.pi / 2: "c64.FL_PIHALF",
-                    math.pi * 2: "c64.FL_TWOPI",
-                    math.sqrt(2)/2.0: "c64.FL_SQRHLF",
-                    math.sqrt(2): "c64.FL_SQRTWO",
-                    math.log(2): "c64.FL_LOG2",
-                    1.0 / math.log(2): "c64.FL_LOGEB2",
-                }
-                for fv, name in rom_floats.items():
-                    if math.isclose(howmuch, fv, rel_tol=0, abs_tol=1e-9):
-                        # use one of the constants available in ROM
-                        stmt.value.name = name
-                        return
-                if howmuch in self._immediate_floats:
-                    # reuse previously defined float constant
-                    blockname, floatvar_name = self._immediate_floats[howmuch]
-                    if blockname:
-                        stmt.value.name = blockname + '.' + floatvar_name
-                    else:
-                        stmt.value.name = floatvar_name
-                else:
-                    # define new float variable to hold the incr/decr value
-                    # note: not a constant, because we need the MFLT bytes
-                    floatvar_name = "il65_float_{:d}".format(id(stmt))
-                    containing_block.symbols.define_variable(floatvar_name, stmt.sourceref, DataType.FLOAT, value=howmuch)
-                    self._immediate_floats[howmuch] = (containing_block.name, floatvar_name)
-                    stmt.value.name = floatvar_name
-
-        for block in self.result.blocks:
-            self.cur_block = block
-            self.sourceref = attr.evolve(block.sourceref, column=0)
-            for _, sub, stmt in block.all_statements():
-                if isinstance(stmt, CallStmt):
-                    self.sourceref = stmt.sourceref
-                    self.desugar_call_arguments_and_outputs(stmt)
-                desugar_immediate_strings(stmt, self.cur_block)
-                desugar_immediate_floats(stmt, self.cur_block)
-
-    def desugar_call_arguments_and_outputs(self, stmt: CallStmt) -> None:
-        stmt.desugared_call_arguments.clear()
-        stmt.desugared_output_assignments.clear()
-        for name, value in stmt.arguments or []:
-            assert name is not None, "all call arguments should have a name or be matched on a named parameter"
-            assignment = self.parse_assignment(name, value)
-            assignment.sourceref = stmt.sourceref
-            if assignment.leftvalues[0].datatype != DataType.BYTE:
-                if isinstance(assignment.right, IntegerValue) and assignment.right.constant:
-                    # a call that doesn't expect a BYTE argument but gets one, converted from a 1-byte string most likely
-                    if value.startswith("'") and value.endswith("'"):
-                        self.print_warning("possible problematic string to byte conversion (use a .text var instead?)")
-            if not assignment.is_identity():
-                stmt.desugared_call_arguments.append(assignment)
-        if all(not isinstance(v, RegisterValue) for r, v in stmt.outputvars or []):
-            # if none of the output variables are registers, we can simply generate the assignments without issues
-            for register, value in stmt.outputvars or []:
-                rvalue = self.parse_expression(register)
-                assignment = AssignmentStmt([value], rvalue, stmt.sourceref)
-                stmt.desugared_output_assignments.append(assignment)
-        else:
-            result_reg_mapping = [(register, value.register, value) for register, value in stmt.outputvars or []
-                                  if isinstance(value, RegisterValue)]
-            if any(r[0] != r[1] for r in result_reg_mapping):
-                # not all result parameter registers line up with the correct order of registers in the statement,
-                # reshuffling call results is not supported yet.
-                raise self.PError("result registers and/or their ordering is not the same as in the "
-                                  "subroutine definition, this isn't supported yet")
-            else:
-                # no register alignment issues, just generate the assignments
-                # note: do not remove the identity assignment here or the output register handling generates buggy code
-                for register, value in stmt.outputvars or []:
-                    rvalue = self.parse_expression(register)
-                    assignment = AssignmentStmt([value], rvalue, stmt.sourceref)
-                    stmt.desugared_output_assignments.append(assignment)
-
-    def next_line(self) -> str:
-        self._cur_lineidx += 1
-        try:
-            lineno, line = self.lines[self._cur_lineidx]
-            self.sourceref = SourceRef(file=self.sourceref.file, line=lineno)    # type: ignore
-            return line
-        except IndexError:
-            return ""
-
-    def prev_line(self) -> str:
-        self._cur_lineidx -= 1
-        lineno, line = self.lines[self._cur_lineidx]
-        self.sourceref = SourceRef(file=self.sourceref.file, line=lineno)    # type: ignore
-        return line
-
-    def peek_next_line(self) -> str:
-        if (self._cur_lineidx + 1) < len(self.lines):
-            return self.lines[self._cur_lineidx + 1][1]
-        return ""
-
-    def PError(self, message: str, lineno: int=0, column: int=0) -> ParseError:
-        sourceline = ""
-        lineno = lineno or self.sourceref.line
-        column = column or self.sourceref.column
-        for num, text in self.lines:
-            if num == lineno:
-                sourceline = text.strip()
-                break
-        return ParseError(message, sourceline, SourceRef(self.sourceref.file, lineno, column))    # type: ignore
-
-    def get_datatype(self, typestr: str) -> Tuple[DataType, int, Optional[Tuple[int, int]]]:
-        if typestr == ".byte":
-            return DataType.BYTE, 1, None
-        elif typestr == ".word":
-            return DataType.WORD, 1, None
-        elif typestr == ".float":
-            return DataType.FLOAT, 1, None
-        elif typestr.endswith("text"):
-            if typestr == ".text":
-                return DataType.STRING, 0, None
-            elif typestr == ".ptext":
-                return DataType.STRING_P, 0, None
-            elif typestr == ".stext":
-                return DataType.STRING_S, 0, None
-            elif typestr == ".pstext":
-                return DataType.STRING_PS, 0, None
-        elif typestr.startswith(".array(") and typestr.endswith(")"):
-            return DataType.BYTEARRAY, self._size_from_arraydecl(typestr), None
-        elif typestr.startswith(".wordarray(") and typestr.endswith(")"):
-            return DataType.WORDARRAY, self._size_from_arraydecl(typestr), None
-        elif typestr.startswith(".matrix(") and typestr.endswith(")"):
-            dimensions = self._size_from_matrixdecl(typestr)
-            return DataType.MATRIX, dimensions[0] * dimensions[1], dimensions
-        raise self.PError("invalid data type: " + typestr)
-
-    def parse_header(self) -> None:
-        self.result.with_sys = False
-        self.result.format = ProgramFormat.RAW
-        output_specified = False
-        zp_specified = False
-        preserve_specified = False
-        while True:
-            self._parse_comments()
-            line = self.next_line()
-            if line.startswith('%'):
-                directive = line.split(maxsplit=1)[0][1:]
-                if directive == "output":
-                    if output_specified:
-                        raise self.PError("can only specify output options once")
-                    output_specified = True
-                    _, _, optionstr = line.partition(" ")
-                    options = set(optionstr.replace(' ', '').split(','))
-                    self.result.with_sys = False
-                    self.result.format = ProgramFormat.RAW
-                    if "raw" in options:
-                        options.remove("raw")
-                    if "prg" in options:
-                        options.remove("prg")
-                        self.result.format = ProgramFormat.PRG
-                    if "basic" in options:
-                        options.remove("basic")
-                        if self.result.format == ProgramFormat.PRG:
-                            self.result.with_sys = True
-                        else:
-                            raise self.PError("can only use basic output option with prg, not raw")
-                    if options:
-                        raise self.PError("invalid output option(s): " + str(options))
-                    continue
-                elif directive == "zp":
-                    if zp_specified:
-                        raise self.PError("can only specify ZP options once")
-                    zp_specified = True
-                    _, _, optionstr = line.partition(" ")
-                    options = set(optionstr.replace(' ', '').split(','))
-                    self.result.clobberzp = False
-                    self.result.restorezp = False
-                    if "clobber" in options:
-                        options.remove("clobber")
-                        self.result.clobberzp = True
-                    if "restore" in options:
-                        options.remove("restore")
-                        if self.result.clobberzp:
-                            self.result.restorezp = True
-                        else:
-                            raise self.PError("can only use restore zp option if clobber zp is used as well")
-                    if options:
-                        raise self.PError("invalid zp option(s): " + str(options))
-                    continue
-                elif directive == "address":
-                    if self.result.start_address:
-                        raise self.PError("multiple occurrences of 'address'")
-                    _, _, arg = line.partition(" ")
-                    try:
-                        self.result.start_address = parse_expr_as_int(arg, None, None, self.sourceref)
-                    except ParseError:
-                        raise self.PError("invalid address")
-                    if self.result.format == ProgramFormat.PRG and self.result.with_sys and self.result.start_address != 0x0801:
-                        raise self.PError("cannot use non-default 'address' when output format includes basic SYS program")
-                    continue
-                elif directive == "saveregisters":
-                    if preserve_specified:
-                        raise self.PError("can only specify saveregisters option once")
-                    preserve_specified = True
-                    _, _, optionstr = line.partition(" ")
-                    self.result.preserve_registers = optionstr in ("", "true", "yes")
-                    continue
-                elif directive == "import":
-                    break    # the first import directive actually is not part of the header anymore
-                else:
-                    raise self.PError("invalid directive")
-            break  # no more directives, header parsing finished!
-        self.prev_line()
-        if not self.result.start_address:
-            # set the proper default start address
-            if self.result.format == ProgramFormat.PRG:
-                self.result.start_address = 0x0801  # normal C-64 basic program start address
-            elif self.result.format == ProgramFormat.RAW:
-                self.result.start_address = 0xc000  # default start for raw assembly
-        if self.result.format == ProgramFormat.PRG and self.result.with_sys and self.result.start_address != 0x0801:
-            raise self.PError("cannot use non-default 'address' when output format includes basic SYS program")
-
-    def parse_import(self) -> None:
-        line = self.next_line()
-        line = line.lstrip()
-        if not line.startswith(("%import ", "%import\t")):
-            raise self.PError("expected import")
-        try:
-            _, filename = line.split(maxsplit=1)
-        except ValueError:
-            raise self.PError("invalid import statement")
-        if filename[0] in "'\"" and filename[-1] in "'\"":
-            filename = filename[1:-1]
-        if not filename:
-            raise self.PError("invalid filename")
-        self._parse_import_file(filename)
-
-    def _parse_import_file(self, filename: str) -> None:
-        candidates = [filename+".ill", filename]
-        filename_at_source_location = os.path.join(os.path.split(self.sourceref.file)[0], filename)
-        if filename_at_source_location not in candidates:
-            candidates.append(filename_at_source_location+".ill")
-            candidates.append(filename_at_source_location)
-        filename_at_libs_location = os.path.join(os.path.split(__file__)[0], "../lib", filename)
-        if filename_at_libs_location not in candidates:
-            candidates.append(filename_at_libs_location+".ill")
-            candidates.append(filename_at_libs_location)
-        for filename in candidates:
-            if os.path.isfile(filename):
-                if not self.check_import_okay(filename):
-                    return
-                self.print_import_progress("importing", filename)
-                parser = self.create_import_parser(filename, self.outputdir)
-                result = parser.parse()
-                self.print_import_progress("\ncontinuing", self.sourceref.file)
-                if result:
-                    # merge the symbol table of the imported file into our own
-                    try:
-                        self.root_scope.merge_roots(parser.root_scope)
-                        self.result.merge(result)
-                    except SymbolError as x:
-                        raise self.PError(str(x))
-                    return
-                else:
-                    raise self.PError("Error while parsing imported file")
-        raise self.PError("imported file not found")
-
-    def print_import_progress(self, message: str, *args: str) -> None:
-        print(message, *args)
-
-    def create_import_parser(self, filename: str, outputdir: str) -> 'Parser':
-        return Parser(filename, outputdir, self.existing_imports, True, ppsymbols=self.ppsymbols, sub_usage=self.result.subroutine_usage)
-
-    def parse_block(self) -> Optional[Block]:
-        # first line contains block header "~ [name] [addr]" followed by a '{'
-        self._parse_comments()
-        line = self.next_line()
-        line = line.lstrip()
-        if not line.startswith("~"):
-            raise self.PError("expected '~' (block)")
-        block_args = line[1:].split()
-        arg = ""
-        self.cur_block = Block("", self.sourceref, self.root_scope, self.result.preserve_registers)
-        is_zp_block = False
-        while block_args:
-            arg = block_args.pop(0)
-            if arg.isidentifier():
-                if arg.lower() == "zeropage" or arg in ("zp", "zP", "Zp"):
-                    raise self.PError("zero page block must be named 'ZP'")
-                is_zp_block = arg == "ZP"
-                if arg in set(b.name for b in self.result.blocks):
-                    orig = [b for b in self.result.blocks if b.name == arg][0]
-                    if not is_zp_block:
-                        raise self.PError("duplicate block name '{:s}', original definition at {}".format(arg, orig.sourceref))
-                    self.cur_block = orig  # zero page block occurrences are merged
-                else:
-                    self.cur_block = Block(arg, self.sourceref, self.root_scope, self.result.preserve_registers)
-                    try:
-                        self.root_scope.define_scope(self.cur_block.symbols, self.cur_block.sourceref)
-                    except SymbolError as x:
-                        raise self.PError(str(x))
-            elif arg == "{":
-                break
-            elif arg.endswith("{"):
-                # when there is no whitespace before the {
-                block_args.insert(0, "{")
-                block_args.insert(0, arg[:-1])
-                continue
-            else:
-                try:
-                    block_address = parse_expr_as_int(arg, self.cur_block.symbols, self.ppsymbols, self.sourceref)
-                except ParseError:
-                    raise self.PError("Invalid block address")
-                if block_address == 0 or (block_address < 0x0200 and not is_zp_block):
-                    raise self.PError("block address must be >= $0200 (or omitted)")
-                if is_zp_block:
-                    if block_address not in (0, 0x04):
-                        raise self.PError("zero page block address must be $04 (or omittted)")
-                    block_address = 0x04
-                self.cur_block.address = block_address
-        if arg != "{":
-            line = self.peek_next_line()
-            if line != "{":
-                raise self.PError("expected '{' after block")
-            else:
-                self.next_line()
-        if self.print_block_parsing:
-            if self.cur_block.address:
-                print("  parsing block '{:s}' at ${:04x}".format(self.cur_block.name, self.cur_block.address))
-            else:
-                print("  parsing block '{:s}'".format(self.cur_block.name))
-        if self.cur_block.ignore:
-            # just skip the lines until we hit a '}' that closes the block
-            nesting_level = 1
-            while True:
-                line = self.next_line().strip()
-                if line.endswith("{"):
-                    nesting_level += 1
-                elif line == "}":
-                    nesting_level -= 1
-                    if nesting_level == 0:
-                        self.print_warning("ignoring block without name and address", self.cur_block.sourceref)
-                        return None
-            else:
-                raise self.PError("invalid statement in block")
-        while True:
-            try:
-                go_on, resultblock = self._parse_block_statement(is_zp_block)
-                if not go_on:
-                    return resultblock
-            except ParseError as x:
-                self.handle_parse_error(x)
-
-    def _parse_block_statement(self, is_zp_block: bool) -> Tuple[bool, Optional[Block]]:
-        # parse the statements inside a block
-        self._parse_comments()
-        line = self.next_line()
-        unstripped_line = line
-        line = line.strip()
-        if line.startswith('%'):
-            directive, _, optionstr = line.partition(" ")
-            directive = directive[1:]
-            self.cur_block.preserve_registers = optionstr in ("", "true", "yes")
-            if directive in ("asminclude", "asmbinary"):
-                if is_zp_block:
-                    raise self.PError("ZP block cannot contain assembler directives")
-                self.cur_block.statements.append(self.parse_asminclude(line))
-            elif directive == "asm":
-                if is_zp_block:
-                    raise self.PError("ZP block cannot contain code statements")
-                self.prev_line()
-                self.cur_block.statements.append(self.parse_asm())
-            elif directive == "breakpoint":
-                self.cur_block.statements.append(BreakpointStmt(self.sourceref))
-                self.print_warning("breakpoint defined")
-            elif directive == "saveregisters":
-                self.result.preserve_registers = optionstr in ("", "true", "yes")
-            else:
-                raise self.PError("invalid directive")
-        elif line == "}":
-            if is_zp_block and any(b.name == "ZP" for b in self.result.blocks):
-                return False, None     # we already have the ZP block
-            if self.cur_block.ignore:
-                self.print_warning("ignoring block without name and address", self.cur_block.sourceref)
-                return False, None
-            return False, self.cur_block
-        elif line.startswith(("var ", "var\t")):
-            self.parse_var_def(line)
-        elif line.startswith(("const ", "const\t")):
-            self.parse_const_def(line)
-        elif line.startswith(("memory ", "memory\t")):
-            self.parse_memory_def(line, is_zp_block)
-        elif line.startswith(("sub ", "sub\t")):
-            if is_zp_block:
-                raise self.PError("ZP block cannot contain subroutines")
-            self.parse_subroutine_def(line)
-        elif unstripped_line.startswith((" ", "\t")):
-            if line.endswith("{"):
-                raise self.PError("invalid statement")
-            if is_zp_block:
-                raise self.PError("ZP block cannot contain code statements")
-            self.cur_block.statements.append(self.parse_statement(line))
-        elif line:
-            match = re.fullmatch(r"(?P<label>\S+)\s*:(?P<rest>.*)", line)
-            if match:
-                if is_zp_block:
-                    raise self.PError("ZP block cannot contain code labels")
-                label = match.group("label")
-                rest = match.group("rest")
-                self.parse_label(label, rest)
-            else:
-                raise self.PError("invalid statement in block")
-        else:
-            raise self.PError("invalid statement in block")
-        return True, None   # continue with more statements
-
-    def parse_label(self, labelname: str, rest: str) -> None:
-        if str.isidentifier(labelname):
-            if labelname in self.cur_block.label_names:
-                raise self.PError("label already defined")
-            if labelname in self.cur_block.symbols:
-                raise self.PError("symbol already defined")
-            self.cur_block.symbols.define_label(labelname, self.sourceref)
-            self.cur_block.statements.append(Label(labelname, self.sourceref))
-            if rest:
-                self.cur_block.statements.append(self.parse_statement(rest))
-        else:
-            raise self.PError("invalid label name")
-
-    def parse_memory_def(self, line: str, is_zeropage: bool=False) -> None:
-        varname, datatype, length, dimensions, valuetext = self.parse_def_common(line, "memory")
-        memaddress = parse_expr_as_int(valuetext, self.cur_block.symbols, self.ppsymbols, self.sourceref)
-        if is_zeropage and memaddress > 0xff:
-            raise self.PError("address must be in zeropage $00-$ff")
-        try:
-            self.cur_block.symbols.define_variable(varname, self.sourceref, datatype,
-                                                   length=length, address=memaddress, matrixsize=dimensions)
-        except SymbolError as x:
-            raise self.PError(str(x)) from x
-
-    def parse_const_def(self, line: str) -> None:
-        varname, datatype, length, dimensions, valuetext = self.parse_def_common(line, "const")
-        if dimensions:
-            raise self.PError("cannot declare a constant matrix")
-        value = parse_expr_as_primitive(valuetext, self.cur_block.symbols, self.ppsymbols, self.sourceref)
-        _, value = self.coerce_value(self.sourceref, datatype, value)
-        try:
-            self.cur_block.symbols.define_constant(varname, self.sourceref, datatype, length=length, value=value)
-        except (ValueError, SymbolError) as x:
-            raise self.PError(str(x)) from x
-
-    def parse_subroutine_def(self, line: str) -> None:
-        match = re.fullmatch(r"sub\s+(?P<name>\w+)\s+"
-                             r"\((?P<parameters>[\w\s:,]*)\)"
-                             r"\s*->\s*"
-                             r"\((?P<results>[\w\s?,]*)\)\s*"
-                             r"(?P<decltype>\s+=\s+(?P<address>\S*)|{)\s*", line)
-        if not match:
-            raise self.PError("invalid sub declaration")
-        groups = match.groupdict()
-        code_decl = groups["decltype"] == "{"
-        name, parameterlist, resultlist, address_str = groups["name"], groups["parameters"], groups["results"], groups["address"]
-        parameters = [(m.group("name"), m.group("target"))
-                      for m in re.finditer(r"(?:(?:(?P<name>[\w]+)\s*:\s*)?(?P<target>[\w]+))(?:,|$)", parameterlist)]
-        for _, regs in parameters:
-            if regs not in REGISTER_SYMBOLS:
-                raise self.PError("invalid register(s) in parameter or return values")
-        all_paramnames = [p[0] for p in parameters if p[0]]
-        if len(all_paramnames) != len(set(all_paramnames)):
-            raise self.PError("duplicates in parameter names")
-        results = [m.group("name") for m in re.finditer(r"\s*(?P<name>(?:\w+)\??)\s*(?:,|$)", resultlist)]
-        if not results:
-            if resultlist == "?":
-                # a single '?' in the result spec means: all 3 registers clobbered
-                results = ['A?', 'X?', 'Y?']
-            elif resultlist:
-                raise self.PError("invalid return values spec")
-        subroutine_block = None
-        if code_decl:
-            address = None
-            # parse the subroutine code lines (until the closing '}')
-            subroutine_block = Block(self.cur_block.name + "." + name, self.sourceref, self.cur_block.symbols,
-                                     self.cur_block.preserve_registers)
-            current_block = self.cur_block
-            self.cur_block = subroutine_block
-            while True:
-                self._parse_comments()
-                line = self.next_line()
-                unstripped_line = line
-                line = line.strip()
-                if line == "}":
-                    # subroutine end
-                    break
-                if line.startswith(("sub ", "sub\t")):
-                    raise self.PError("cannot nest subroutines")
-                elif line.startswith(("%asm ", "%asm\t")):
-                    self.prev_line()
-                    subroutine_block.statements.append(self.parse_asm())
-                elif unstripped_line.startswith((" ", "\t")):
-                    if line.endswith("{"):
-                        raise self.PError("invalid statement")
-                    subroutine_block.statements.append(self.parse_statement(line))
-                elif line:
-                    match = re.fullmatch(r"(?P<label>\S+)\s*:(?P<rest>.*)", line)
-                    if match:
-                        label = match.group("label")
-                        rest = match.group("rest")
-                        self.parse_label(label, rest)
-                    else:
-                        raise self.PError("invalid statement in subroutine")
-                else:
-                    raise self.PError("invalid statement in subroutine")
-            self.cur_block = current_block
-            self.cur_block.sourceref = subroutine_block.sourceref
-        else:
-            try:
-                address = parse_expr_as_int(address_str, self.cur_block.symbols, self.ppsymbols, self.sourceref)
-            except ParseError:
-                raise self.PError("invalid subroutine address")
-        try:
-            self.cur_block.symbols.define_sub(name, self.sourceref, parameters, results, address, subroutine_block)
-        except SymbolError as x:
-            raise self.PError(str(x)) from x
-
-    def parse_var_def(self, line: str) -> None:
-        varname, datatype, length, dimensions, valuetext = self.parse_def_common(line, "var", False)
-        value = parse_expr_as_primitive(valuetext, self.cur_block.symbols, self.ppsymbols, self.sourceref)
-        _, value = self.coerce_value(self.sourceref, datatype, value)
-        try:
-            self.cur_block.symbols.define_variable(varname, self.sourceref, datatype,
-                                                   length=length, value=value, matrixsize=dimensions)
-        except (ValueError, SymbolError) as x:
-            raise self.PError(str(x)) from x
-
-    def parse_def_common(self, line: str, what: str, value_required: bool=True) -> \
-            Tuple[str, DataType, int, Optional[Tuple[int, int]], str]:
-        try:
-            vartext, valuetext = line.split("=", maxsplit=1)
-        except ValueError:
-            if '=' not in line:
-                if value_required:
-                    raise self.PError("missing value assignment")
-                vartext, valuetext = line, "0"  # unspecified value is '0'
-            else:
-                raise self.PError("invalid {:s} decl, '=' missing?".format(what))
-        args = self.psplit(vartext)
-        if args[0] != what or len(args) < 2:
-            raise self.PError("invalid {:s} decl".format(what))
-        if len(args) > 3 or valuetext.startswith('='):
-            raise self.PError("invalid {:s} decl, '=' missing?".format(what))
-        if len(args) == 2:
-            args.insert(1, ".byte")  # unspecified data type is ".byte"
-        if not args[1].startswith("."):
-            raise self.PError("invalid {:s} decl, type is missing".format(what))
-        varname = args[2]
-        if not varname.isidentifier():
-            raise self.PError("invalid {:s} name".format(what))
-        if varname in RESERVED_NAMES:
-            raise self.PError("can't use a reserved name as {:s} name".format(what))
-        datatype, length, matrix_dimensions = self.get_datatype(args[1])
-        return varname, datatype, length, matrix_dimensions, valuetext
-
-    def parse_statement(self, line: str) -> AstNode:
-        match = re.fullmatch(r"(?P<if>if(_[a-z]+)?)\s+(?P<cond>.+)?goto\s+(?P<subname>[\S]+?)\s*(\((?P<arguments>.*)\))?\s*", line)
-        if match:
-            # conditional goto
-            groups = match.groupdict()
-            subname = groups["subname"]
-            if groups["if"] == "if" and not groups["cond"]:
-                raise self.PError("need explicit if status when a condition is not present")
-            condition = self.parse_if_condition(groups["if"], groups["cond"])
-            return self.parse_call_or_goto(subname, groups["arguments"], None, None, True, condition=condition)
-        match = re.fullmatch(r"goto\s+(?P<subname>[\S]+?)\s*(\((?P<arguments>.*)\))?\s*", line)
-        if match:
-            # goto
-            groups = match.groupdict()
-            subname = groups["subname"]
-            return self.parse_call_or_goto(subname, groups["arguments"], None, None, True)
-        match = re.fullmatch(
-            r"(?P<outputs>[^\(]*\s*=)?\s*(?P<subname>[\S]+?)\s*(?P<preserve>!\s*[A-Z]*)?\s*(\((?P<arguments>.*)\))?\s*", line)
-        if match:
-            # subroutine call (not a goto) with possible output param assignment
-            groups = match.groupdict()
-            preserve = None
-            preserve_str = groups["preserve"]
-            if preserve_str and preserve_str.startswith('!'):
-                preserve_str = preserve_str.replace(' ', '')
-                if preserve_str == "!":
-                    preserve = {'A', 'X', 'Y'}
-                else:
-                    preserve = set(preserve_str[1:])
-                    for r in preserve:
-                        if r not in REGISTER_BYTES:
-                            raise self.PError("invalid register in call preservation list")
-            subname = groups["subname"]
-            arguments = groups["arguments"]
-            outputs = groups["outputs"] or ""
-            if outputs.strip() == "=":
-                raise self.PError("missing assignment target variables")
-            outputs = outputs.rstrip("=")
-            if arguments or match.group(4):     # group 4 = (possibly empty) parenthesis
-                return self.parse_call_or_goto(subname, arguments, outputs, preserve, False)
-            # apparently it is not a call (no arguments), fall through
-        if line == "return" or line.startswith(("return ", "return\t")):
-            return self.parse_return(line)
-        elif line.endswith(("++", "--")):
-            incr = line.endswith("++")
-            what = self.parse_expression(line[:-2].rstrip())
-            if isinstance(what, IntegerValue):
-                raise self.PError("cannot in/decrement a constant value")
-            one_value = IntegerValue(1, self.sourceref)
-            if incr:
-                return InplaceIncrStmt(what, one_value, self.sourceref)
-            return InplaceDecrStmt(what, one_value, self.sourceref)
-        else:
-            # perhaps it is an augmented assignment statement
-            match = re.fullmatch(r"(?P<left>\S+)\s*(?P<assignment>\+=|-=|\*=|/=|%=|//=|\*\*=|&=|\|=|\^=|>>=|<<=)\s*(?P<right>\S.*)", line)
-            if match:
-                return self.parse_augmented_assignment(match.group("left"), match.group("assignment"), match.group("right"))
-            # a normal assignment perhaps?
-            splits = [s.strip() for s in line.split('=')]
-            if len(splits) > 1 and all(splits):
-                return self.parse_assignment(*splits)
-            raise self.PError("invalid statement")
-
-    def parse_call_or_goto(self, targetstr: str, argumentstr: str, outputstr: str,
-                           preserve_regs: Set[str]=None, is_goto: bool=False, condition: IfCondition=None) -> CallStmt:
-        if not is_goto:
-            assert condition is None
-        argumentstr = argumentstr.strip() if argumentstr else ""
-        outputstr = outputstr.strip() if outputstr else ""
-        arguments = None
-        outputvars = None
-        if argumentstr:
-            arguments = parse_arguments(argumentstr, self.sourceref)
-        target = None  # type: Value
-        if targetstr[0] == '[' and targetstr[-1] == ']':
-            # indirect call to address in register pair or memory location
-            targetstr, target = self.parse_indirect_value(targetstr, True)
-            if target.datatype != DataType.WORD:
-                raise self.PError("invalid call target (should contain 16-bit)")
-        else:
-            target = self.parse_expression(targetstr)
-        if not isinstance(target, (IntegerValue, MemMappedValue, IndirectValue)):
-            raise self.PError("cannot call that type of symbol")
-        if isinstance(target, IndirectValue) \
-                and not isinstance(target.value, (IntegerValue, RegisterValue, MemMappedValue)):
-            raise self.PError("cannot call that type of indirect symbol")
-        address = target.address if isinstance(target, MemMappedValue) else None
-        try:
-            _, symbol = self.lookup_with_ppsymbols(targetstr)
-        except ParseError:
-            symbol = None   # it's probably a number or a register then
-        if isinstance(symbol, SubroutineDef):
-            if condition and symbol.parameters:
-                raise self.PError("cannot use a subroutine that requires parameters as a target for conditional goto")
-            # verify subroutine arguments
-            if len(arguments or []) != len(symbol.parameters):
-                raise self.PError("invalid number of arguments ({:d}, expected {:d})"
-                                  .format(len(arguments or []), len(symbol.parameters)))
-            args_with_pnames = []
-            for i, (argname, value) in enumerate(arguments or []):
-                pname, preg = symbol.parameters[i]
-                required_name = pname or preg
-                if argname and argname != required_name:
-                    raise self.PError("parameter mismatch ('{:s}', expected '{:s}')".format(argname, required_name))
-                argname = preg
-                args_with_pnames.append((argname, value))
-            arguments = args_with_pnames
-            # verify output parameters
-            if symbol.return_registers:
-                if outputstr:
-                    outputs = [r.strip() for r in outputstr.split(",")]
-                    if len(outputs) != len(symbol.return_registers):
-                        raise self.PError("invalid number of output parameters consumed ({:d}, expected {:d})"
-                                          .format(len(outputs), len(symbol.return_registers)))
-                    outputvars = list(zip(symbol.return_registers, (self.parse_expression(out) for out in outputs)))
-                else:
-                    self.print_warning("return values discarded")
-            else:
-                if outputstr:
-                    raise self.PError("this subroutine doesn't have output parameters")
-            self.result.sub_used_by(symbol, self.sourceref)  # sub usage tracking
-        else:
-            if outputstr:
-                raise self.PError("call cannot use output parameter assignment here, a subroutine is required for that")
-            if arguments:
-                raise self.PError("call cannot take any arguments here, a subroutine is required for that")
-        # verify that all arguments have gotten a name
-        if any(not a[0] for a in arguments or []):
-            raise self.PError("all call arguments should have a name or be matched on a named parameter")
-        if isinstance(target, (type(None), Value)):
-            # special case for the C-64 lib's print function, to be able to use it with a single character argument
-            if target.name == "c64scr.print_string" and len(arguments) == 1 and isinstance(arguments[0], str):
-                if arguments[0][1].startswith("'") and arguments[0][1].endswith("'"):
-                    target = self.parse_expression("c64.CHROUT")
-                    address = target.address
-                    outputvars = None
-                    _, newsymbol = self.lookup_with_ppsymbols("c64.CHROUT")
-                    assert len(newsymbol.parameters) == 1
-                    arguments = [(newsymbol.parameters[0][1], arguments[0][1])]
-            if is_goto:
-                return CallStmt(self.sourceref, target, address=address, arguments=arguments,
-                                outputs=outputvars, is_goto=True, condition=condition)
-            else:
-                return CallStmt(self.sourceref, target, address=address, arguments=arguments,
-                                outputs=outputvars, preserve_regs=preserve_regs)
-        else:
-            raise TypeError("target must be a Value", target)
-
-    def parse_integer(self, text: str) -> int:
-        text = text.strip()
-        if text.startswith('$'):
-            return int(text[1:], 16)
-        if text.startswith('%'):
-            return int(text[1:], 2)
-        return int(text)
-
-    def parse_assignment(self, *parts) -> AssignmentStmt:
-        # parses the assignment of one rvalue to one or more lvalues
-        l_values = [self.parse_expression(p) for p in parts[:-1]]
-        r_value = self.parse_expression(parts[-1])
-        if any(lv.constant for lv in l_values):
-            raise self.PError("can't have a constant as assignment target, perhaps you wanted indirection [...] instead?")
-        for lv in l_values:
-            assignable, reason = lv.assignable_from(r_value)
-            if not assignable:
-                raise self.PError("cannot assign {0} to {1}; {2}".format(r_value, lv, reason))
-            if lv.datatype in (DataType.BYTE, DataType.WORD, DataType.MATRIX):
-                # truncate the rvalue if needed
-                if isinstance(r_value, FloatValue):
-                    truncated, value = self.coerce_value(self.sourceref, lv.datatype, r_value.value)
-                    if truncated:
-                        r_value = IntegerValue(int(value), self.sourceref, datatype=lv.datatype, name=r_value.name)
-        return AssignmentStmt(l_values, r_value, self.sourceref)
-
-    def parse_augmented_assignment(self, leftstr: str, operator: str, rightstr: str) \
-            -> Union[AssignmentStmt, InplaceDecrStmt, InplaceIncrStmt]:
-        # parses an augmented assignment (for instance: value += 3)
-        if operator not in AugmentedAssignmentStmt.SUPPORTED_OPERATORS:
-            raise self.PError("augmented assignment operator '{:s}' not supported".format(operator))
-        l_value = self.parse_expression(leftstr)
-        r_value = self.parse_expression(rightstr)
-        if l_value.constant:
-            raise self.PError("can't have a constant as assignment target, perhaps you wanted indirection [...] instead?")
-        if l_value.datatype in (DataType.BYTE, DataType.WORD, DataType.MATRIX):
-            # truncate the rvalue if needed
-            if isinstance(r_value, FloatValue):
-                truncated, value = self.coerce_value(self.sourceref, l_value.datatype, r_value.value)
-                if truncated:
-                    r_value = IntegerValue(int(value), self.sourceref, datatype=l_value.datatype, name=r_value.name)
-        if operator in ("+=", "-="):
-            # see if we can simplify this to inplace incr/decr statement (only int/float constant values)
-            if r_value.constant:
-                if not isinstance(r_value, (IntegerValue, FloatValue)):
-                    raise self.PError("incr/decr requires constant int or float, not " + r_value.__class__.__name__)
-                if operator == "+=":
-                    if r_value.value > 0:
-                        return InplaceIncrStmt(l_value, r_value, self.sourceref)
-                    elif r_value.value < 0:
-                        return InplaceDecrStmt(l_value, r_value.negative(), self.sourceref)
-                else:
-                    if r_value.value > 0:
-                        return InplaceDecrStmt(l_value, r_value, self.sourceref)
-                    elif r_value.value < 0:
-                        return InplaceIncrStmt(l_value, r_value.negative(), self.sourceref)
-        return AugmentedAssignmentStmt(l_value, operator, r_value, self.sourceref)
-
-    def parse_return(self, line: str) -> Union[ReturnStmt, CallStmt]:
-        parts = line.split(maxsplit=1)
-        if parts[0] != "return":
-            raise self.PError("invalid statement, return expected")
-        if '(' in line and line[-1] == ')':
-            # assume it's a function call that follows the 'return'. Turn it into a goto.
-            parts[0] = "goto"
-            line = " ".join(parts)
-            return self.parse_statement(line)       # type: ignore
-        a = x = y = None
-        values = []  # type: List[str]
-        if len(parts) > 1:
-            values = parts[1].split(",")
-        if len(values) == 0:
-            return ReturnStmt(self.sourceref)
-        else:
-            a = self.parse_expression(values[0]) if values[0] else None
-            if len(values) > 1:
-                x = self.parse_expression(values[1]) if values[1] else None
-                if len(values) > 2:
-                    y = self.parse_expression(values[2]) if values[2] else None
-                    if len(values) > 3:
-                        raise self.PError("too many returnvalues (>3)")
-        return ReturnStmt(self.sourceref, a, x, y)
-
-    def parse_asm(self) -> InlineAsm:
-        line = self.next_line()
-        aline = line.split()
-        if not len(aline) == 2 or aline[0] != "%asm" or aline[1] != "{":
-            raise self.PError("invalid asm directive")
-        asmlines = []   # type: List[str]
-        while True:
-            line = self.next_line()
-            if line.strip() == "}":
-                return InlineAsm(asmlines, self.sourceref)
-            # asm can refer to other symbols as well, track subroutine usage
-            splits = line.split(maxsplit=1)
-            if len(splits) == 2:
-                for match in re.finditer(r"(?P<symbol>[a-zA-Z_$][a-zA-Z0-9_\.]+)", splits[1]):
-                    name = match.group("symbol")
-                    if name[0] == '$':
-                        continue
-                    try:
-                        if '.' not in name:
-                            name = self.cur_block.symbols.parent.name + '.' + name
-                        _, symbol = self.lookup_with_ppsymbols(name)
-                    except ParseError:
-                        pass
-                    else:
-                        if isinstance(symbol, SubroutineDef):
-                            self.result.sub_used_by(symbol, self.sourceref)
-            asmlines.append(line)
-
-    def parse_asminclude(self, line: str) -> InlineAsm:
-        line = line.replace(",", " ")
-        aline = line.split()
-        if len(aline) < 2:
-            raise self.PError("invalid asminclude or asmbinary directive")
-        filename = aline[1]
-        if filename[0] not in "'\"" or filename[-1] not in "'\"":
-            raise self.PError("invalid filename, should use quotes")
-        filename = filename[1:-1]
-        if not filename:
-            raise self.PError("invalid filename")
-        filename_in_sourcedir = os.path.join(os.path.split(self.sourceref.file)[0], filename)
-        filename_in_output_location = os.path.join(self.outputdir, filename)
-        if not os.path.isfile(filename_in_sourcedir):
-            raise self.PError("included file not found")
-        print("copying included file to output location:", filename)
-        shutil.copy(filename_in_sourcedir, filename_in_output_location)
-        if aline[0] == "%asminclude":
-            if len(aline) == 3:
-                scopename = aline[2]
-                lines = ['{:s}\t.binclude "{:s}"'.format(scopename, filename)]
-            else:
-                raise self.PError("invalid asminclude directive")
-            return InlineAsm(lines, self.sourceref)
-        elif aline[0] == "%asmbinary":
-            if len(aline) == 4:
-                offset = parse_expr_as_int(aline[2], None, None, self.sourceref)
-                length = parse_expr_as_int(aline[3], None, None, self.sourceref)
-                lines = ['\t.binary "{:s}", ${:04x}, ${:04x}'.format(filename, offset, length)]
-            elif len(aline) == 3:
-                offset = parse_expr_as_int(aline[2], None, None, self.sourceref)
-                lines = ['\t.binary "{:s}", ${:04x}'.format(filename, offset)]
-            elif len(aline) == 2:
-                lines = ['\t.binary "{:s}"'.format(filename)]
-            else:
-                raise self.PError("invalid asmbinary directive")
-            return InlineAsm(lines, self.sourceref)
-        else:
-            raise self.PError("invalid statement")
-
-    def parse_expression(self, text: str, is_indirect=False) -> Value:
-        # parse an expression into whatever it is (primitive value, register, memory, register, etc)
-        text = text.strip()
-        if not text:
-            raise self.PError("value expected")
-        if text[0] == '&':
-            if is_indirect:
-                raise self.PError("using the address-of something in an indirect value makes no sense")
-            # take the pointer (memory address) from the thing that follows this
-            expression = self.parse_expression(text[1:])
-            if isinstance(expression, StringValue):
-                return expression
-            elif isinstance(expression, MemMappedValue):
-                return IntegerValue(expression.address, self.sourceref, datatype=DataType.WORD, name=expression.name)
-            else:
-                raise self.PError("cannot take the address of type " + expression.__class__.__name__)
-        elif text[0] in "-.0123456789$%~":
-            number = parse_expr_as_number(text, self.cur_block.symbols, self.ppsymbols, self.sourceref)
-            try:
-                if type(number) is int:
-                    return IntegerValue(int(number), self.sourceref)
-                elif type(number) is float:
-                    return FloatValue(number, self.sourceref)
-                else:
-                    raise TypeError("invalid number type")
-            except (ValueError, OverflowError) as ex:
-                raise self.PError(str(ex))
-        elif text in REGISTER_WORDS:
-            return RegisterValue(text, DataType.WORD, self.sourceref)
-        elif text in REGISTER_BYTES | REGISTER_SBITS:
-            return RegisterValue(text, DataType.BYTE, self.sourceref)
-        elif (text.startswith("'") and text.endswith("'")) or (text.startswith('"') and text.endswith('"')):
-            strvalue = parse_expr_as_string(text, self.cur_block.symbols, self.ppsymbols, self.sourceref)
-            if len(strvalue) == 1:
-                petscii_code = char_to_bytevalue(strvalue)
-                return IntegerValue(petscii_code, self.sourceref)
-            return StringValue(strvalue, self.sourceref)
-        elif text == "true":
-            return IntegerValue(1, self.sourceref)
-        elif text == "false":
-            return IntegerValue(0, self.sourceref)
-        elif self.is_identifier(text):
-            symblock, sym = self.lookup_with_ppsymbols(text)
-            if isinstance(sym, (VariableDef, ConstantDef)):
-                constant = isinstance(sym, ConstantDef)
-                if self.cur_block is symblock:
-                    symbolname = sym.name
-                else:
-                    symbolname = "{:s}.{:s}".format(sym.blockname, sym.name)
-                if isinstance(sym, VariableDef) and sym.register:
-                    return RegisterValue(sym.register, sym.type, self.sourceref, name=symbolname)
-                elif sym.type in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
-                    if isinstance(sym, ConstantDef):
-                        if sym.type == DataType.FLOAT:
-                            return FloatValue(sym.value, self.sourceref, sym.name)   # type: ignore
-                        elif sym.type in (DataType.BYTE, DataType.WORD):
-                            return IntegerValue(sym.value, self.sourceref, datatype=sym.type, name=sym.name)  # type: ignore
-                        elif sym.type in STRING_DATATYPES:
-                            return StringValue(sym.value, self.sourceref, sym.name, True)   # type: ignore
-                        else:
-                            raise TypeError("invalid const type", sym.type)
-                    else:
-                        return MemMappedValue(sym.address, sym.type, sym.length, self.sourceref, name=symbolname, constant=constant)
-                elif sym.type in STRING_DATATYPES:
-                    return StringValue(sym.value, self.sourceref, name=symbolname, constant=constant)      # type: ignore
-                elif sym.type == DataType.MATRIX:
-                    raise self.PError("cannot manipulate matrix directly, use one of the matrix procedures")
-                elif sym.type == DataType.BYTEARRAY or sym.type == DataType.WORDARRAY:
-                    raise self.PError("cannot manipulate array directly, use one of the array procedures")
-                else:
-                    raise self.PError("invalid symbol type")
-            elif isinstance(sym, LabelDef):
-                name = sym.name if symblock is self.cur_block else sym.blockname + '.' + sym.name
-                return MemMappedValue(None, DataType.WORD, 1, self.sourceref, name, True)
-            elif isinstance(sym, SubroutineDef):
-                self.result.sub_used_by(sym, self.sourceref)
-                name = sym.name if symblock is self.cur_block else sym.blockname + '.' + sym.name
-                return MemMappedValue(sym.address, DataType.WORD, 1, self.sourceref, name, True)
-            else:
-                raise self.PError("invalid symbol type")
-        elif text.startswith('[') and text.endswith(']'):
-            return self.parse_indirect_value(text)[1]
-        else:
-            raise self.PError("invalid single value '" + text + "'")    # @todo understand complex expressions
-
-    def parse_indirect_value(self, text: str, allow_mmapped_for_call: bool=False) -> Tuple[str, IndirectValue]:
-        indirect = text[1:-1].strip()
-        indirect2, sep, typestr = indirect.rpartition('.')
-        type_modifier = None
-        if sep:
-            if typestr in ("byte", "word", "float"):
-                type_modifier, type_len, _ = self.get_datatype(sep + typestr)
-                indirect = indirect2
-        expr = self.parse_expression(indirect, True)
-        if not isinstance(expr, (IntegerValue, MemMappedValue, RegisterValue)):
-            raise self.PError("only integers, memmapped vars, and registers can be used in an indirect value")
-        if type_modifier is None:
-            if isinstance(expr, (RegisterValue, MemMappedValue)):
-                type_modifier = expr.datatype
-            else:
-                type_modifier = DataType.BYTE
-        if isinstance(expr, IntegerValue):
-            if type_modifier not in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
-                raise self.PError("invalid type modifier for the value's datatype")
-        elif isinstance(expr, MemMappedValue):
-            if allow_mmapped_for_call:
-                if type_modifier and expr.datatype != type_modifier:
-                    raise self.PError("invalid type modifier for the value's datatype, must be " + expr.datatype.name)
-            else:
-                raise self.PError("use variable directly instead of using indirect addressing")
-        return indirect, IndirectValue(expr, type_modifier, self.sourceref)
-
-    def is_identifier(self, name: str) -> bool:
-        if name.isidentifier():
-            return True
-        blockname, sep, name = name.partition(".")
-        if sep:
-            return blockname.isidentifier() and name.isidentifier()
-        return False
-
-    def lookup_with_ppsymbols(self, dottedname: str) -> Tuple[Block, Union[SymbolDefinition, SymbolTable]]:
-        # Tries to find a symbol, if it cannot be located, the symbol table from the preprocess parse phase is consulted as well
-        symblock, sym = self.cur_block.lookup(dottedname)
-        if sym is None and self.ppsymbols:
-            # symbol is not (yet) known, see if the symbols from the preprocess parse phase know about it
-            if '.' not in dottedname:
-                dottedname = self.cur_block.name + '.' + dottedname
-            try:
-                symtable, sym = self.ppsymbols.lookup(dottedname)
-                assert dottedname.startswith(symtable.name)
-                symblock = None   # the block might not have been parsed yet, so just return this instead
-            except (LookupError, SymbolError) as x:
-                raise self.PError(str(x))
-        return symblock, sym
-
-    def _size_from_arraydecl(self, decl: str) -> int:
-        return parse_expr_as_int(decl[:-1].split("(")[-1], self.cur_block.symbols, self.ppsymbols, self.sourceref)
-
-    def _size_from_matrixdecl(self, decl: str) -> Tuple[int, int]:
-        dimensions = decl[:-1].split("(")[-1]
-        try:
-            xs, ys = dimensions.split(",")
-        except ValueError:
-            raise self.PError("invalid matrix dimensions")
-        return (parse_expr_as_int(xs, self.cur_block.symbols, self.ppsymbols, self.sourceref),
-                parse_expr_as_int(ys, self.cur_block.symbols, self.ppsymbols, self.sourceref))
-
-    def coerce_value(self, sourceref: SourceRef, datatype: DataType, value: PrimitiveType) -> Tuple[bool, PrimitiveType]:
-        # if we're a BYTE type, and the value is a single character, convert it to the numeric value
-        if datatype in (DataType.BYTE, DataType.BYTEARRAY, DataType.MATRIX) and isinstance(value, str):
-            if len(value) == 1:
-                return True, char_to_bytevalue(value)
-        # if we're an integer value and the passed value is float, truncate it (and give a warning)
-        if datatype in (DataType.BYTE, DataType.WORD, DataType.MATRIX) and isinstance(value, float):
-            frac = math.modf(value)
-            if frac != 0:
-                self.print_warning("float value truncated ({} to datatype {})".format(value, datatype.name))
-                return True, int(value)
-        return False, value
-
-    @staticmethod
-    def to_hex(number: int) -> str:
-        # 0..255 -> "$00".."$ff"
-        # 256..65536 -> "$0100".."$ffff"
-        if 0 <= number < 0x100:
-            return "${:02x}".format(number)
-        if number < 0x10000:
-            return "${:04x}".format(number)
-        raise OverflowError(number)
-
-    def psplit(self, sentence: str, separators: str=" \t", lparen: str="(", rparen: str=")") -> List[str]:
-        """split a sentence but not on separators within parenthesis"""
-        nb_brackets = 0
-        sentence = sentence.strip(separators)  # get rid of leading/trailing seps
-        indices = [0]
-        for i, c in enumerate(sentence):
-            if c == lparen:
-                nb_brackets += 1
-            elif c == rparen:
-                nb_brackets -= 1
-            elif c in separators and nb_brackets == 0:
-                indices.append(i)
-            # handle malformed string
-            if nb_brackets < 0:
-                raise self.PError("syntax error")
-
-        indices.append(len(sentence))
-        # handle missing closing parentheses
-        if nb_brackets > 0:
-            raise self.PError("syntax error")
-        result = [sentence[i:j].strip(separators) for i, j in zip(indices, indices[1:])]
-        return list(filter(None, result))   # remove empty strings
-
-    def parse_if_condition(self, ifpart: str, conditionpart: str) -> IfCondition:
-        if ifpart == "if":
-            ifstatus = "true"
-        else:
-            ifstatus = ifpart[3:]
-        if ifstatus not in IfCondition.IF_STATUSES:
-            raise self.PError("invalid if form")
-        if conditionpart:
-            if ifstatus not in ("true", "not", "zero"):
-                raise self.PError("can only have if[_true], if_not or if_zero when using a comparison expression")
-            left, operator, right = parse_expr_as_comparison(conditionpart, self.sourceref)
-            leftv = self.parse_expression(left)
-            if not operator and isinstance(leftv, (IntegerValue, FloatValue, StringValue)):
-                raise self.PError("condition is a constant value")
-            if isinstance(leftv, RegisterValue):
-                if leftv.register in {"SC", "SZ", "SI"}:
-                    raise self.PError("cannot use a status bit register explicitly in a condition")
-            if operator:
-                rightv = self.parse_expression(right)
-            else:
-                rightv = None
-            if leftv == rightv:
-                raise self.PError("left and right values in comparison are identical")
-            result = IfCondition(ifstatus, leftv, operator, rightv, self.sourceref)
-        else:
-            result = IfCondition(ifstatus, None, "", None, self.sourceref)
-        if result.make_if_true():
-            self.print_warning("if_not condition inverted to if")
-        return result
-
-    def check_import_okay(self, filename: str) -> bool:
-        if filename == self.sourceref.file and not filename.endswith("il65lib.ill"):
-            raise self.PError("can't import itself")
-        if filename in self.existing_imports:
-            return False
-        self.existing_imports.add(filename)
-        return True
diff --git a/il65/handwritten/preprocess.py b/il65/handwritten/preprocess.py
deleted file mode 100644
index 985d76c0b..000000000
--- a/il65/handwritten/preprocess.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""
-Programming Language for 6502/6510 microprocessors
-This is the preprocessing parser of the IL65 code, that only generates a symbol table.
-
-Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-"""
-
-from typing import List, Tuple, Set
-from .parse import Parser, ParseResult, SymbolTable, SymbolDefinition
-from .symbols import SourceRef, AstNode, InlineAsm
-
-
-class PreprocessingParser(Parser):
-    def __init__(self, filename: str, existing_imports: Set[str], parsing_import: bool=False) -> None:
-        super().__init__(filename, "", existing_imports=existing_imports, parsing_import=parsing_import)
-        self.print_block_parsing = False
-
-    def preprocess(self) -> Tuple[List[Tuple[int, str]], SymbolTable]:
-        def cleanup_table(symbols: SymbolTable):
-            symbols.owning_block = None   # not needed here
-            for name, symbol in list(symbols.symbols.items()):
-                if isinstance(symbol, SymbolTable):
-                    cleanup_table(symbol)
-                elif not isinstance(symbol, SymbolDefinition):
-                    del symbols.symbols[name]
-        self.parse()
-        cleanup_table(self.root_scope)
-        return self.lines, self.root_scope
-
-    def print_warning(self, text: str, sourceref: SourceRef=None) -> None:
-        pass
-
-    def load_source(self, filename: str) -> List[Tuple[int, str]]:
-        lines = super().load_source(filename)
-        # can do some additional source-level preprocessing here
-        return lines
-
-    def parse_file(self) -> ParseResult:
-        print("preprocessing", self.sourceref.file)
-        self._parse_1()
-        return self.result
-
-    def parse_asminclude(self, line: str) -> InlineAsm:
-        return InlineAsm([], self.sourceref)
-
-    def parse_statement(self, line: str) -> AstNode:
-        return None
-
-    def parse_var_def(self, line: str) -> None:
-        super().parse_var_def(line)
-
-    def parse_const_def(self, line: str) -> None:
-        super().parse_const_def(line)
-
-    def parse_memory_def(self, line: str, is_zeropage: bool=False) -> None:
-        super().parse_memory_def(line, is_zeropage)
-
-    def parse_label(self, labelname: str, rest: str) -> None:
-        super().parse_label(labelname, rest)
-
-    def parse_subroutine_def(self, line: str) -> None:
-        super().parse_subroutine_def(line)
-
-    def create_import_parser(self, filename: str, outputdir: str) -> Parser:
-        return PreprocessingParser(filename, parsing_import=True, existing_imports=self.existing_imports)
-
-    def print_import_progress(self, message: str, *args: str) -> None:
-        pass
diff --git a/il65/handwritten/symbols.py b/il65/handwritten/symbols.py
deleted file mode 100644
index 62712bf97..000000000
--- a/il65/handwritten/symbols.py
+++ /dev/null
@@ -1,1196 +0,0 @@
-"""
-Programming Language for 6502/6510 microprocessors
-Here are the symbol (name) operations such as lookups, datatype definitions.
-
-Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-"""
-
-import inspect
-import math
-import enum
-import builtins
-from functools import total_ordering
-from typing import Optional, Set, Union, Tuple, Dict, Iterable, Sequence, Any, List, Generator
-import attr
-
-
-PrimitiveType = Union[int, float, str]
-
-
-REGISTER_SYMBOLS = {"A", "X", "Y", "AX", "AY", "XY", "SC", "SI"}
-REGISTER_SYMBOLS_RETURNVALUES = REGISTER_SYMBOLS | {"SZ"}
-REGISTER_BYTES = {"A", "X", "Y"}
-REGISTER_SBITS = {"SC", "SI", "SZ"}
-REGISTER_WORDS = {"AX", "AY", "XY"}
-
-# 5-byte cbm MFLPT format limitations:
-FLOAT_MAX_POSITIVE = 1.7014118345e+38
-FLOAT_MAX_NEGATIVE = -1.7014118345e+38
-
-RESERVED_NAMES = {'true', 'false', 'var', 'memory', 'const', 'asm', 'byte', 'word', 'float'}
-RESERVED_NAMES |= REGISTER_SYMBOLS
-
-MATH_SYMBOLS = {name for name in dir(math) if name[0].islower()}
-BUILTIN_SYMBOLS = {name for name in dir(builtins) if name[0].islower()}
-
-
-@total_ordering
-class DataType(enum.Enum):
-    """The possible data types of values"""
-    BYTE = 1
-    WORD = 2
-    FLOAT = 3
-    BYTEARRAY = 4
-    WORDARRAY = 5
-    MATRIX = 6
-    STRING = 7
-    STRING_P = 8
-    STRING_S = 9
-    STRING_PS = 10
-
-    def assignable_from_value(self, value: PrimitiveType) -> bool:
-        if isinstance(value, (int, float)):
-            if self == DataType.BYTE:
-                return 0 <= value < 0x100
-            if self == DataType.WORD:
-                return 0 <= value < 0x10000
-            if self == DataType.FLOAT:
-                return type(value) in (float, int)
-        return False
-
-    def __lt__(self, other):
-        if self.__class__ == other.__class__:
-            return self.value < other.value
-        return NotImplemented
-
-
-STRING_DATATYPES = {DataType.STRING, DataType.STRING_P, DataType.STRING_S, DataType.STRING_PS}
-
-
-class SymbolError(Exception):
-    pass
-
-
-_identifier_seq_nr = 0
-
-
-@attr.s(slots=True, frozen=True)
-class SourceRef:
-    file = attr.ib(type=str)
-    line = attr.ib(type=int)
-    column = attr.ib(type=int, default=0)
-
-    def __str__(self) -> str:
-        if self.column:
-            return "{:s}:{:d}:{:d}".format(self.file, self.line, self.column)
-        if self.line:
-            return "{:s}:{:d}".format(self.file, self.line)
-        return self.file
-
-
-class SymbolDefinition:
-    def __init__(self, blockname: str, name: str, sourceref: SourceRef, allocate: bool) -> None:
-        self.blockname = blockname
-        self.name = name
-        self.sourceref = sourceref
-        self.allocate = allocate     # set to false if the variable is memory mapped (or a constant) instead of allocated
-        global _identifier_seq_nr
-        self.seq_nr = _identifier_seq_nr
-        _identifier_seq_nr += 1
-
-    def __lt__(self, other: 'SymbolDefinition') -> bool:
-        if not isinstance(other, SymbolDefinition):
-            return NotImplemented
-        return (self.blockname, self.name, self.seq_nr) < (other.blockname, other.name, self.seq_nr)
-
-    def __str__(self):
-        return "<{:s} {:s}.{:s}>".format(self.__class__.__name__, self.blockname, self.name)
-
-
-class LabelDef(SymbolDefinition):
-    pass
-
-
-class VariableDef(SymbolDefinition):
-    # if address is None, it's a dynamically allocated variable.
-    # if address is not None, it's a memory mapped variable (=memory address referenced by a name).
-    def __init__(self, blockname: str, name: str, sourceref: SourceRef,
-                 datatype: DataType, allocate: bool, *,
-                 value: PrimitiveType, length: int, address: Optional[int]=None,
-                 register: str=None, matrixsize: Tuple[int, int]=None, sourcecomment: str="") -> None:
-        super().__init__(blockname, name, sourceref, allocate)
-        self.type = datatype
-        self.address = address
-        self.length = length
-        self.value = value
-        self.register = register
-        self.matrixsize = matrixsize
-        self.sourcecomment = sourcecomment
-
-    @property
-    def is_memmap(self):
-        return self.address is not None
-
-    def __repr__(self):
-        return "<Variable {:s}.{:s}, {:s}, addr {:s}, len {:s}, value {:s}>"\
-            .format(self.blockname, self.name, self.type, str(self.address), str(self.length), str(self.value))
-
-    def __lt__(self, other: 'SymbolDefinition') -> bool:
-        if not isinstance(other, VariableDef):
-            return NotImplemented
-        v1 = (self.blockname, self.name or "", self.address or 0, self.seq_nr)
-        v2 = (other.blockname, other.name or "", other.address or 0, self.seq_nr)
-        return v1 < v2
-
-
-class ConstantDef(SymbolDefinition):
-    def __init__(self, blockname: str, name: str, sourceref: SourceRef, datatype: DataType, *,
-                 value: PrimitiveType, length: int) -> None:
-        super().__init__(blockname, name, sourceref, False)
-        self.type = datatype
-        self.length = length
-        self.value = value
-
-    def __repr__(self):
-        return "<Constant {:s}.{:s}, {:s}, len {:s}, value {:s}>"\
-            .format(self.blockname, self.name, self.type, str(self.length), str(self.value))
-
-    def __lt__(self, other: 'SymbolDefinition') -> bool:
-        if not isinstance(other, ConstantDef):
-            return NotImplemented
-        v1 = (str(self.value) or "", self.blockname, self.name or "", self.seq_nr)
-        v2 = (str(other.value) or "", other.blockname, other.name or "", self.seq_nr)
-        return v1 < v2
-
-
-class SubroutineDef(SymbolDefinition):
-    def __init__(self, blockname: str, name: str, sourceref: SourceRef,
-                 parameters: Sequence[Tuple[str, str]], returnvalues: Sequence[str],
-                 address: Optional[int]=None, sub_block: 'Block'=None) -> None:
-        super().__init__(blockname, name, sourceref, False)
-        self.address = address
-        self.sub_block = sub_block
-        self.parameters = parameters
-        self.clobbered_registers = set()    # type: Set[str]
-        self.return_registers = []      # type: List[str]  # ordered!
-        for _, param in parameters:
-            if param in REGISTER_BYTES | REGISTER_SBITS:
-                self.clobbered_registers.add(param)
-            elif param in REGISTER_WORDS:
-                self.clobbered_registers.add(param[0])
-                self.clobbered_registers.add(param[1])
-            else:
-                raise SymbolError("invalid parameter spec: " + param)
-        for register in returnvalues:
-            if register in REGISTER_SYMBOLS_RETURNVALUES:
-                self.return_registers.append(register)
-                if len(register) == 1:
-                    self.clobbered_registers.add(register)
-                else:
-                    self.clobbered_registers.add(register[0])
-                    self.clobbered_registers.add(register[1])
-            elif register[-1] == "?":
-                for r in register[:-1]:
-                    if r not in REGISTER_SYMBOLS_RETURNVALUES:
-                        raise SymbolError("invalid return value spec: " + r)
-                    if len(r) == 1:
-                        self.clobbered_registers.add(r)
-                    else:
-                        self.clobbered_registers.add(r[0])
-                        self.clobbered_registers.add(r[1])
-            else:
-                raise SymbolError("invalid return value spec: " + register)
-
-
-class Zeropage:
-    SCRATCH_B1 = 0x02
-    SCRATCH_B2 = 0x03
-    SCRATCH_W1 = 0xfb     # $fb/$fc
-    SCRATCH_W2 = 0xfd     # $fd/$fe
-
-    def __init__(self) -> None:
-        self.free = []  # type: List[int]
-        self.allocations = {}   # type: Dict[int, Tuple[str, DataType]]
-        self._configured = False
-
-    def configure(self, clobber_zp: bool = False) -> None:
-        if self._configured:
-            raise SymbolError("cannot configure the ZP multiple times")
-        if clobber_zp:
-            self.free = list(range(0x04, 0xfb)) + [0xff]
-            for updated_by_irq in [0xa0, 0xa1, 0xa2, 0x91, 0xc0, 0xc5, 0xcb, 0xf5, 0xf6]:
-                self.free.remove(updated_by_irq)
-        else:
-            # these are valid for the C-64 (when no RS232 I/O is performed):
-            # ($02, $03, $fb-$fc, $fd-$fe are reserved as scratch addresses for various routines)
-            self.free = [0x04, 0x05, 0x06, 0x2a, 0x52, 0xf7, 0xf8, 0xf9, 0xfa]
-        assert self.SCRATCH_B1 not in self.free
-        assert self.SCRATCH_B2 not in self.free
-        assert self.SCRATCH_W1 not in self.free
-        assert self.SCRATCH_W2 not in self.free
-        self._configured = True
-
-    def allocate(self, name: str, datatype: DataType) -> int:
-        assert self._configured
-        size = {
-            DataType.BYTE: 1,
-            DataType.WORD: 2,
-            DataType.FLOAT: 5
-        }[datatype]
-
-        def sequential(loc: int) -> bool:
-            for i in range(size):
-                if loc+i not in self.free:
-                    return False
-            return True
-
-        if len(self.free) > 0:
-            if size == 1:
-                assert not name or name not in {a[0] for a in self.allocations.values()}
-                loc = self.free.pop()
-                self.allocations[loc] = (name or "<unnamed>", datatype)
-                return loc
-            for candidate in range(min(self.free), max(self.free)+1):
-                if sequential(candidate):
-                    assert not name or name not in {a[0] for a in self.allocations.values()}
-                    for loc in range(candidate, candidate+size):
-                        self.free.remove(loc)
-                    self.allocations[candidate] = (name or "<unnamed>", datatype)
-                    return candidate
-        raise LookupError("no more free space in ZP to allocate {:d} sequential bytes".format(size))
-
-    def available(self) -> int:
-        return len(self.free)
-
-
-class SymbolTable:
-
-    def __init__(self, name: str, parent: Optional['SymbolTable'], owning_block: 'Block') -> None:
-        self.name = name
-        self.symbols = {}       # type: Dict[str, Union[SymbolDefinition, SymbolTable]]
-        self.parent = parent
-        self.owning_block = owning_block
-        self.eval_dict = None
-        self._zeropage = parent._zeropage if parent else None       # type: Zeropage
-
-    def set_zeropage(self, zp: Zeropage) -> None:
-        if self._zeropage is None:
-            self._zeropage = zp
-        else:
-            raise SymbolError("already have a zp")
-
-    def __iter__(self):
-        yield from self.symbols.values()
-
-    def __getitem__(self, symbolname: str) -> Union[SymbolDefinition, 'SymbolTable']:
-        return self.symbols[symbolname]
-
-    def __contains__(self, symbolname: str) -> bool:
-        return symbolname in self.symbols
-
-    def lookup(self, dottedname: str, include_builtin_names: bool=False) -> Tuple['SymbolTable', Union[SymbolDefinition, 'SymbolTable']]:
-        # Tries to find the dottedname in the current symbol table (if it is not scoped),
-        # or globally if it is scoped (=contains a '.'). If required, math and builtin symbols
-        # such as 'sin' or 'max' are also resolved.
-        # Does NOT utilize a symbol table from a preprocessing parse phase, only looks in the current.
-        nameparts = dottedname.split('.')
-        if not nameparts[0]:
-            nameparts = nameparts[1:]
-        if len(nameparts) == 1:
-            try:
-                return self, self.symbols[nameparts[0]]
-            except LookupError:
-                if include_builtin_names:
-                    if nameparts[0] in MATH_SYMBOLS:
-                        return self, getattr(math, nameparts[0])
-                    elif nameparts[0] in BUILTIN_SYMBOLS:
-                        return self, getattr(builtins, nameparts[0])
-                raise SymbolError("undefined symbol '{:s}'".format(nameparts[0])) from None
-        # restart from global namespace:
-        scope = self
-        while scope.parent:
-            scope = scope.parent
-        for namepart in nameparts[:-1]:
-            try:
-                scope = scope.symbols[namepart]     # type: ignore
-                assert scope.name == namepart
-            except LookupError:
-                raise SymbolError("undefined block '{:s}'".format(namepart)) from None
-        if isinstance(scope, SymbolTable):
-            return scope.lookup(nameparts[-1])
-        elif isinstance(scope, SubroutineDef):
-            return scope.sub_block.symbols.lookup(nameparts[-1])
-        else:
-            raise SymbolError("invalid block name '{:s}' in dotted name".format(namepart))
-
-    def get_address(self, name: str) -> int:
-        scope, symbol = self.lookup(name)
-        if isinstance(symbol, ConstantDef):
-            raise SymbolError("cannot take the address of a constant")
-        if not symbol or not isinstance(symbol, VariableDef):
-            raise SymbolError("no var or const defined by that name")
-        if symbol.address is None:
-            raise SymbolError("can only take address of memory mapped variables")
-        return symbol.address
-
-    def as_eval_dict(self, ppsymbols: 'SymbolTable') -> Dict[str, Any]:     # @todo type
-        # return a dictionary suitable to be passed as locals or globals to eval()
-        if self.eval_dict is None:
-            d = EvalSymbolDict(self, ppsymbols)
-            self.eval_dict = d      # type: ignore
-        return self.eval_dict
-
-    def iter_variables(self) -> Iterable[VariableDef]:
-        yield from sorted((v for v in self.symbols.values() if isinstance(v, VariableDef)))
-
-    def iter_constants(self) -> Iterable[ConstantDef]:
-        yield from sorted((v for v in self.symbols.values() if isinstance(v, ConstantDef)))
-
-    def iter_subroutines(self, userdefined_only: bool=False) -> Iterable[SubroutineDef]:
-        if userdefined_only:
-            yield from sorted((sub for sub in self.symbols.values()
-                               if isinstance(sub, SubroutineDef) and sub.address is None and sub.sub_block is not None))
-        else:
-            yield from sorted((sub for sub in self.symbols.values() if isinstance(sub, SubroutineDef)))
-
-    def iter_labels(self) -> Iterable[LabelDef]:
-        yield from sorted((v for v in self.symbols.values() if isinstance(v, LabelDef)))
-
-    def remove_node(self, name: str) -> None:
-        del self.symbols[name]
-
-    def check_identifier_valid(self, name: str, sourceref: SourceRef) -> None:
-        if not name.isidentifier():
-            raise SymbolError("invalid identifier")
-        identifier = self.symbols.get(name, None)
-        if identifier:
-            if isinstance(identifier, SymbolDefinition):
-                raise SymbolError("identifier was already defined at " + str(identifier.sourceref))
-            elif isinstance(identifier, SymbolTable):
-                raise SymbolError("identifier already defined as block at " + str(identifier.owning_block.sourceref))
-            raise SymbolError("identifier already defined as " + str(type(identifier)))
-        if name in MATH_SYMBOLS:
-            print("warning: {}: identifier shadows a name from the math module".format(sourceref))
-        elif name in BUILTIN_SYMBOLS:
-            print("warning: {}: identifier shadows a builtin name".format(sourceref))
-
-    def define_variable(self, name: str, sourceref: SourceRef, datatype: DataType, *,
-                        address: int=None, length: int=0, value: PrimitiveType=0,
-                        matrixsize: Tuple[int, int]=None, register: str=None) -> None:
-        # this defines a new variable and also checks if the prefill value is allowed for the variable type.
-        assert value is not None
-        self.check_identifier_valid(name, sourceref)
-        range_error = check_value_in_range(datatype, register, length, value)
-        if range_error:
-            raise ValueError(range_error)
-        allocate = address is None
-        if datatype == DataType.BYTE:
-            if allocate and self.name == "ZP":
-                try:
-                    address = self._zeropage.allocate(name, datatype)
-                except LookupError:
-                    raise SymbolError("no space in ZP left for global 8-bit variable (try zp clobber)")
-            self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.BYTE, allocate,
-                                             value=value, length=1, address=address)
-        elif datatype == DataType.WORD:
-            if allocate and self.name == "ZP":
-                try:
-                    address = self._zeropage.allocate(name, datatype)
-                except LookupError:
-                    raise SymbolError("no space in ZP left for global 16-bit word variable (try zp clobber)")
-            self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.WORD, allocate,
-                                             value=value, length=1, address=address)
-        elif datatype == DataType.FLOAT:
-            if allocate and self.name == "ZP":
-                try:
-                    address = self._zeropage.allocate(name, datatype)
-                except LookupError:
-                    raise SymbolError("no space in ZP left for global 5-byte MFLT float variable (try zp clobber)")
-            sourcecomment = "float " + str(value)
-            self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.FLOAT, allocate,
-                                             value=value, length=1, address=address, sourcecomment=sourcecomment)
-        elif datatype == DataType.BYTEARRAY:
-            self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.BYTEARRAY, allocate,
-                                             value=value, length=length, address=address)
-        elif datatype == DataType.WORDARRAY:
-            self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.WORDARRAY, allocate,
-                                             value=value, length=length, address=address)
-        elif datatype in (DataType.STRING, DataType.STRING_P, DataType.STRING_S, DataType.STRING_PS):
-            self.symbols[name] = VariableDef(self.name, name, sourceref, datatype, True,
-                                             value=value, length=len(value))     # type: ignore
-        elif datatype == DataType.MATRIX:
-            assert isinstance(matrixsize, tuple)
-            length = matrixsize[0] * matrixsize[1]
-            self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.MATRIX, allocate,
-                                             value=value, length=length, address=address, matrixsize=matrixsize)
-        else:
-            raise ValueError("unknown type " + str(datatype))
-        self.eval_dict = None
-
-    def define_sub(self, name: str, sourceref: SourceRef,
-                   parameters: Sequence[Tuple[str, str]], returnvalues: Sequence[str],
-                   address: Optional[int], sub_block: 'Block') -> None:
-        self.check_identifier_valid(name, sourceref)
-        self.symbols[name] = SubroutineDef(self.name, name, sourceref, parameters, returnvalues, address, sub_block)
-
-    def discard_sub(self, name: str) -> None:
-        sub = self.symbols[name]
-        if isinstance(sub, SubroutineDef):
-            del self.symbols[name]
-        else:
-            raise TypeError("not a subroutine")
-
-    def define_label(self, name: str, sourceref: SourceRef) -> None:
-        self.check_identifier_valid(name, sourceref)
-        self.symbols[name] = LabelDef(self.name, name, sourceref, False)
-
-    def define_scope(self, scope: 'SymbolTable', sourceref: SourceRef) -> None:
-        self.check_identifier_valid(scope.name, sourceref)
-        self.symbols[scope.name] = scope
-
-    def define_constant(self, name: str, sourceref: SourceRef, datatype: DataType, *,
-                        length: int=0, value: PrimitiveType=0) -> None:
-        # this defines a new constant and also checks if the value is allowed for the data type.
-        assert value is not None
-        self.check_identifier_valid(name, sourceref)
-        range_error = check_value_in_range(datatype, "", length, value)
-        if range_error:
-            raise ValueError(range_error)
-        if datatype in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
-            self.symbols[name] = ConstantDef(self.name, name, sourceref, datatype, value=value, length=length or 1)
-        elif datatype in STRING_DATATYPES:
-            strlen = len(value)  # type: ignore
-            self.symbols[name] = ConstantDef(self.name, name, sourceref, datatype, value=value, length=strlen)
-        else:
-            raise ValueError("invalid data type for constant: " + str(datatype))
-        self.eval_dict = None
-
-    def merge_roots(self, other_root: 'SymbolTable') -> None:
-        assert self.parent is None and other_root.parent is None
-        for name, thing in other_root.symbols.items():
-            if isinstance(thing, SymbolTable):
-                try:
-                    self.define_scope(thing, thing.owning_block.sourceref)
-                except SymbolError as x:
-                    raise SymbolError("problematic symbol '{:s}' from {}; {:s}"
-                                      .format(thing.name, thing.owning_block.sourceref, str(x))) from None
-
-    def print_table(self) -> None:
-        def print_symbols(symbols: 'SymbolTable', level: int) -> None:
-            indent = '\t' * level
-            print("\n" + indent + "BLOCK:", symbols.name)
-            for name, s in sorted(symbols.symbols.items(), key=lambda x: str(getattr(x[1], "sourceref", ""))):
-                if isinstance(s, SymbolTable):
-                    print_symbols(s, level + 1)
-                elif isinstance(s, SubroutineDef):
-                    print(indent * 2 + "SUB:   " + s.name, s.sourceref, sep="\t")
-                elif isinstance(s, LabelDef):
-                    print(indent * 2 + "LABEL: " + s.name, s.sourceref, sep="\t")
-                elif isinstance(s, VariableDef):
-                    print(indent * 2 + "VAR:   " + s.name, s.sourceref, s.type, sep="\t")
-                elif isinstance(s, ConstantDef):
-                    print(indent * 2 + "CONST: " + s.name, s.sourceref, s.type, sep="\t")
-                else:
-                    raise TypeError("invalid symbol def type", s)
-        print("\nSymbols defined in the symbol table:")
-        print("------------------------------------")
-        print_symbols(self, 0)
-        print()
-
-
-class EvalSymbolDict(dict):
-    def __init__(self, symboltable: SymbolTable, ppsymbols: SymbolTable, constant: bool=True) -> None:
-        super().__init__()
-        self._symboltable = symboltable
-        self._ppsymbols = ppsymbols
-        self._is_constant = constant
-
-    def __getattr__(self, name):
-        return self.__getitem__(name)
-
-    def __getitem__(self, name):
-        if name[0] != '_' and name in builtins.__dict__:
-            return builtins.__dict__[name]
-        try:
-            scope, symbol = self._symboltable.lookup(name)
-        except (LookupError, SymbolError):
-            # attempt lookup from global scope
-            global_scope = self._symboltable
-            while global_scope.parent:
-                global_scope = global_scope.parent
-            try:
-                scope, symbol = global_scope.lookup(name, True)
-            except (LookupError, SymbolError):
-                # try the ppsymbols
-                if self._ppsymbols:
-                    return self._ppsymbols.as_eval_dict(None)[name]
-                raise SymbolError("undefined symbol '{:s}'".format(name)) from None
-        if self._is_constant:
-            if isinstance(symbol, ConstantDef):
-                return symbol.value
-            elif isinstance(symbol, VariableDef):
-                raise SymbolError("can't reference a variable inside a (constant) expression")
-            elif inspect.isbuiltin(symbol):
-                return symbol
-            elif isinstance(symbol, SymbolTable):
-                return symbol.as_eval_dict(self._ppsymbols)
-            elif isinstance(symbol, (LabelDef, SubroutineDef)):
-                raise SymbolError("can't reference a label or subroutine inside a (constant) expression")
-            else:
-                raise SymbolError("invalid symbol type referenced " + repr(symbol))
-        else:
-            raise SymbolError("no support for non-constant expression evaluation yet")
-
-
-def check_value_in_range(datatype: DataType, register: str, length: int, value: PrimitiveType) -> Optional[str]:
-    if register:
-        if register in REGISTER_BYTES:
-            if value < 0 or value > 0xff:  # type: ignore
-                return "value out of range, must be (unsigned) byte for a single register"
-        elif register in REGISTER_SBITS:
-            if value not in (0, 1):
-                return "value out of range, must be 0 or 1 for a status bit register"
-        elif register in REGISTER_WORDS:
-            if value is None and datatype in (DataType.BYTE, DataType.WORD):
-                return None
-            if value < 0 or value > 0xffff:  # type: ignore
-                return "value out of range, must be (unsigned) word for 2 combined registers"
-        else:
-            return "strange register"
-    elif datatype in (DataType.BYTE, DataType.BYTEARRAY, DataType.MATRIX):
-        if value is None and datatype == DataType.BYTE:
-            return None
-        if value < 0 or value > 0xff:       # type: ignore
-            return "value out of range, must be (unsigned) byte"
-    elif datatype in (DataType.WORD, DataType.WORDARRAY):
-        if value is None and datatype in (DataType.BYTE, DataType.WORD):
-            return None
-        if value < 0 or value > 0xffff:     # type: ignore
-            return "value out of range, must be (unsigned) word"
-    elif datatype in STRING_DATATYPES:
-        if type(value) is not str:
-            return "value must be a string"
-    elif datatype == DataType.FLOAT:
-        if type(value) not in (int, float):
-            return "value must be a number"
-    else:
-        raise SymbolError("missing value check for type", datatype, register, length, value)
-    return None  # all ok !
-
-
-def char_to_bytevalue(character: str, petscii: bool=True) -> int:
-    assert len(character) == 1
-    if petscii:
-        return ord(character.translate(ascii_to_petscii_trans))
-    else:
-        raise NotImplementedError("screencode conversion not yet implemented for chars")
-
-
-# ASCII/UNICODE-to-PETSCII translation table
-# Unicode symbols supported that map to a PETSCII character:  £ ↑ ← ♠ ♥ ♦ ♣ π ● ○ and various others
-ascii_to_petscii_trans = str.maketrans({
-    '\f': 147,  # form feed becomes ClearScreen  "{clear}"
-    '\n': 13,   # line feed becomes a RETURN  "{cr}"  (not a line feed)
-    '\r': 17,   # CR becomes CursorDown  "{down}"
-    'a': 65,
-    'b': 66,
-    'c': 67,
-    'd': 68,
-    'e': 69,
-    'f': 70,
-    'g': 71,
-    'h': 72,
-    'i': 73,
-    'j': 74,
-    'k': 75,
-    'l': 76,
-    'm': 77,
-    'n': 78,
-    'o': 79,
-    'p': 80,
-    'q': 81,
-    'r': 82,
-    's': 83,
-    't': 84,
-    'u': 85,
-    'v': 86,
-    'w': 87,
-    'x': 88,
-    'y': 89,
-    'z': 90,
-    'A': 97,
-    'B': 98,
-    'C': 99,
-    'D': 100,
-    'E': 101,
-    'F': 102,
-    'G': 103,
-    'H': 104,
-    'I': 105,
-    'J': 106,
-    'K': 107,
-    'L': 108,
-    'M': 109,
-    'N': 110,
-    'O': 111,
-    'P': 112,
-    'Q': 113,
-    'R': 114,
-    'S': 115,
-    'T': 116,
-    'U': 117,
-    'V': 118,
-    'W': 119,
-    'X': 120,
-    'Y': 121,
-    'Z': 122,
-    '{': 179,       # left squiggle
-    '}': 235,       # right squiggle
-    '£': 92,        # pound currency sign
-    '^': 94,        # up arrow
-    '~': 126,       # pi math symbol
-    'π': 126,       # pi symbol
-    '`': 39,        # single quote
-    '✓': 250,       # check mark
-
-    '|': 221,       # vertical bar
-    '│': 221,       # vertical bar
-    '─': 96,        # horizontal bar
-    '┼': 123,       # vertical and horizontal bar
-
-    '↑': 94,        # up arrow
-    '←': 95,        # left arrow
-
-    '▔': 163,       # upper bar
-    '_': 164,       # lower bar (underscore)
-    '▁': 164,       # lower bar
-    '▎': 165,       # left bar
-
-    '♠': 97,        # spades
-    '●': 113,       # circle
-    '♥': 115,       # hearts
-    '○': 119,       # open circle
-    '♣': 120,       # clubs
-    '♦': 122,       # diamonds
-
-    '├': 171,       # vertical and right
-    '┤': 179,       # vertical and left
-    '┴': 177,       # horiz and up
-    '┬': 178,       # horiz and down
-    '└': 173,       # up right
-    '┐': 174,       # down left
-    '┌': 175,       # down right
-    '┘': 189,       # up left
-    '▗': 172,       # block lr
-    '▖': 187,       # block ll
-    '▝': 188,       # block ur
-    '▘': 190,       # block ul
-    '▚': 191,       # block ul and lr
-    '▌': 161,       # left half
-    '▄': 162,       # lower half
-    '▒': 230,       # raster
-})
-
-
-class AstNode:
-    __slots__ = ["sourceref"]
-
-    def __init__(self, sourceref: SourceRef) -> None:
-        self.sourceref = sourceref
-
-    @property
-    def lineref(self) -> str:
-        return "src l. " + str(self.sourceref.line)
-
-    def print_tree(self) -> None:
-        def tostr(node: AstNode, level: int) -> None:
-            if not isinstance(node, AstNode):
-                return
-            indent = "   " * level
-            name = getattr(node, "name", "")
-            print(indent, node.__class__.__name__, repr(name))
-            try:
-                variables = vars(node).items()
-            except TypeError:
-                pass
-            else:
-                for name, value in variables:
-                    if isinstance(value, AstNode):
-                        tostr(value, level + 1)
-                    if isinstance(value, (list, tuple, set)):
-                        if len(value) > 0:
-                            elt = list(value)[0]
-                            if isinstance(elt, AstNode) or name == "nodes":
-                                print(indent, "  >", name, "=")
-                                for elt in value:
-                                    tostr(elt, level + 2)
-        tostr(self, 0)
-
-
-class Block(AstNode):
-    _unnamed_block_labels = {}  # type: Dict[Block, str]
-
-    def __init__(self, name: str, sourceref: SourceRef, parent_scope: SymbolTable, preserve_registers: bool=False) -> None:
-        super().__init__(sourceref)
-        self.address = 0
-        self.name = name
-        self.statements = []  # type: List[AstNode]
-        self.symbols = SymbolTable(name, parent_scope, self)
-        self.preserve_registers = preserve_registers
-
-    @property
-    def ignore(self) -> bool:
-        return not self.name and not self.address
-
-    @property
-    def label_names(self) -> Set[str]:
-        return {symbol.name for symbol in self.symbols.iter_labels()}
-
-    @property
-    def label(self) -> str:
-        if self.name:
-            return self.name
-        if self in self._unnamed_block_labels:
-            return self._unnamed_block_labels[self]
-        label = "il65_block_{:d}".format(len(self._unnamed_block_labels))
-        self._unnamed_block_labels[self] = label
-        return label
-
-    def lookup(self, dottedname: str) -> Tuple[Optional['Block'], Optional[Union[SymbolDefinition, SymbolTable]]]:
-        # Searches a name in the current block or globally, if the name is scoped (=contains a '.').
-        # Does NOT utilize a symbol table from a preprocessing parse phase, only looks in the current.
-        try:
-            scope, result = self.symbols.lookup(dottedname)
-            return scope.owning_block, result
-        except (SymbolError, LookupError):
-            return None, None
-
-    def all_statements(self) -> Generator[Tuple['Block', Optional[SubroutineDef], AstNode], None, None]:
-        for stmt in self.statements:
-            yield self, None, stmt
-        for sub in self.symbols.iter_subroutines(True):
-            for stmt in sub.sub_block.statements:
-                yield sub.sub_block, sub, stmt
-
-
-class Value(AstNode):
-    def __init__(self, datatype: DataType, sourceref: SourceRef, name: str = None, constant: bool = False) -> None:
-        super().__init__(sourceref)
-        self.datatype = datatype
-        self.name = name
-        self.constant = constant
-
-    def assignable_from(self, other: 'Value') -> Tuple[bool, str]:
-        if self.constant:
-            return False, "cannot assign to a constant"
-        return False, "incompatible value for assignment"
-
-
-class IndirectValue(Value):
-    # only constant integers, memmapped and register values are wrapped in this.
-    def __init__(self, value: Value, type_modifier: DataType, sourceref: SourceRef) -> None:
-        assert type_modifier
-        super().__init__(type_modifier, sourceref, value.name, False)
-        self.value = value
-
-    def __str__(self):
-        return "<IndirectValue {} itype={} name={}>".format(self.value, self.datatype, self.name)
-
-    def __hash__(self):
-        return hash((self.datatype, self.name, self.value))
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, IndirectValue):
-            return NotImplemented
-        elif self is other:
-            return True
-        else:
-            vvo = getattr(other.value, "value", getattr(other.value, "address", None))
-            vvs = getattr(self.value, "value", getattr(self.value, "address", None))
-            return (other.datatype, other.name, other.value.name, other.value.datatype, other.value.constant, vvo) == \
-                   (self.datatype, self.name, self.value.name, self.value.datatype, self.value.constant, vvs)
-
-    def assignable_from(self, other: Value) -> Tuple[bool, str]:
-        if self.constant:
-            return False, "cannot assign to a constant"
-        if self.datatype == DataType.BYTE:
-            if other.datatype == DataType.BYTE:
-                return True, ""
-        if self.datatype == DataType.WORD:
-            if other.datatype in {DataType.BYTE, DataType.WORD} | STRING_DATATYPES:
-                return True, ""
-        if self.datatype == DataType.FLOAT:
-            if other.datatype in {DataType.BYTE, DataType.WORD, DataType.FLOAT}:
-                return True, ""
-        if isinstance(other, (IntegerValue, FloatValue, StringValue)):
-            rangefault = check_value_in_range(self.datatype, "", 1, other.value)
-            if rangefault:
-                return False, rangefault
-            return True, ""
-        return False, "incompatible value for indirect assignment (need byte, word, float or string)"
-
-
-class IntegerValue(Value):
-    def __init__(self, value: Optional[int], sourceref: SourceRef, *, datatype: DataType = None, name: str = None) -> None:
-        if type(value) is int:
-            if datatype is None:
-                if 0 <= value < 0x100:
-                    datatype = DataType.BYTE
-                elif value < 0x10000:
-                    datatype = DataType.WORD
-                else:
-                    raise OverflowError("value too big: ${:x}".format(value))
-            else:
-                faultreason = check_value_in_range(datatype, "", 1, value)
-                if faultreason:
-                    raise OverflowError(faultreason)
-            super().__init__(datatype, sourceref, name, True)
-            self.value = value
-        elif value is None:
-            if not name:
-                raise ValueError("when integer value is not given, the name symbol must be specified")
-            super().__init__(datatype, sourceref, name, True)
-            self.value = None
-        else:
-            raise TypeError("invalid data type")
-
-    def __hash__(self):
-        return hash((self.datatype, self.value, self.name))
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, IntegerValue):
-            return NotImplemented
-        elif self is other:
-            return True
-        else:
-            return (other.datatype, other.value, other.name) == (self.datatype, self.value, self.name)
-
-    def __str__(self):
-        return "<IntegerValue {} name={}>".format(self.value, self.name)
-
-    def negative(self) -> 'IntegerValue':
-        return IntegerValue(-self.value, self.sourceref, datatype=self.datatype, name=self.name)
-
-
-class FloatValue(Value):
-    def __init__(self, value: float, sourceref: SourceRef, name: str = None) -> None:
-        if type(value) is float:
-            super().__init__(DataType.FLOAT, sourceref, name, True)
-            self.value = value
-        else:
-            raise TypeError("invalid data type")
-
-    def __hash__(self):
-        return hash((self.datatype, self.value, self.name))
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, FloatValue):
-            return NotImplemented
-        elif self is other:
-            return True
-        else:
-            return (other.datatype, other.value, other.name) == (self.datatype, self.value, self.name)
-
-    def __str__(self):
-        return "<FloatValue {} name={}>".format(self.value, self.name)
-
-    def negative(self) -> 'FloatValue':
-        return FloatValue(-self.value, self.sourceref, name=self.name)
-
-
-class StringValue(Value):
-    def __init__(self, value: str, sourceref: SourceRef, name: str = None, constant: bool = False) -> None:
-        super().__init__(DataType.STRING, sourceref, name, constant)
-        self.value = value
-
-    def __hash__(self):
-        return hash((self.datatype, self.value, self.name, self.constant))
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, StringValue):
-            return NotImplemented
-        elif self is other:
-            return True
-        else:
-            return (other.datatype, other.value, other.name, other.constant) == (self.datatype, self.value, self.name, self.constant)
-
-    def __str__(self):
-        return "<StringValue {!r:s} name={} constant={}>".format(self.value, self.name, self.constant)
-
-
-class RegisterValue(Value):
-    def __init__(self, register: str, datatype: DataType, sourceref: SourceRef, name: str = None) -> None:
-        assert datatype in (DataType.BYTE, DataType.WORD)
-        assert register in REGISTER_SYMBOLS
-        super().__init__(datatype, sourceref, name, False)
-        self.register = register
-
-    def __hash__(self):
-        return hash((self.datatype, self.register, self.name))
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, RegisterValue):
-            return NotImplemented
-        elif self is other:
-            return True
-        else:
-            return (other.datatype, other.register, other.name) == (self.datatype, self.register, self.name)
-
-    def __str__(self):
-        return "<RegisterValue {:s} type {:s} name={}>".format(self.register, self.datatype, self.name)
-
-    def assignable_from(self, other: Value) -> Tuple[bool, str]:
-        if isinstance(other, IndirectValue):
-            if self.datatype == DataType.BYTE:
-                if other.datatype == DataType.BYTE:
-                    return True, ""
-                return False, "(unsigned) byte required"
-            if self.datatype == DataType.WORD:
-                if other.datatype in (DataType.BYTE, DataType.WORD):
-                    return True, ""
-                return False, "(unsigned) byte required"
-            return False, "incompatible indirect value for register assignment"
-        if self.register in ("SC", "SI"):
-            if isinstance(other, IntegerValue) and other.value in (0, 1):
-                return True, ""
-            return False, "can only assign an integer constant value of 0 or 1 to SC and SI"
-        if self.constant:
-            return False, "cannot assign to a constant"
-        if isinstance(other, RegisterValue):
-            if other.register in {"SI", "SC", "SZ"}:
-                return False, "cannot explicitly assign from a status bit register alias"
-            if len(self.register) < len(other.register):
-                return False, "register size mismatch"
-        if isinstance(other, StringValue) and self.register in REGISTER_BYTES | REGISTER_SBITS:
-            return False, "string address requires 16 bits combined register"
-        if isinstance(other, IntegerValue):
-            if other.value is not None:
-                range_error = check_value_in_range(self.datatype, self.register, 1, other.value)
-                if range_error:
-                    return False, range_error
-                return True, ""
-            if self.datatype == DataType.WORD:
-                return True, ""
-            return False, "cannot assign address to single register"
-        if isinstance(other, FloatValue):
-            range_error = check_value_in_range(self.datatype, self.register, 1, other.value)
-            if range_error:
-                return False, range_error
-            return True, ""
-        if self.datatype == DataType.BYTE:
-            if other.datatype != DataType.BYTE:
-                return False, "(unsigned) byte required"
-            return True, ""
-        if self.datatype == DataType.WORD:
-            if other.datatype in (DataType.BYTE, DataType.WORD) or other.datatype in STRING_DATATYPES:
-                return True, ""
-            return False, "(unsigned) byte, word or string required"
-        return False, "incompatible value for register assignment"
-
-
-class MemMappedValue(Value):
-    def __init__(self, address: Optional[int], datatype: DataType, length: int,
-                 sourceref: SourceRef, name: str = None, constant: bool = False) -> None:
-        super().__init__(datatype, sourceref, name, constant)
-        self.address = address
-        self.length = length
-        assert address is None or type(address) is int
-
-    def __hash__(self):
-        return hash((self.datatype, self.address, self.length, self.name, self.constant))
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, MemMappedValue):
-            return NotImplemented
-        elif self is other:
-            return True
-        else:
-            return (other.datatype, other.address, other.length, other.name, other.constant) == \
-                   (self.datatype, self.address, self.length, self.name, self.constant)
-
-    def __str__(self):
-        addr = "" if self.address is None else "${:04x}".format(self.address)
-        return "<MemMappedValue {:s} type={:s} #={:d} name={} constant={}>" \
-            .format(addr, self.datatype, self.length, self.name, self.constant)
-
-    def assignable_from(self, other: Value) -> Tuple[bool, str]:
-        if self.constant:
-            return False, "cannot assign to a constant"
-        if isinstance(other, IndirectValue):
-            if self.datatype == other.datatype:
-                return True, ""
-            return False, "data type of value and target are not the same"
-        if self.datatype == DataType.BYTE:
-            if isinstance(other, (IntegerValue, RegisterValue, MemMappedValue)):
-                if other.datatype == DataType.BYTE:
-                    return True, ""
-                return False, "(unsigned) byte required"
-            elif isinstance(other, FloatValue):
-                range_error = check_value_in_range(self.datatype, "", 1, other.value)
-                if range_error:
-                    return False, range_error
-                return True, ""
-            else:
-                return False, "(unsigned) byte required"
-        elif self.datatype in (DataType.WORD, DataType.FLOAT):
-            if isinstance(other, (IntegerValue, FloatValue)):
-                range_error = check_value_in_range(self.datatype, "", 1, other.value)
-                if range_error:
-                    return False, range_error
-                return True, ""
-            elif isinstance(other, (RegisterValue, MemMappedValue)):
-                if other.datatype in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
-                    return True, ""
-                else:
-                    return False, "byte or word or float required"
-            elif isinstance(other, StringValue):
-                if self.datatype == DataType.WORD:
-                    return True, ""
-                return False, "string address requires 16 bits (a word)"
-            if self.datatype == DataType.BYTE:
-                return False, "(unsigned) byte required"
-            if self.datatype == DataType.WORD:
-                return False, "(unsigned) word required"
-        return False, "incompatible value for assignment"
-
-
-class Comment(AstNode):
-    def __init__(self, text: str, sourceref: SourceRef) -> None:
-        super().__init__(sourceref)
-        self.text = text
-
-
-class Label(AstNode):
-    def __init__(self, name: str, sourceref: SourceRef) -> None:
-        super().__init__(sourceref)
-        self.name = name
-
-
-class AssignmentStmt(AstNode):
-    def __init__(self, leftvalues: List[Value], right: Value, sourceref: SourceRef) -> None:
-        super().__init__(sourceref)
-        self.leftvalues = leftvalues
-        self.right = right
-
-    def __str__(self):
-        return "<Assign {:s} to {:s}>".format(str(self.right), ",".join(str(lv) for lv in self.leftvalues))
-
-    def remove_identity_lvalues(self) -> None:
-        for lv in self.leftvalues:
-            if lv == self.right:
-                print("{}: removed identity assignment".format(self.sourceref))
-        remaining_leftvalues = [lv for lv in self.leftvalues if lv != self.right]
-        self.leftvalues = remaining_leftvalues
-
-    def is_identity(self) -> bool:
-        return all(lv == self.right for lv in self.leftvalues)
-
-
-class AugmentedAssignmentStmt(AssignmentStmt):
-    SUPPORTED_OPERATORS = {"+=", "-=", "&=", "|=", "^=", ">>=", "<<="}
-
-    # full set: {"+=", "-=", "*=", "/=", "%=", "//=", "**=", "&=", "|=", "^=", ">>=", "<<="}
-
-    def __init__(self, left: Value, operator: str, right: Value, sourceref: SourceRef) -> None:
-        assert operator in self.SUPPORTED_OPERATORS
-        super().__init__([left], right, sourceref)
-        self.operator = operator
-
-    def __str__(self):
-        return "<AugAssign {:s} {:s} {:s}>".format(str(self.leftvalues[0]), self.operator, str(self.right))
-
-
-class ReturnStmt(AstNode):
-    def __init__(self, sourceref: SourceRef, a: Optional[Value] = None,
-                 x: Optional[Value] = None,
-                 y: Optional[Value] = None) -> None:
-        super().__init__(sourceref)
-        self.a = a
-        self.x = x
-        self.y = y
-
-
-class InplaceIncrStmt(AstNode):
-    def __init__(self, what: Value, value: Union[IntegerValue, FloatValue], sourceref: SourceRef) -> None:
-        super().__init__(sourceref)
-        assert value.constant
-        assert (value.value is None and value.name) or value.value > 0
-        self.what = what
-        self.value = value
-
-
-class InplaceDecrStmt(AstNode):
-    def __init__(self, what: Value, value: Union[IntegerValue, FloatValue], sourceref: SourceRef) -> None:
-        super().__init__(sourceref)
-        assert value.constant
-        assert (value.value is None and value.name) or value.value > 0
-        self.what = what
-        self.value = value
-
-
-class IfCondition(AstNode):
-    SWAPPED_OPERATOR = {"==": "==",
-                        "!=": "!=",
-                        "<=": ">=",
-                        ">=": "<=",
-                        "<": ">",
-                        ">": "<"}
-    IF_STATUSES = {"cc", "cs", "vc", "vs", "eq", "ne", "true", "not", "zero", "pos", "neg", "lt", "gt", "le", "ge"}
-
-    def __init__(self, ifstatus: str, leftvalue: Optional[Value],
-                 operator: str, rightvalue: Optional[Value], sourceref: SourceRef) -> None:
-        assert ifstatus in self.IF_STATUSES
-        assert operator in (None, "") or operator in self.SWAPPED_OPERATOR
-        if operator:
-            assert ifstatus in ("true", "not", "zero")
-        super().__init__(sourceref)
-        self.ifstatus = ifstatus
-        self.lvalue = leftvalue
-        self.comparison_op = operator
-        self.rvalue = rightvalue
-
-    def __str__(self):
-        return "<IfCondition if_{:s} {} {:s} {}>".format(self.ifstatus, self.lvalue, self.comparison_op, self.rvalue)
-
-    def make_if_true(self) -> bool:
-        # makes a condition of the form if_not a < b  into: if a > b (gets rid of the not)
-        # returns whether the change was made or not
-        if self.ifstatus == "not" and self.comparison_op:
-            self.ifstatus = "true"
-            self.comparison_op = self.SWAPPED_OPERATOR[self.comparison_op]
-            return True
-        return False
-
-    def swap(self) -> Tuple[Value, str, Value]:
-        self.lvalue, self.comparison_op, self.rvalue = self.rvalue, self.SWAPPED_OPERATOR[self.comparison_op], self.lvalue
-        return self.lvalue, self.comparison_op, self.rvalue
-
-
-class CallStmt(AstNode):
-    def __init__(self, sourceref: SourceRef, target: Optional[Value] = None, *,
-                 address: Optional[int] = None, arguments: List[Tuple[str, Any]] = None,
-                 outputs: List[Tuple[str, Value]] = None, is_goto: bool = False,
-                 preserve_regs: Set[str] = None, condition: IfCondition = None) -> None:
-        if not is_goto:
-            assert condition is None
-        super().__init__(sourceref)
-        self.target = target
-        self.address = address
-        self.arguments = arguments
-        self.outputvars = outputs
-        self.is_goto = is_goto
-        self.condition = condition
-        self.preserve_regs = preserve_regs
-        self.desugared_call_arguments = []  # type: List[AssignmentStmt]
-        self.desugared_output_assignments = []  # type: List[AssignmentStmt]
-
-
-class InlineAsm(AstNode):
-    def __init__(self, asmlines: List[str], sourceref: SourceRef) -> None:
-        super().__init__(sourceref)
-        self.asmlines = asmlines
-
-
-class BreakpointStmt(AstNode):
-    def __init__(self, sourceref: SourceRef) -> None:
-        super().__init__(sourceref)
diff --git a/il65/main_old.py b/il65/main_old.py
deleted file mode 100644
index e770a24d0..000000000
--- a/il65/main_old.py
+++ /dev/null
@@ -1,65 +0,0 @@
-"""
-Programming Language for 6502/6510 microprocessors, codename 'Sick'
-This is the main program that drives the rest.
-
-Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-"""
-
-import time
-import os
-import argparse
-import subprocess
-from .handwritten.parse import Parser
-from .handwritten.optimize import Optimizer
-from .handwritten.preprocess import PreprocessingParser
-from .handwritten.codegen import CodeGenerator, Assembler64Tass
-
-
-def main() -> None:
-    description = "Compiler for IL65 language, code name 'Sick'"
-    ap = argparse.ArgumentParser(description=description)
-    ap.add_argument("-o", "--output", help="output directory")
-    ap.add_argument("-no", "--nooptimize", action="store_true", help="do not optimize the parse tree")
-    ap.add_argument("-sv", "--startvice", action="store_true", help="autostart vice x64 emulator after compilation")
-    ap.add_argument("sourcefile", help="the source .ill/.il65 file to compile")
-    args = ap.parse_args()
-    assembly_filename = os.path.splitext(args.sourcefile)[0] + ".asm"
-    program_filename = os.path.splitext(args.sourcefile)[0] + ".prg"
-    if args.output:
-        os.makedirs(args.output, mode=0o700, exist_ok=True)
-        assembly_filename = os.path.join(args.output, os.path.split(assembly_filename)[1])
-        program_filename = os.path.join(args.output, os.path.split(program_filename)[1])
-
-    print("\n" + description)
-
-    start = time.perf_counter()
-    pp = PreprocessingParser(args.sourcefile, set())
-    sourcelines, symbols = pp.preprocess()
-    # symbols.print_table()
-
-    p = Parser(args.sourcefile, args.output, set(), sourcelines=sourcelines, ppsymbols=symbols, sub_usage=pp.result.subroutine_usage)
-    parsed = p.parse()
-    if parsed:
-        if args.nooptimize:
-            p.print_bold("not optimizing the parse tree!")
-        else:
-            opt = Optimizer(parsed)
-            parsed = opt.optimize()
-        cg = CodeGenerator(parsed)
-        cg.generate()
-        cg.optimize()
-        with open(assembly_filename, "wt") as out:
-            cg.write_assembly(out)
-        assembler = Assembler64Tass(parsed.format)
-        assembler.assemble(assembly_filename, program_filename)
-        mon_command_file = assembler.generate_breakpoint_list(program_filename)
-        duration_total = time.perf_counter() - start
-        print("Compile duration:  {:.2f} seconds".format(duration_total))
-        p.print_bold("Output file:       " + program_filename)
-        print()
-        if args.startvice:
-            print("Autostart vice emulator...")
-            cmdline = ["x64", "-remotemonitor", "-moncommands", mon_command_file,
-                       "-autostartprgmode", "1", "-autostart-warp", "-autostart", program_filename]
-            with open(os.devnull, "wb") as shutup:
-                subprocess.call(cmdline, stdout=shutup)
diff --git a/il65/handwritten/codegen.py b/il65/oldstuff/codegen.py
similarity index 96%
rename from il65/handwritten/codegen.py
rename to il65/oldstuff/codegen.py
index be0137d29..c09a460ea 100644
--- a/il65/handwritten/codegen.py
+++ b/il65/oldstuff/codegen.py
@@ -1869,79 +1869,3 @@ class CodeGenerator:
             self.p("\t\tsta  {}+1".format(assign_target))
         else:
             raise CodeError("cannot assign immediate string, it must be a string variable")
-
-    def footer(self) -> None:
-        self.p("\n\n.end")
-
-    def output_string(self, value: str, screencodes: bool = False) -> str:
-        if len(value) == 1 and screencodes:
-            if value[0].isprintable() and ord(value[0]) < 128:
-                return "'{:s}'".format(value[0])
-            else:
-                return str(ord(value[0]))
-        result = '"'
-        for char in value:
-            if char in "{}":
-                result += '", {:d}, "'.format(ord(char))
-            elif char.isprintable() and ord(char) < 128:
-                result += char
-            else:
-                if screencodes:
-                    result += '", {:d}, "'.format(ord(char))
-                else:
-                    if char == '\f':
-                        result += "{clear}"
-                    elif char == '\b':
-                        result += "{delete}"
-                    elif char == '\n':
-                        result += "{cr}"
-                    elif char == '\r':
-                        result += "{down}"
-                    elif char == '\t':
-                        result += "{tab}"
-                    else:
-                        result += '", {:d}, "'.format(ord(char))
-        return result + '"'
-
-
-class Assembler64Tass:
-    def __init__(self, format: ProgramFormat) -> None:
-        self.format = format
-
-    def assemble(self, inputfilename: str, outputfilename: str) -> None:
-        args = ["64tass", "--ascii", "--case-sensitive", "-Wall", "-Wno-strict-bool",
-                "--dump-labels", "--vice-labels", "-l", outputfilename+".vice-mon-list",
-                "-L", outputfilename+".final-asm", "--no-monitor", "--output", outputfilename, inputfilename]
-        if self.format == ProgramFormat.PRG:
-            args.append("--cbm-prg")
-        elif self.format == ProgramFormat.RAW:
-            args.append("--nostart")
-        else:
-            raise ValueError("don't know how to create format "+str(self.format))
-        try:
-            if self.format == ProgramFormat.PRG:
-                print("\ncreating C-64 prg")
-            elif self.format == ProgramFormat.RAW:
-                print("\ncreating raw binary")
-            try:
-                subprocess.check_call(args)
-            except FileNotFoundError as x:
-                raise SystemExit("ERROR: cannot run assembler program: "+str(x))
-        except subprocess.CalledProcessError as x:
-            raise SystemExit("assembler failed with returncode " + str(x.returncode))
-
-    def generate_breakpoint_list(self, program_filename: str) -> str:
-        breakpoints = []
-        with open(program_filename + ".final-asm", "rU") as f:
-            for line in f:
-                match = re.fullmatch(CodeGenerator.BREAKPOINT_COMMENT_DETECTOR, line, re.DOTALL)
-                if match:
-                    breakpoints.append("$" + match.group("address"))
-        cmdfile = program_filename + ".vice-mon-list"
-        with open(cmdfile, "at") as f:
-            print("; vice monitor breakpoint list now follows", file=f)
-            print("; {:d} breakpoints have been defined here".format(len(breakpoints)), file=f)
-            print("del", file=f)
-            for b in breakpoints:
-                print("break", b, file=f)
-        return cmdfile
diff --git a/tests/test_zp.py b/tests/test_zp.py
index 8b87799c1..ac87ce6f1 100644
--- a/tests/test_zp.py
+++ b/tests/test_zp.py
@@ -1,65 +1,74 @@
 import pytest
 from il65.compile import Zeropage, CompileError
-from il65.plyparse import ZpOptions
+from il65.plyparse import ZpOptions, VarDef
+from il65.plylex import SourceRef
 from il65.datatypes import DataType
 
 
 def test_zp_names():
+    sref = SourceRef("test", 1, 1)
     zp = Zeropage(ZpOptions.NOCLOBBER)
-    zp.allocate("", DataType.BYTE)
-    zp.allocate("", DataType.BYTE)
-    zp.allocate("varname", DataType.BYTE)
     with pytest.raises(AssertionError):
-        zp.allocate("varname", DataType.BYTE)
-    zp.allocate("varname2", DataType.BYTE)
+        zp.allocate(VarDef(name="", vartype="memory", datatype=DataType.BYTE, sourceref=sref))
+    zp.allocate(VarDef(name="", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    zp.allocate(VarDef(name="", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    zp.allocate(VarDef(name="varname", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    with pytest.raises(AssertionError):
+        zp.allocate(VarDef(name="varname", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    zp.allocate(VarDef(name="varname2", vartype="var", datatype=DataType.BYTE, sourceref=sref))
 
 
 def test_zp_noclobber_allocation():
+    sref = SourceRef("test", 1, 1)
     zp = Zeropage(ZpOptions.NOCLOBBER)
     assert zp.available() == 9
     with pytest.raises(CompileError):
-        zp.allocate("impossible", DataType.FLOAT)     # in regular zp there aren't 5 sequential bytes free
+        # in regular zp there aren't 5 sequential bytes free
+        zp.allocate(VarDef(name="impossible", vartype="var", datatype=DataType.FLOAT, sourceref=sref))
     for i in range(zp.available()):
-        loc = zp.allocate("bytevar"+str(i), DataType.BYTE)
+        loc = zp.allocate(VarDef(name="bvar"+str(i), vartype="var", datatype=DataType.BYTE, sourceref=sref))
         assert loc > 0
     assert zp.available() == 0
     with pytest.raises(CompileError):
-        zp.allocate("", DataType.BYTE)
+        zp.allocate(VarDef(name="", vartype="var", datatype=DataType.BYTE, sourceref=sref))
     with pytest.raises(CompileError):
-        zp.allocate("", DataType.WORD)
+        zp.allocate(VarDef(name="", vartype="var", datatype=DataType.WORD, sourceref=sref))
 
 
 def test_zp_clobber_allocation():
+    sref = SourceRef("test", 1, 1)
     zp = Zeropage(ZpOptions.CLOBBER)
     assert zp.available() == 239
-    loc = zp.allocate("", DataType.FLOAT)
+    loc = zp.allocate(VarDef(name="", vartype="var", datatype=DataType.FLOAT, sourceref=sref))
     assert loc > 3 and loc not in zp.free
     num, rest = divmod(zp.available(), 5)
     for _ in range(num-3):
-        zp.allocate("", DataType.FLOAT)
+        zp.allocate(VarDef(name="", vartype="var", datatype=DataType.FLOAT, sourceref=sref))
     assert zp.available() == 19
     with pytest.raises(CompileError):
-        zp.allocate("", DataType.FLOAT)     # can't allocate because no more sequential bytes, only fragmented
+        # can't allocate because no more sequential bytes, only fragmented
+        zp.allocate(VarDef(name="", vartype="var", datatype=DataType.FLOAT, sourceref=sref))
     for _ in range(14):
-        zp.allocate("", DataType.BYTE)
-    zp.allocate("", DataType.WORD)
-    zp.allocate("", DataType.WORD)
+        zp.allocate(VarDef(name="", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    zp.allocate(VarDef(name="", vartype="var", datatype=DataType.WORD, sourceref=sref))
+    zp.allocate(VarDef(name="", vartype="var", datatype=DataType.WORD, sourceref=sref))
     with pytest.raises(CompileError):
-        zp.allocate("", DataType.WORD)
+        zp.allocate(VarDef(name="", vartype="var", datatype=DataType.WORD, sourceref=sref))
     assert zp.available() == 1
-    zp.allocate("last", DataType.BYTE)
+    zp.allocate(VarDef(name="last", vartype="var", datatype=DataType.BYTE, sourceref=sref))
     with pytest.raises(CompileError):
-        zp.allocate("impossible", DataType.BYTE)
+        zp.allocate(VarDef(name="impossible", vartype="var", datatype=DataType.BYTE, sourceref=sref))
 
 
 def test_zp_efficient_allocation():
     # free = [0x04, 0x05, 0x06, 0x2a, 0x52, 0xf7, 0xf8, 0xf9, 0xfa]
+    sref = SourceRef("test", 1, 1)
     zp = Zeropage(ZpOptions.NOCLOBBER)
     assert zp.available() == 9
-    assert 0x2a == zp.allocate("", DataType.BYTE)
-    assert 0x52 == zp.allocate("", DataType.BYTE)
-    assert 0x04 == zp.allocate("", DataType.WORD)
-    assert 0xf7 == zp.allocate("", DataType.WORD)
-    assert 0x06 == zp.allocate("", DataType.BYTE)
-    assert 0xf9 == zp.allocate("", DataType.WORD)
+    assert 0x2a == zp.allocate(VarDef(name="", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    assert 0x52 == zp.allocate(VarDef(name="", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    assert 0x04 == zp.allocate(VarDef(name="", vartype="var", datatype=DataType.WORD, sourceref=sref))
+    assert 0xf7 == zp.allocate(VarDef(name="", vartype="var", datatype=DataType.WORD, sourceref=sref))
+    assert 0x06 == zp.allocate(VarDef(name="", vartype="var", datatype=DataType.BYTE, sourceref=sref))
+    assert 0xf9 == zp.allocate(VarDef(name="", vartype="var", datatype=DataType.WORD, sourceref=sref))
     assert zp.available() == 0