--- a/python/baselex.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +0,0 @@
-
-import re
-from ppci import Token, CompilerError, SourceLocation
-from pyyacc import EOF
-
-
-class BaseLexer:
-    """ Base class for a lexer. This class can be overridden to create a
-        lexer. This class handles the regular expression generation and
-        source position accounting.
-    """
-    def __init__(self, tok_spec):
-        tok_re = '|'.join('(?P<{}>{})'.format(pair[0], pair[1]) for pair in tok_spec)
-        self.gettok = re.compile(tok_re).match
-        self.func_map = {pair[0]: pair[2] for pair in tok_spec}
-        self.filename = None
-
-    def feed(self, txt):
-        """ Feeds the lexer with extra input """
-        self.tokens = self.tokenize(txt)
-
-    def tokenize(self, txt):
-        """ Generator that generates tokens from text
-            It does not yield the EOF token.
-        """
-        self.line = 1
-        self.line_start = 0
-        self.pos = 0
-        mo = self.gettok(txt)
-        while mo:
-            typ = mo.lastgroup
-            val = mo.group(typ)
-            column = mo.start() - self.line_start
-            length = mo.end() - mo.start()
-            loc = SourceLocation(self.filename, self.line, column, length)
-            func = self.func_map[typ]
-            if func:
-                res = func(typ, val)
-                if res:
-                    typ, val = res
-                    yield Token(typ, val, loc)
-            self.pos = mo.end()
-            mo = self.gettok(txt, self.pos)
-        if len(txt) != self.pos:
-            raise CompilerError('Lex fault at {}'.format(txt[self.pos:]))
-
-    def newline(self):
-        """ Enters a new line """
-        self.line_start = self.pos
-        self.line = self.line + 1
-
-    def next_token(self):
-        try:
-            return self.tokens.__next__()
-        except StopIteration:
-            loc = SourceLocation(self.filename, self.line, 0, 0)
-            return Token(EOF, EOF, loc)

--- a/python/burg.x	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,31 +0,0 @@
-
-%tokens ':' ';' '(' ')' ',' string id number '%%' '%terminal' header
-
-%%
-
-burgdef: header '%%' directives '%%' rules { self.system.header_lines = $1.val };
-
-directives:
-          | directives directive;
-
-directive: termdef;
-
-termdef: '%terminal' termids;
-
-termids:
-       | termids termid;
-
-termid: id { self.system.add_terminal($1.val) };
-
-rules:
-     | rules rule;
-
-rule: id ':' tree cost string { self.system.add_rule($1.val, $3, $4, None, $5.val) };
-rule: id ':' tree cost string string { self.system.add_rule($1.val, $3, $4, $5.val, $6.val) };
-
-cost: number { return $1.val };
-
-tree: id { return self.system.tree($1.val) }
-    | id '(' tree ')' { return self.system.tree($1.val, $3) }
-    | id '(' tree ',' tree ')' { return self.system.tree($1.val, $3, $5) };
-

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/python/c3c.py	Mon Jul 14 22:23:55 2014 +0200
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+import sys
+import argparse
+import logging
+
+from ppci.buildfunctions import c3toir
+import ppci.buildtasks  # Include not used, but it registers build tasks.
+import ppci
+from zcc import logLevel
+
+
+def make_parser():
+    parser = argparse.ArgumentParser(description='c3 Compiler')
+
+    parser.add_argument('--log', help='Log level (INFO,DEBUG,[WARN])',
+                        type=logLevel, default='INFO')
+
+    parser.add_argument('--target', help='target machine', default="arm")
+    parser.add_argument('-o', '--output', help='target machine',
+        type=argparse.FileType('w'), default=sys.stdout)
+    parser.add_argument('-i', '--include', action='append',
+        help='include file', default=[])
+    parser.add_argument('sources', metavar='source',
+        help='source file', nargs='+')
+    return parser
+
+
+def main(args):
+    # Configure some logging:
+    logging.getLogger().setLevel(logging.DEBUG)
+    ch = logging.StreamHandler()
+    ch.setFormatter(logging.Formatter(ppci.logformat))
+    ch.setLevel(args.log)
+    logging.getLogger().addHandler(ch)
+
+    res = c3toir(args.sources, args.include, args.target)
+    writer = ppci.irutils.Writer()
+    for ir_module in res:
+        writer.write(ir_module, args.output)
+
+    logging.getLogger().removeHandler(ch)
+    return res
+
+
+if __name__ == '__main__':
+    parser = make_parser()
+    arguments = parser.parse_args()
+    sys.exit(main(arguments))

--- a/python/ppci/__init__.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-# File to make this directory a package.
-
-import sys
-import os
-
-version = '0.0.1'
-
-# Assert python version:
-if sys.version_info.major != 3:
-   print("Needs to be run in python version 3.x")
-   sys.exit(1)
-
-from .common import SourceLocation, SourceRange, Token
-from .common import CompilerError, DiagnosticsManager
-
-logformat='%(asctime)s|%(levelname)s|%(name)s|%(message)s'
-
-def same_dir(full_path, filename):
-    return os.path.join(os.path.dirname(os.path.abspath(full_path)), filename)
-
-
-def make_num(txt):
-    if txt.startswith('0x'):
-        return int(txt[2:], 16)
-    else:
-        return int(txt)
-

--- a/python/ppci/assembler.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,133 +0,0 @@
-
-import re
-import pyyacc
-from baselex import BaseLexer
-from . import Token, CompilerError, SourceLocation, make_num
-from .target import Target, Label
-
-
-def bit_type(value):
-    assert value < (2**32)
-    assert value >= 0
-    t = 'val32'
-    for n in [16, 12, 8, 5, 3]:
-        if value < (2**n):
-            t = 'val{}'.format(n)
-    return t
-
-
-class AsmLexer(BaseLexer):
-    def __init__(self, kws):
-        tok_spec = [
-           ('REAL', r'\d+\.\d+', lambda typ, val: (typ, float(val))),
-           ('HEXNUMBER', r'0x[\da-fA-F]+', self.handle_number),
-           ('NUMBER', r'\d+', self.handle_number),
-           ('ID', r'[A-Za-z][A-Za-z\d_]*', self.handle_id),
-           ('SKIP', r'[ \t]', None),
-           ('LEESTEKEN', r':=|[\.,=:\-+*\[\]/\(\)]|>=|<=|<>|>|<|}|{', lambda typ, val: (val, val)),
-           ('STRING', r"'.*?'", lambda typ, val: (typ, val[1:-1])),
-           ('COMMENT', r";.*", None)
-        ]
-        super().__init__(tok_spec)
-        self.kws = kws
-
-    def handle_id(self, typ, val):
-        if val.lower() in self.kws:
-            typ = val.lower()
-        return (typ, val)
-
-    def handle_number(self, typ, val):
-        val = make_num(val)
-        typ = bit_type(val)
-        return typ, val
-
-
-class Parser:
-    def add_rule(self, prod, rhs, f):
-        """ Helper function to add a rule, why this is required? """
-        if prod == 'instruction':
-            def f_wrap(*args):
-                i = f(args)
-                if i:
-                    self.emit(i)
-        else:
-            def f_wrap(*rhs):
-                return f(rhs)
-        self.g.add_production(prod, rhs, f_wrap)
-
-    def __init__(self, kws, instruction_rules, emit):
-        # Construct a parser given a grammar:
-        tokens2 = ['ID', 'NUMBER', ',', '[', ']', ':', '+', '-', '*', '=',
-                   pyyacc.EPS, 'COMMENT', '{', '}',
-                   pyyacc.EOF, 'val32', 'val16', 'val12', 'val8', 'val5', 'val3']
-        tokens2.extend(kws)
-        self.kws = kws
-        g = pyyacc.Grammar(tokens2)
-        self.g = g
-        # Global structure of assembly line:
-        g.add_production('asmline', ['asmline2'])
-        g.add_production('asmline', ['asmline2', 'COMMENT'])
-        g.add_production('asmline2', ['label', 'instruction'])
-        g.add_production('asmline2', ['instruction'])
-        g.add_production('asmline2', ['label'])
-        g.add_production('asmline2', [])
-        g.add_production('label', ['ID', ':'], self.p_label)
-
-        # Add instruction rules for the target in question:
-        for prod, rhs, f in instruction_rules:
-            self.add_rule(prod, rhs, f)
-
-        #g.add_production('instruction', [])
-        g.start_symbol = 'asmline'
-        self.emit = emit
-        self.p = g.generate_parser()
-        # print('length of table:', len(self.p.action_table))
-
-    # Parser handlers:
-
-    def p_label(self, lname, cn):
-        lab = Label(lname.val)
-        self.emit(lab)
-
-    def parse(self, lexer):
-        self.p.parse(lexer)
-
-
-class BaseAssembler:
-    """ Assembler base class, inherited by assemblers specific for a target """
-    def __init__(self, target):
-        self.target = target
-        assert isinstance(target, Target)
-
-    def make_parser(self):
-        self.parser = Parser(self.target.asm_keywords, self.target.assembler_rules, self.emit)
-        self.lexer = AsmLexer(self.target.asm_keywords)
-
-    def prepare(self):
-        pass
-
-    def emit(self, *args):
-        self.stream.emit(*args)
-
-    # Top level interface:
-    def parse_line(self, line):
-        """ Parse line into assembly instructions """
-        self.lexer.feed(line)
-        self.parser.parse(self.lexer)
-
-    def assemble(self, asmsrc, stream):
-        """ Assemble this source snippet """
-        if type(asmsrc) is str:
-            pass
-        elif hasattr(asmsrc, 'read'):
-            asmsrc2 = asmsrc.read()
-            asmsrc.close()
-            asmsrc = asmsrc2
-        # TODO: use generic newline??
-        # TODO: the bothersome newline ...
-        self.stream = stream
-        for line in asmsrc.split('\n'):
-            self.parse_line(line)
-
-    def flush(self):
-        pass

--- a/python/ppci/bitfun.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,25 +0,0 @@
-
-
-def rotate_right(v, n):
-    """ bit-wise Rotate right n times """
-    mask = (2**n) - 1
-    mask_bits = v & mask
-    return (v >> n) | (mask_bits << (32 - n))
-
-def rotate_left(v, n):
-    assert n >= 0
-    assert n < 32
-    return rotate_right(v, 32 - n)
-
-def encode_imm32(v):
-    """ Bundle 32 bit value into 4 bits rotation and 8 bits value
-     """
-    for i in range(0, 16):
-        v2 = rotate_left(v, i*2)
-        if (v2 & 0xFFFFFF00) == 0:
-            rotation = i
-            val = v2 & 0xFF
-            x = (rotation << 8) | val
-            return x
-    raise Exception("Invalid value {}".format(v))
-

--- a/python/ppci/buildfunctions.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,152 +0,0 @@
-
-"""
-    This module contains a set of handy functions to invoke compilation,
-        linking
-    and assembling.
-"""
-
-import logging
-from .target import Target
-from .c3 import Builder
-from .irutils import Verifier
-from .codegen import CodeGenerator
-from .transform import CleanPass, RemoveAddZero
-from .linker import Linker
-from .layout import Layout, load_layout
-from .target.target_list import targets
-from .outstream import BinaryOutputStream
-from .objectfile import ObjectFile, load_object
-from . import DiagnosticsManager
-from .tasks import TaskError, TaskRunner
-from .recipe import RecipeLoader
-
-
-def fix_target(tg):
-    """ Try to return an instance of the Target class """
-    if isinstance(tg, Target):
-        return tg
-    elif isinstance(tg, str):
-        if tg in targets:
-            return targets[tg]
-    raise TaskError('Invalid target {}'.format(tg))
-
-
-def fix_file(f):
-    """ Determine if argument is a file like object or make it so! """
-    if hasattr(f, 'read'):
-        # Assume this is a file like object
-        return f
-    elif isinstance(f, str):
-        return open(f, 'r')
-    else:
-        raise TaskError('cannot use {} as input'.format(f))
-
-
-def fix_object(o):
-    if isinstance(o, ObjectFile):
-        return o
-    elif isinstance(o, str):
-        with open(o, 'r') as f:
-            return load_object(f)
-    else:
-        raise TaskError('Cannot use {} as objectfile'.format(o))
-
-
-def fix_layout(l):
-    if isinstance(l, Layout):
-        return l
-    elif hasattr(l, 'read'):
-        # Assume file handle
-        return load_layout(l)
-    elif isinstance(l, str):
-        with open(l, 'r') as f:
-            return load_layout(f)
-    else:
-        raise TaskError('Cannot use {} as layout'.format(l))
-
-
-def construct(buildfile, targets=[]):
-    recipe_loader = RecipeLoader()
-    try:
-        project = recipe_loader.load_file(buildfile)
-    except OSError:
-        raise TaskError('Could not construct {}'.format(buildfile))
-        project = None
-
-    if project:
-        runner = TaskRunner()
-        res = runner.run(project, targets)
-    else:
-        res = 1
-
-    return res
-
-
-def assemble(source, target):
-    """ Invoke the assembler on the given source, returns an object containing
-        the output. """
-    logger = logging.getLogger('assemble')
-    target = fix_target(target)
-    source = fix_file(source)
-    output = ObjectFile()
-    assembler = target.assembler
-    logger.debug('Assembling into code section')
-    ostream = BinaryOutputStream(output)
-    ostream.select_section('code')
-    assembler.prepare()
-    assembler.assemble(source, ostream)
-    assembler.flush()
-    return output
-
-
-def c3compile(sources, includes, target):
-    """ Compile a set of sources for the given target """
-    logger = logging.getLogger('c3c')
-    logger.debug('C3 compilation started')
-    target = fix_target(target)
-    sources = [fix_file(fn) for fn in sources]
-    includes = [fix_file(fn) for fn in includes]
-    output = ObjectFile()
-    diag = DiagnosticsManager()
-    c3b = Builder(diag, target)
-    cg = CodeGenerator(target)
-
-    output_stream = BinaryOutputStream(output)
-
-    for ircode in c3b.build(sources, includes):
-        if not ircode:
-            # Something went wrong, do not continue the code generation
-            continue
-
-        d = {'ircode': ircode}
-        logger.debug('Verifying code {}'.format(ircode), extra=d)
-        Verifier().verify(ircode)
-
-        # Optimization passes:
-        CleanPass().run(ircode)
-        Verifier().verify(ircode)
-        RemoveAddZero().run(ircode)
-        Verifier().verify(ircode)
-        CleanPass().run(ircode)
-        Verifier().verify(ircode)
-
-        # Code generation:
-        d = {'ircode': ircode}
-        logger.debug('Starting code generation for {}'.format(ircode), extra=d)
-
-        cg.generate(ircode, output_stream)
-
-    if not c3b.ok:
-        diag.printErrors()
-        raise TaskError('Compile errors')
-    return output
-
-
-def link(objects, layout, target):
-    """ Links the iterable of objects into one using the given layout """
-    objects = list(map(fix_object, objects))
-    layout = fix_layout(layout)
-    target = fix_target(target)
-    linker = Linker(target)
-    output_obj = linker.link(objects, layout)
-    return output_obj

--- a/python/ppci/buildtasks.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,115 +0,0 @@
-
-"""
-Defines task classes that can compile, link etc..
-Task can depend upon one another.
-"""
-
-from .tasks import Task, TaskError, register_task
-from .buildfunctions import c3compile, link, assemble, fix_object, construct
-from pyyacc import ParserException
-from . import CompilerError
-
-
-@register_task("empty")
-class EmptyTask(Task):
-    """ Basic task that does nothing """
-    def run(self):
-        pass
-
-
-@register_task("echo")
-class EchoTask(Task):
-    """ Simple task that echoes a message """
-    def run(self):
-        message = self.arguments['message']
-        print(message)
-
-
-@register_task("property")
-class Property(Task):
-    """ Sets a property to a value """
-    def run(self):
-        name = self.arguments['name']
-        value = self.arguments['value']
-        self.target.project.set_property(name, value)
-
-
-@register_task("build")
-class ConstructTask(Task):
-    """ Builds another build description file (build.xml) """
-    def run(self):
-        project = self.get_argument('file')
-        construct(project)
-
-
-@register_task("assemble")
-class AssembleTask(Task):
-    """ Task that can runs the assembler over the source and enters the
-        output into an object file """
-
-    def run(self):
-        target = self.get_argument('target')
-        source = self.relpath(self.get_argument('source'))
-        output_filename = self.relpath(self.get_argument('output'))
-
-        try:
-            output = assemble(source, target)
-        except ParserException as e:
-            raise TaskError('Error during assembly:' + str(e))
-        except CompilerError as e:
-            raise TaskError('Error during assembly:' + str(e))
-        except OSError as e:
-            raise TaskError('Error:' + str(e))
-        with open(output_filename, 'w') as f:
-            output.save(f)
-        self.logger.debug('Assembling finished')
-
-
-@register_task("compile")
-class C3cTask(Task):
-    """ Task that compiles C3 source for some target into an object file """
-    def run(self):
-        target = self.get_argument('target')
-        sources = self.open_file_set(self.arguments['sources'])
-        output_filename = self.relpath(self.get_argument('output'))
-        if 'includes' in self.arguments:
-            includes = self.open_file_set(self.arguments['includes'])
-        else:
-            includes = []
-
-        output = c3compile(sources, includes, target)
-        # Store output:
-        with open(output_filename, 'w') as output_file:
-            output.save(output_file)
-
-
-@register_task("link")
-class LinkTask(Task):
-    """ Link together a collection of object files """
-    def run(self):
-        layout = self.relpath(self.get_argument('layout'))
-        target = self.get_argument('target')
-        objects = self.open_file_set(self.get_argument('objects'))
-        output_filename = self.relpath(self.get_argument('output'))
-
-        try:
-            output_obj = link(objects, layout, target)
-        except CompilerError as e:
-            raise TaskError(e.msg)
-
-        # Store output:
-        with open(output_filename, 'w') as output_file:
-            output_obj.save(output_file)
-
-
-@register_task("objcopy")
-class ObjCopyTask(Task):
-    def run(self):
-        image_name = self.get_argument('imagename')
-        output_filename = self.relpath(self.get_argument('output'))
-        object_filename = self.relpath(self.get_argument('objectfile'))
-
-        obj = fix_object(object_filename)
-        image = obj.get_image(image_name)
-        with open(output_filename, 'wb') as output_file:
-            output_file.write(image)

--- a/python/ppci/c3/__init__.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-""" This is the C3 language front end. """
-
-from .parser import Parser
-from .lexer import Lexer
-from .codegenerator import CodeGenerator
-from .visitor import Visitor
-from .visitor import AstPrinter
-from .builder import Builder

--- a/python/ppci/c3/astnodes.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,421 +0,0 @@
-"""
-AST (abstract syntax tree) nodes for the c3 language.
-The tree is build by the parser.
-Then it is checked
-Finally code is generated from it.
-"""
-
-
-class Node:
-    """ Base class of all nodes in a AST """
-    pass
-
-
-# Variables, parameters, local variables, constants and named types:
-class Symbol(Node):
-    """ Symbol is the base class for all named things like variables,
-        functions, constants and types and modules """
-    def __init__(self, name):
-        self.name = name
-        self.refs = []
-
-    def addRef(self, r):
-        self.refs.append(r)
-
-    @property
-    def References(self):
-        return self.refs
-
-
-# Modules
-class Package(Symbol):
-    def __init__(self, name, loc):
-        super().__init__(name)
-        self.loc = loc
-        self.declarations = []
-        self.imports = []
-
-    def add_declaration(self, decl):
-        self.declarations.append(decl)
-        if isinstance(decl, Function):
-            decl.package = self
-
-    @property
-    def Types(self):
-        return self.innerScope.Types
-
-    @property
-    def Functions(self):
-        return self.innerScope.Functions
-
-    def __repr__(self):
-        return 'MODULE {}'.format(self.name)
-
-
-class Type(Node):
-    """ Base class of all types """
-    pass
-
-
-class NamedType(Type, Symbol):
-    """ Some types are named, for example a user defined type (typedef)
-        and built in types. That is why this class derives from both Type
-        and Symbol. """
-    def __init__(self, name):
-        Symbol.__init__(self, name)
-
-
-class BaseType(NamedType):
-    """ Built in type """
-    def __init__(self, name):
-        super().__init__(name)
-
-    def __repr__(self):
-        return '{}'.format(self.name)
-
-
-class FunctionType(Type):
-    """ Function blueprint, defines argument types and return type """
-    def __init__(self, parametertypes, returntype):
-        self.parametertypes = parametertypes
-        self.returntype = returntype
-
-    def __repr__(self):
-        params = ', '.join([str(v) for v in self.parametertypes])
-        return '{1} f({0})'.format(params, self.returntype)
-
-
-class PointerType(Type):
-    """ A type that points to data of some other type """
-    def __init__(self, ptype):
-        assert isinstance(ptype, Type) or isinstance(ptype, Expression)
-        self.ptype = ptype
-
-    def __repr__(self):
-        return '({}*)'.format(self.ptype)
-
-
-class StructField:
-    """ Field of a struct type """
-    def __init__(self, name, typ):
-        assert type(name) is str
-        self.name = name
-        self.typ = typ
-
-    def __repr__(self):
-        return 'Member {}'.format(self.name)
-
-
-class StructureType(Type):
-    """ Struct type consisting of several named members """
-    def __init__(self, mems):
-        self.mems = mems
-        assert all(type(mem) is StructField for mem in mems)
-
-    def hasField(self, name):
-        for mem in self.mems:
-            if name == mem.name:
-                return True
-        return False
-
-    def fieldType(self, name):
-        return self.findField(name).typ
-
-    def fieldOffset(self, name):
-        return self.findField(name).offset
-
-    def findField(self, name):
-        for mem in self.mems:
-            if name == mem.name:
-                return mem
-        raise KeyError(name)
-
-    def __repr__(self):
-        return 'STRUCT'
-
-
-class ArrayType(Type):
-    """ Array type """
-    def __init__(self, element_type, size):
-        self.element_type = element_type
-        self.size = size
-
-    def __repr__(self):
-        return 'ARRAY {}'.format(self.size)
-
-
-class DefinedType(NamedType):
-    """ A named type indicating another type """
-    def __init__(self, name, typ, loc):
-        assert isinstance(name, str)
-        super().__init__(name)
-        self.typ = typ
-        self.loc = loc
-
-    def __repr__(self):
-        return 'Named type {0} of type {1}'.format(self.name, self.typ)
-
-
-class Constant(Symbol):
-    """ Constant definition """
-    def __init__(self, name, typ, value):
-        super().__init__(name)
-        self.typ = typ
-        self.value = value
-
-    def __repr__(self):
-        return 'CONSTANT {0} = {1}'.format(self.name, self.value)
-
-
-class Variable(Symbol):
-    def __init__(self, name, typ):
-        super().__init__(name)
-        self.typ = typ
-        self.isLocal = False
-        self.isParameter = False
-
-    def __repr__(self):
-        return 'Var {} [{}]'.format(self.name, self.typ)
-
-
-class LocalVariable(Variable):
-    def __init__(self, name, typ):
-        super().__init__(name, typ)
-        self.isLocal = True
-
-
-class FormalParameter(Variable):
-    def __init__(self, name, typ):
-        super().__init__(name, typ)
-        self.isParameter = True
-
-
-# Procedure types
-class Function(Symbol):
-    """ Actual implementation of a function """
-    def __init__(self, name, loc):
-        super().__init__(name)
-        self.loc = loc
-        self.declarations = []
-
-    def add_declaration(self, decl):
-        self.declarations.append(decl)
-
-    def __repr__(self):
-        return 'Func {}'.format(self.name)
-
-
-# Operations / Expressions:
-class Expression(Node):
-    def __init__(self, loc):
-        self.loc = loc
-
-
-class Sizeof(Expression):
-    def __init__(self, typ, loc):
-        super().__init__(loc)
-        self.query_typ = typ
-
-
-class Deref(Expression):
-    def __init__(self, ptr, loc):
-        super().__init__(loc)
-        assert isinstance(ptr, Expression)
-        self.ptr = ptr
-
-    def __repr__(self):
-        return 'DEREF {}'.format(self.ptr)
-
-
-class TypeCast(Expression):
-    def __init__(self, to_type, x, loc):
-        super().__init__(loc)
-        self.to_type = to_type
-        self.a = x
-
-    def __repr__(self):
-        return 'TYPECAST {}'.format(self.to_type)
-
-
-class Member(Expression):
-    """ Field reference of some object, can also be package selection """
-    def __init__(self, base, field, loc):
-        super().__init__(loc)
-        assert isinstance(base, Expression)
-        assert isinstance(field, str)
-        self.base = base
-        self.field = field
-
-    def __repr__(self):
-        return 'MEMBER {}.{}'.format(self.base, self.field)
-
-
-class Index(Expression):
-    """ Index something, for example an array """
-    def __init__(self, base, i, loc):
-        super().__init__(loc)
-        self.base = base
-        self.i = i
-
-    def __repr__(self):
-        return 'Index {}'.format(self.i)
-
-
-class Unop(Expression):
-    """ Operation on one operand """
-    def __init__(self, op, a, loc):
-        super().__init__(loc)
-        assert isinstance(a, Expression)
-        assert isinstance(op, str)
-        self.a = a
-        self.op = op
-
-    def __repr__(self):
-        return 'UNOP {}'.format(self.op)
-
-
-class Binop(Expression):
-    """ Expression taking two operands and one operator """
-    def __init__(self, a, op, b, loc):
-        super().__init__(loc)
-        assert isinstance(a, Expression), type(a)
-        assert isinstance(b, Expression)
-        assert isinstance(op, str)
-        self.a = a
-        self.b = b
-        self.op = op   # Operation: '+', '-', '*', '/', 'mod'
-
-    def __repr__(self):
-        return 'BINOP {}'.format(self.op)
-
-
-class Identifier(Expression):
-    """ Reference to some identifier, can be anything from package, variable
-        function or type, any named thing! """
-    def __init__(self, target, loc):
-        super().__init__(loc)
-        self.target = target
-
-    def __repr__(self):
-        return 'ID {}'.format(self.target)
-
-
-class Literal(Expression):
-    """ Constant value or string """
-    def __init__(self, val, loc):
-        super().__init__(loc)
-        self.val = val
-
-    def __repr__(self):
-        return 'LITERAL {}'.format(self.val)
-
-
-class FunctionCall(Expression):
-    """ Call to a some function """
-    def __init__(self, proc, args, loc):
-        super().__init__(loc)
-        self.proc = proc
-        self.args = args
-
-    def __repr__(self):
-        return 'CALL {0} '.format(self.proc)
-
-
-# Statements
-class Statement(Node):
-    """ Base class of all statements """
-    def __init__(self, loc):
-        self.loc = loc
-
-
-class Empty(Statement):
-    """ Empty statement which does nothing! """
-    def __init__(self):
-        super().__init__(None)
-
-    def __repr__(self):
-        return 'NOP'
-
-
-class Compound(Statement):
-    """ Statement consisting of a sequence of other statements """
-    def __init__(self, statements):
-        super().__init__(None)
-        self.statements = statements
-        for s in self.statements:
-            assert isinstance(s, Statement)
-
-    def __repr__(self):
-        return 'COMPOUND STATEMENT'
-
-
-class Return(Statement):
-    def __init__(self, expr, loc):
-        super().__init__(loc)
-        self.expr = expr
-
-    def __repr__(self):
-        return 'RETURN STATEMENT'
-
-
-class Assignment(Statement):
-    def __init__(self, lval, rval, loc):
-        super().__init__(loc)
-        assert isinstance(lval, Expression)
-        assert isinstance(rval, Expression)
-        self.lval = lval
-        self.rval = rval
-
-    def __repr__(self):
-        return 'ASSIGNMENT'
-
-
-class ExpressionStatement(Statement):
-    def __init__(self, ex, loc):
-        super().__init__(loc)
-        self.ex = ex
-
-    def __repr__(self):
-        return 'Epression'
-
-
-class If(Statement):
-    def __init__(self, condition, truestatement, falsestatement, loc):
-        super().__init__(loc)
-        self.condition = condition
-        self.truestatement = truestatement
-        self.falsestatement = falsestatement
-
-    def __repr__(self):
-        return 'IF-statement'
-
-
-class Switch(Statement):
-    def __init__(self, condition, loc):
-        super().__init__(loc)
-        self.condition = condition
-
-    def __repr__(self):
-        return 'Switch on {}'.format(self.condition)
-
-
-class While(Statement):
-    def __init__(self, condition, statement, loc):
-        super().__init__(loc)
-        self.condition = condition
-        self.statement = statement
-
-    def __repr__(self):
-        return 'WHILE-statement'
-
-
-class For(Statement):
-    def __init__(self, init, condition, final, statement, loc):
-        super().__init__(loc)
-        self.init = init
-        self.condition = condition
-        self.final = final
-        self.statement = statement
-
-    def __repr__(self):
-        return 'FOR-statement'

--- a/python/ppci/c3/builder.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,139 +0,0 @@
-import logging
-from .lexer import Lexer
-from .parser import Parser
-from .codegenerator import CodeGenerator
-from .scope import createTopScope, Scope
-from .visitor import AstPrinter, Visitor
-from .astnodes import Package, Function, Identifier, Symbol
-
-
-class C3Pass:
-    def __init__(self, diag):
-        self.diag = diag
-        self.logger = logging.getLogger('c3')
-        self.visitor = Visitor()
-
-    def error(self, msg, loc=None):
-        self.pkg.ok = False
-        self.diag.error(msg, loc)
-
-    def visit(self, pkg, pre, post):
-        self.visitor.visit(pkg, pre, post)
-
-
-class ScopeFiller(C3Pass):
-    scoped_types = [Package, Function]
-
-    def __init__(self, diag, topScope, packages):
-        super().__init__(diag)
-        self.topScope = topScope
-        self.packages = packages
-
-    """ Scope is attached to the correct modules. """
-    def addScope(self, pkg):
-        self.logger.debug('Adding scoping to package {}'.format(pkg.name))
-        self.pkg = pkg
-        # Prepare top level scope and set scope to all objects:
-        self.scopeStack = [self.topScope]
-        modScope = Scope(self.CurrentScope)
-        self.scopeStack.append(modScope)
-        self.visit(pkg, self.enterScope, self.quitScope)
-        assert len(self.scopeStack) == 2
-
-        self.logger.debug('Resolving imports for package {}'.format(pkg.name))
-        # Handle imports:
-        for i in pkg.imports:
-            if i not in self.packages:
-                self.error('Cannot import {}'.format(i))
-                continue
-            pkg.scope.addSymbol(self.packages[i])
-
-    @property
-    def CurrentScope(self):
-        return self.scopeStack[-1]
-
-    def addSymbol(self, sym):
-        if self.CurrentScope.hasSymbol(sym.name):
-            self.error('Redefinition of {0}'.format(sym.name), sym.loc)
-        else:
-            self.CurrentScope.addSymbol(sym)
-
-    def enterScope(self, sym):
-        # Attach scope to references:
-        if type(sym) is Identifier:
-            sym.scope = self.CurrentScope
-
-        # Add symbols to current scope:
-        if isinstance(sym, Symbol):
-            self.addSymbol(sym)
-            sym.scope = self.CurrentScope
-
-        # Create subscope for items creating a scope:
-        if type(sym) in self.scoped_types:
-            newScope = Scope(self.CurrentScope)
-            self.scopeStack.append(newScope)
-            sym.innerScope = self.CurrentScope
-
-    def quitScope(self, sym):
-        # Pop out of scope:
-        if type(sym) in self.scoped_types:
-            self.scopeStack.pop(-1)
-
-
-class Builder:
-    """
-        Generates IR-code from c3 source.
-        Reports errors to the diagnostics system.
-    """
-    def __init__(self, diag, target):
-        self.logger = logging.getLogger('c3')
-        self.diag = diag
-        self.lexer = Lexer(diag)
-        self.parser = Parser(diag)
-        self.cg = CodeGenerator(diag)
-        self.topScope = createTopScope(target)  # Scope with built in types
-
-    def build(self, srcs, imps=[]):
-        """ Create IR-code from sources """
-        self.logger.debug('Building {} source files'.format(len(srcs + imps)))
-        iter(srcs)  # Check if srcs are iterable
-        iter(imps)
-        self.ok = True
-        self.pkgs = {}
-
-        # Lexing and parsing stage (phase 1)
-        def doParse(src):
-            tokens = self.lexer.lex(src)
-            pkg = self.parser.parseSource(tokens)
-            return pkg
-        s_pkgs = list(map(doParse, srcs))
-        i_pkgs = list(map(doParse, imps))
-        all_pkgs = s_pkgs + i_pkgs
-        if not all(all_pkgs):
-            self.ok = False
-            self.logger.debug('Parsing failed')
-            return
-
-        self.logger.debug('Parsed {} packages'.format(len(all_pkgs)))
-
-        # Fix scopes and package refs (phase 1.5)
-        packages = {pkg.name: pkg for pkg in all_pkgs}
-        self.pkgs = packages
-
-        scopeFiller = ScopeFiller(self.diag, self.topScope, packages)
-        # Fix scopes:
-        for pkg in all_pkgs:
-            scopeFiller.addScope(pkg)
-        if not all(pkg.ok for pkg in all_pkgs):
-            self.ok = False
-            self.logger.debug('Scope filling failed')
-            return
-
-        # Generate intermediate code (phase 2)
-        # Only return ircode when everything is OK
-        for pkg in s_pkgs:
-            yield self.cg.gencode(pkg)
-        if not all(pkg.ok for pkg in all_pkgs):
-            self.logger.debug('Code generation failed')
-            self.ok = False
-        self.logger.debug('C3 build complete!')

--- a/python/ppci/c3/codegenerator.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,552 +0,0 @@
-import logging
-import struct
-from .. import ir
-from .. import irutils
-from . import astnodes as ast
-
-
-class SemanticError(Exception):
-    """ Error thrown when a semantic issue is observed """
-    def __init__(self, msg, loc):
-        super().__init__()
-        self.msg = msg
-        self.loc = loc
-
-
-class CodeGenerator:
-    """
-      Generates intermediate (IR) code from a package. The entry function is
-      'genModule'. The main task of this part is to rewrite complex control
-      structures, such as while and for loops into simple conditional
-      jump statements. Also complex conditional statements are simplified.
-      Such as 'and' and 'or' statements are rewritten in conditional jumps.
-      And structured datatypes are rewritten.
-
-      Type checking is done in one run with code generation.
-    """
-    def __init__(self, diag):
-        self.logger = logging.getLogger('c3cgen')
-        self.builder = irutils.Builder()
-        self.diag = diag
-
-    def gencode(self, pkg):
-        """ Generate code for a single module """
-        self.builder.prepare()
-        assert type(pkg) is ast.Package
-        self.pkg = pkg
-        self.intType = pkg.scope['int']
-        self.boolType = pkg.scope['bool']
-        self.pointerSize = 4
-        self.logger.debug('Generating ir-code for {}'.format(pkg.name),
-                          extra={'c3_ast': pkg})
-        self.varMap = {}    # Maps variables to storage locations.
-        self.builder.m = ir.Module(pkg.name)
-        try:
-            for typ in pkg.Types:
-                self.check_type(typ)
-            # Only generate function if function contains a body:
-            real_functions = list(filter(
-                lambda f: f.body, pkg.Functions))
-            for v in pkg.innerScope.Variables:
-                v2 = ir.GlobalVariable(v.name, ir.i32)
-                self.varMap[v] = v2
-                if not v.isLocal:
-                    self.builder.m.add_variable(v2)
-            for s in real_functions:
-                self.gen_function(s)
-        except SemanticError as e:
-            self.error(e.msg, e.loc)
-        if self.pkg.ok:
-            return self.builder.m
-
-    def error(self, msg, loc=None):
-        self.pkg.ok = False
-        self.diag.error(msg, loc)
-
-    def gen_function(self, fn):
-        # TODO: handle arguments
-        f = self.builder.new_function(fn.name)
-        f.return_value = self.builder.newTemp()
-        self.builder.setFunction(f)
-        l2 = self.builder.newBlock()
-        self.builder.emit(ir.Jump(l2))
-        self.builder.setBlock(l2)
-        # generate room for locals:
-
-        for sym in fn.innerScope:
-            self.check_type(sym.typ)
-            if sym.isParameter:
-                p = ir.Parameter(sym.name, ir.i32)
-                variable = ir.LocalVariable(sym.name + '_copy', ir.i32)
-                f.addParameter(p)
-                f.addLocal(variable)
-                # Move parameter into local copy:
-                self.builder.emit(ir.Move(ir.Mem(variable), p))
-            elif sym.isLocal:
-                variable = ir.LocalVariable(sym.name, ir.i32)
-                f.addLocal(variable)
-            elif isinstance(sym, ast.Variable):
-                variable = ir.LocalVariable(sym.name, ir.i32)
-                f.addLocal(variable)
-            else:
-                raise NotImplementedError('{}'.format(sym))
-            self.varMap[sym] = variable
-
-        self.gen_stmt(fn.body)
-        self.builder.emit(ir.Move(f.return_value, ir.Const(0)))
-        self.builder.emit(ir.Jump(f.epiloog))
-        self.builder.setFunction(None)
-
-    def gen_stmt(self, code):
-        """ Generate code for a statement """
-        try:
-            assert isinstance(code, ast.Statement)
-            self.builder.setLoc(code.loc)
-            if type(code) is ast.Compound:
-                for s in code.statements:
-                    self.gen_stmt(s)
-            elif type(code) is ast.Empty:
-                pass
-            elif type(code) is ast.Assignment:
-                self.gen_assignment_stmt(code)
-            elif type(code) is ast.ExpressionStatement:
-                self.builder.emit(ir.Exp(self.gen_expr_code(code.ex)))
-            elif type(code) is ast.If:
-                self.gen_if_stmt(code)
-            elif type(code) is ast.Return:
-                re = self.gen_expr_code(code.expr)
-                self.builder.emit(ir.Move(self.builder.fn.return_value, re))
-                self.builder.emit(ir.Jump(self.builder.fn.epiloog))
-                b = self.builder.newBlock()
-                self.builder.setBlock(b)
-            elif type(code) is ast.While:
-                self.gen_while(code)
-            elif type(code) is ast.For:
-                self.gen_for_stmt(code)
-            elif type(code) is ast.Switch:
-                raise NotImplementedError('Unknown stmt {}'.format(code))
-            else:
-                raise NotImplementedError('Unknown stmt {}'.format(code))
-        except SemanticError as e:
-            self.error(e.msg, e.loc)
-
-    def gen_assignment_stmt(self, code):
-        """ Generate code for assignment statement """
-        lval = self.gen_expr_code(code.lval)
-        rval = self.gen_expr_code(code.rval)
-        if not self.equal_types(code.lval.typ, code.rval.typ):
-            raise SemanticError('Cannot assign {} to {}'
-                                .format(code.rval.typ, code.lval.typ),
-                                code.loc)
-        if not code.lval.lvalue:
-            raise SemanticError('No valid lvalue {}'.format(code.lval),
-                                code.lval.loc)
-        self.builder.emit(ir.Move(lval, rval))
-
-    def gen_if_stmt(self, code):
-        """ Generate code for if statement """
-        true_block = self.builder.newBlock()
-        bbfalse = self.builder.newBlock()
-        te = self.builder.newBlock()
-        self.gen_cond_code(code.condition, true_block, bbfalse)
-        self.builder.setBlock(true_block)
-        self.gen_stmt(code.truestatement)
-        self.builder.emit(ir.Jump(te))
-        self.builder.setBlock(bbfalse)
-        self.gen_stmt(code.falsestatement)
-        self.builder.emit(ir.Jump(te))
-        self.builder.setBlock(te)
-
-    def gen_while(self, code):
-        """ Generate code for while statement """
-        bbdo = self.builder.newBlock()
-        test_block = self.builder.newBlock()
-        final_block = self.builder.newBlock()
-        self.builder.emit(ir.Jump(test_block))
-        self.builder.setBlock(test_block)
-        self.gen_cond_code(code.condition, bbdo, final_block)
-        self.builder.setBlock(bbdo)
-        self.gen_stmt(code.statement)
-        self.builder.emit(ir.Jump(test_block))
-        self.builder.setBlock(final_block)
-
-    def gen_for_stmt(self, code):
-        """ Generate for statement code """
-        bbdo = self.builder.newBlock()
-        test_block = self.builder.newBlock()
-        final_block = self.builder.newBlock()
-        self.gen_stmt(code.init)
-        self.builder.emit(ir.Jump(test_block))
-        self.builder.setBlock(test_block)
-        self.gen_cond_code(code.condition, bbdo, final_block)
-        self.builder.setBlock(bbdo)
-        self.gen_stmt(code.statement)
-        self.gen_stmt(code.final)
-        self.builder.emit(ir.Jump(test_block))
-        self.builder.setBlock(final_block)
-
-    def gen_cond_code(self, expr, bbtrue, bbfalse):
-        """ Generate conditional logic.
-            Implement sequential logical operators. """
-        if type(expr) is ast.Binop:
-            if expr.op == 'or':
-                l2 = self.builder.newBlock()
-                self.gen_cond_code(expr.a, bbtrue, l2)
-                if not self.equal_types(expr.a.typ, self.boolType):
-                    raise SemanticError('Must be boolean', expr.a.loc)
-                self.builder.setBlock(l2)
-                self.gen_cond_code(expr.b, bbtrue, bbfalse)
-                if not self.equal_types(expr.b.typ, self.boolType):
-                    raise SemanticError('Must be boolean', expr.b.loc)
-            elif expr.op == 'and':
-                l2 = self.builder.newBlock()
-                self.gen_cond_code(expr.a, l2, bbfalse)
-                if not self.equal_types(expr.a.typ, self.boolType):
-                    self.error('Must be boolean', expr.a.loc)
-                self.builder.setBlock(l2)
-                self.gen_cond_code(expr.b, bbtrue, bbfalse)
-                if not self.equal_types(expr.b.typ, self.boolType):
-                    raise SemanticError('Must be boolean', expr.b.loc)
-            elif expr.op in ['==', '>', '<', '!=', '<=', '>=']:
-                ta = self.gen_expr_code(expr.a)
-                tb = self.gen_expr_code(expr.b)
-                if not self.equal_types(expr.a.typ, expr.b.typ):
-                    raise SemanticError('Types unequal {} != {}'
-                                        .format(expr.a.typ, expr.b.typ),
-                                        expr.loc)
-                self.builder.emit(ir.CJump(ta, expr.op, tb, bbtrue, bbfalse))
-            else:
-                raise SemanticError('non-bool: {}'.format(expr.op), expr.loc)
-            expr.typ = self.boolType
-        elif type(expr) is ast.Literal:
-            self.gen_expr_code(expr)
-            if expr.val:
-                self.builder.emit(ir.Jump(bbtrue))
-            else:
-                self.builder.emit(ir.Jump(bbfalse))
-        else:
-            raise NotImplementedError('Unknown cond {}'.format(expr))
-
-        # Check that the condition is a boolean value:
-        if not self.equal_types(expr.typ, self.boolType):
-            self.error('Condition must be boolean', expr.loc)
-
-    def gen_expr_code(self, expr):
-        """ Generate code for an expression. Return the generated ir-value """
-        assert isinstance(expr, ast.Expression)
-        if type(expr) is ast.Binop:
-            expr.lvalue = False
-            if expr.op in ['+', '-', '*', '/', '<<', '>>', '|', '&']:
-                ra = self.gen_expr_code(expr.a)
-                rb = self.gen_expr_code(expr.b)
-                if self.equal_types(expr.a.typ, self.intType) and \
-                        self.equal_types(expr.b.typ, self.intType):
-                    expr.typ = expr.a.typ
-                elif self.equal_types(expr.b.typ, self.intType) and \
-                        type(expr.a.typ) is ast.PointerType:
-                    # Special case for pointer arithmatic TODO: coerce!
-                    expr.typ = expr.a.typ
-                else:
-                    raise SemanticError('Can only add integers', expr.loc)
-            else:
-                raise NotImplementedError("Cannot use equality as expressions")
-            return ir.Binop(ra, expr.op, rb, "op", ir.i32)
-        elif type(expr) is ast.Unop:
-            if expr.op == '&':
-                ra = self.gen_expr_code(expr.a)
-                expr.typ = ast.PointerType(expr.a.typ)
-                if not expr.a.lvalue:
-                    raise SemanticError('No valid lvalue', expr.a.loc)
-                expr.lvalue = False
-                assert type(ra) is ir.Mem
-                return ra.e
-            else:
-                raise NotImplementedError('Unknown unop {0}'.format(expr.op))
-        elif type(expr) is ast.Identifier:
-            # Generate code for this identifier.
-            tg = self.resolveSymbol(expr)
-            expr.kind = type(tg)
-            expr.typ = tg.typ
-            # This returns the dereferenced variable.
-            if isinstance(tg, ast.Variable):
-                expr.lvalue = True
-                return ir.Mem(self.varMap[tg])
-            elif isinstance(tg, ast.Constant):
-                c_val = self.gen_expr_code(tg.value)
-                return self.evalConst(c_val)
-            else:
-                raise NotImplementedError(str(tg))
-        elif type(expr) is ast.Deref:
-            # dereference pointer type:
-            addr = self.gen_expr_code(expr.ptr)
-            ptr_typ = self.the_type(expr.ptr.typ)
-            expr.lvalue = True
-            if type(ptr_typ) is ast.PointerType:
-                expr.typ = ptr_typ.ptype
-                return ir.Mem(addr)
-            else:
-                raise SemanticError('Cannot deref non-pointer', expr.loc)
-        elif type(expr) is ast.Member:
-            return self.gen_member_expr(expr)
-        elif type(expr) is ast.Index:
-            return self.gen_index_expr(expr)
-        elif type(expr) is ast.Literal:
-            return self.gen_literal_expr(expr)
-        elif type(expr) is ast.TypeCast:
-            return self.gen_type_cast(expr)
-        elif type(expr) is ast.Sizeof:
-            # The type of this expression is int:
-            expr.typ = self.intType
-            self.check_type(expr.query_typ)
-            type_size = self.size_of(expr.query_typ)
-            return ir.Const(type_size)
-        elif type(expr) is ast.FunctionCall:
-            return self.gen_function_call(expr)
-        else:
-            raise NotImplementedError('Unknown expr {}'.format(expr))
-
-    def gen_member_expr(self, expr):
-        base = self.gen_expr_code(expr.base)
-        expr.lvalue = expr.base.lvalue
-        basetype = self.the_type(expr.base.typ)
-        if type(basetype) is ast.StructureType:
-            if basetype.hasField(expr.field):
-                expr.typ = basetype.fieldType(expr.field)
-            else:
-                raise SemanticError('{} does not contain field {}'
-                                    .format(basetype, expr.field),
-                                    expr.loc)
-        else:
-            raise SemanticError('Cannot select {} of non-structure type {}'
-                                .format(expr.field, basetype), expr.loc)
-
-        assert type(base) is ir.Mem, type(base)
-        bt = self.the_type(expr.base.typ)
-        offset = ir.Const(bt.fieldOffset(expr.field))
-        addr = ir.Add(base.e, offset, "mem_addr", ir.i32)
-        return ir.Mem(addr)
-
-    def gen_index_expr(self, expr):
-        """ Array indexing """
-        base = self.gen_expr_code(expr.base)
-        idx = self.gen_expr_code(expr.i)
-        base_typ = self.the_type(expr.base.typ)
-        if not isinstance(base_typ, ast.ArrayType):
-            raise SemanticError('Cannot index non-array type {}'
-                                .format(base_typ),
-                                expr.base.loc)
-        idx_type = self.the_type(expr.i.typ)
-        if not self.equal_types(idx_type, self.intType):
-            raise SemanticError('Index must be int not {}'
-                                .format(idx_type), expr.i.loc)
-        assert type(base) is ir.Mem
-        element_type = self.the_type(base_typ.element_type)
-        element_size = self.size_of(element_type)
-        expr.typ = base_typ.element_type
-        expr.lvalue = True
-
-        offset = ir.Mul(idx, ir.Const(element_size), "element_offset", ir.i32)
-        addr = ir.Add(base.e, offset, "element_address", ir.i32)
-        return ir.Mem(addr)
-
-    def gen_literal_expr(self, expr):
-        """ Generate code for literal """
-        expr.lvalue = False
-        typemap = {int: 'int',
-                   float: 'double',
-                   bool: 'bool',
-                   str: 'string'}
-        if type(expr.val) in typemap:
-            expr.typ = self.pkg.scope[typemap[type(expr.val)]]
-        else:
-            raise SemanticError('Unknown literal type {}'
-                                .format(expr.val), expr.loc)
-        # Construct correct const value:
-        if type(expr.val) is str:
-            cval = self.pack_string(expr.val)
-            return ir.Addr(ir.Const(cval))
-        else:
-            return ir.Const(expr.val)
-
-    def pack_string(self, txt):
-        """ Pack a string using 4 bytes length followed by text data """
-        length = struct.pack('<I', len(txt))
-        data = txt.encode('ascii')
-        return length + data
-
-    def gen_type_cast(self, expr):
-        """ Generate code for type casting """
-        ar = self.gen_expr_code(expr.a)
-        from_type = self.the_type(expr.a.typ)
-        to_type = self.the_type(expr.to_type)
-        if isinstance(from_type, ast.PointerType) and \
-                isinstance(to_type, ast.PointerType):
-            expr.typ = expr.to_type
-            return ar
-        elif self.equal_types(self.intType, from_type) and \
-                isinstance(to_type, ast.PointerType):
-            expr.typ = expr.to_type
-            return ar
-        elif self.equal_types(self.intType, to_type) \
-                and isinstance(from_type, ast.PointerType):
-            expr.typ = expr.to_type
-            return ar
-        elif type(from_type) is ast.BaseType and from_type.name == 'byte' and \
-                type(to_type) is ast.BaseType and to_type.name == 'int':
-            expr.typ = expr.to_type
-            return ar
-        else:
-            raise SemanticError('Cannot cast {} to {}'
-                                .format(from_type, to_type), expr.loc)
-
-    def gen_function_call(self, expr):
-        """ Generate code for a function call """
-        # Evaluate the arguments:
-        args = [self.gen_expr_code(e) for e in expr.args]
-        # Check arguments:
-        tg = self.resolveSymbol(expr.proc)
-        if type(tg) is not ast.Function:
-            raise SemanticError('cannot call {}'.format(tg))
-        ftyp = tg.typ
-        fname = tg.package.name + '_' + tg.name
-        ptypes = ftyp.parametertypes
-        if len(expr.args) != len(ptypes):
-            raise SemanticError('{} requires {} arguments, {} given'
-                                .format(fname, len(ptypes), len(expr.args)),
-                                expr.loc)
-        for arg, at in zip(expr.args, ptypes):
-            if not self.equal_types(arg.typ, at):
-                raise SemanticError('Got {}, expected {}'
-                                    .format(arg.typ, at), arg.loc)
-        # determine return type:
-        expr.typ = ftyp.returntype
-        return ir.Call(fname, args)
-
-    def evalConst(self, c):
-        if isinstance(c, ir.Const):
-            return c
-        else:
-            raise SemanticError('Cannot evaluate constant {}'.format(c))
-
-    def resolveSymbol(self, sym):
-        if type(sym) is ast.Member:
-            base = self.resolveSymbol(sym.base)
-            if type(base) is not ast.Package:
-                raise SemanticError('Base is not a package', sym.loc)
-            scope = base.innerScope
-            name = sym.field
-        elif type(sym) is ast.Identifier:
-            scope = sym.scope
-            name = sym.target
-        else:
-            raise NotImplementedError(str(sym))
-        if name in scope:
-            s = scope[name]
-        else:
-            raise SemanticError('{} undefined'.format(name), sym.loc)
-        assert isinstance(s, ast.Symbol)
-        return s
-
-    def size_of(self, t):
-        """ Determine the byte size of a type """
-        t = self.the_type(t)
-        if type(t) is ast.BaseType:
-            return t.bytesize
-        elif type(t) is ast.StructureType:
-            return sum(self.size_of(mem.typ) for mem in t.mems)
-        elif type(t) is ast.ArrayType:
-            return t.size * self.size_of(t.element_type)
-        elif type(t) is ast.PointerType:
-            return self.pointerSize
-        else:
-            raise NotImplementedError(str(t))
-
-    def the_type(self, t, reveil_defined=True):
-        """ Recurse until a 'real' type is found
-            When reveil_defined is True, defined types are resolved to
-            their backing types.
-        """
-        if type(t) is ast.DefinedType:
-            if reveil_defined:
-                t = self.the_type(t.typ)
-        elif type(t) in [ast.Identifier, ast.Member]:
-            t = self.the_type(self.resolveSymbol(t), reveil_defined)
-        elif isinstance(t, ast.Type):
-            pass
-        else:
-            raise NotImplementedError(str(t))
-        assert isinstance(t, ast.Type)
-        return t
-
-    def equal_types(self, a, b, byname=False):
-        """ Compare types a and b for structural equavalence.
-            if byname is True stop on defined types.
-        """
-        # Recurse into named types:
-        a = self.the_type(a, not byname)
-        b = self.the_type(b, not byname)
-
-        # Check types for sanity:
-        self.check_type(a)
-        self.check_type(b)
-
-        # Do structural equivalence check:
-        if type(a) is type(b):
-            if type(a) is ast.BaseType:
-                return a.name == b.name
-            elif type(a) is ast.PointerType:
-                # If a pointed type is detected, stop structural
-                # equivalence:
-                return self.equal_types(a.ptype, b.ptype, byname=True)
-            elif type(a) is ast.StructureType:
-                if len(a.mems) != len(b.mems):
-                    return False
-                return all(self.equal_types(am.typ, bm.typ) for am, bm in
-                           zip(a.mems, b.mems))
-            elif type(a) is ast.ArrayType:
-                return self.equal_types(a.element_type, b.element_type)
-            elif type(a) is ast.DefinedType:
-                # Try by name in case of defined types:
-                return a.name == b.name
-            else:
-                raise NotImplementedError('{} not implemented'.format(type(a)))
-        return False
-
-    def check_type(self, t, first=True, byname=False):
-        """ Determine struct offsets and check for recursiveness by using
-            mark and sweep algorithm.
-            The calling function could call this function with first set
-            to clear the marks.
-        """
-
-        # Reset the mark and sweep:
-        if first:
-            self.got_types = set()
-
-        # Resolve the type:
-        t = self.the_type(t, not byname)
-
-        # Check for recursion:
-        if t in self.got_types:
-            raise SemanticError('Recursive data type {}'.format(t), None)
-
-        if type(t) is ast.BaseType:
-            pass
-        elif type(t) is ast.PointerType:
-            # If a pointed type is detected, stop structural
-            # equivalence:
-            self.check_type(t.ptype, first=False, byname=True)
-        elif type(t) is ast.StructureType:
-            self.got_types.add(t)
-            # Setup offsets of fields. Is this the right place?:
-            offset = 0
-            for struct_member in t.mems:
-                self.check_type(struct_member.typ, first=False)
-                struct_member.offset = offset
-                offset = offset + self.size_of(struct_member.typ)
-        elif type(t) is ast.ArrayType:
-            self.check_type(t.element_type, first=False)
-        elif type(t) is ast.DefinedType:
-            pass
-        else:
-            raise NotImplementedError('{} not implemented'.format(type(t)))

--- a/python/ppci/c3/grammar.txt	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-
-
-stmt: if_stmt | while_stmt | for_stmt | assign_stmt | compound_stmt
-
-compound_stmt: '{' stmt ';' stmt ... '}'
-if_stmt: 'if' '(' cond ')' stmt
-assign_stmt: lhs '=' expr
-
-cond:
-
-expr:
-

--- a/python/ppci/c3/lexer.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-import re
-from ppci import CompilerError, SourceLocation, Token, make_num
-from baselex import BaseLexer
-
-"""
- Lexical analyzer part. Splits the input character stream into tokens.
-"""
-
-keywords = ['and', 'or', 'not', 'true', 'false',
-            'else', 'if', 'while', 'for', 'return',
-            'switch', 'case', 'default',
-            'function', 'var', 'type', 'const',
-            'struct', 'cast', 'sizeof',
-            'import', 'module']
-
-
-class Lexer(BaseLexer):
-    """ Generates a sequence of token from an input stream """
-    def __init__(self, diag):
-        self.diag = diag
-        tok_spec = [
-            ('REAL', r'\d+\.\d+', lambda typ, val: (typ, float(val))),
-            ('HEXNUMBER', r'0x[\da-fA-F]+',
-             lambda typ, val: ('NUMBER', make_num(val))),
-            ('NUMBER', r'\d+', lambda typ, val: (typ, int(val))),
-            ('ID', r'[A-Za-z][A-Za-z\d_]*', self.handle_id),
-            ('NEWLINE', r'\n', lambda typ, val: self.newline()),
-            ('SKIP', r'[ \t]', None),
-            ('COMMENTS', r'//.*', None),
-            ('LONGCOMMENTBEGIN', r'\/\*', self.handle_comment_start),
-            ('LONGCOMMENTEND', r'\*\/', self.handle_comment_stop),
-            ('LEESTEKEN',
-             r'==|->|<<|>>|!=|\+\+|[\.,=:;\-+*\[\]/\(\)]|>=|<=|<>|>|<|{|}|&|\^|\|',
-             lambda typ, val: (val, val)),
-            ('STRING', r'".*?"', lambda typ, val: (typ, val[1:-1]))
-            ]
-        super().__init__(tok_spec)
-
-    def lex(self, input_file):
-        filename = input_file.name if hasattr(input_file, 'name') else ''
-        s = input_file.read()
-        input_file.close()
-        self.diag.addSource(filename, s)
-        self.filename = filename
-        return self.tokenize(s)
-
-    def handle_comment_start(self, typ, val):
-        self.incomment = True
-
-    def handle_comment_stop(self, typ, val):
-        self.incomment = False
-
-    def tokenize(self, text):
-        """ Keeps track of the long comments """
-        self.incomment = False
-        for token in super().tokenize(text):
-            if self.incomment:
-                pass    # Wait until we are not in a comment section
-            else:
-                yield token
-        loc = SourceLocation(self.filename, self.line, 0, 0)
-        yield Token('EOF', 'EOF', loc)
-
-    def handle_id(self, typ, val):
-        if val in keywords:
-            typ = val
-        return typ, val

--- a/python/ppci/c3/parser.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,471 +0,0 @@
-import logging
-from .. import CompilerError
-from .astnodes import Member, Literal, TypeCast, Unop, Binop
-from .astnodes import Assignment, ExpressionStatement, Compound
-from .astnodes import Return, While, If, Empty, For
-from .astnodes import FunctionType, Function, FormalParameter
-from .astnodes import StructureType, DefinedType, PointerType, ArrayType
-from .astnodes import Constant, Variable, Sizeof
-from .astnodes import StructField, Deref, Index
-from .astnodes import Package
-from .astnodes import Identifier
-from .astnodes import FunctionCall
-
-
-class Parser:
-    """ Parses sourcecode into an abstract syntax tree (AST) """
-    def __init__(self, diag):
-        self.logger = logging.getLogger('c3')
-        self.diag = diag
-
-    def parseSource(self, tokens):
-        self.logger.debug('Parsing source')
-        self.tokens = tokens
-        self.token = self.tokens.__next__()
-        try:
-            self.parse_package()
-            self.logger.debug('Parsing complete')
-            self.mod.ok = True  # Valid until proven wrong :)
-            return self.mod
-        except CompilerError as e:
-            self.diag.addDiag(e)
-
-    def Error(self, msg):
-        raise CompilerError(msg, self.token.loc)
-
-    # Lexer helpers:
-    def Consume(self, typ):
-        if self.Peak == typ:
-            return self.NextToken()
-        else:
-            self.Error('Excected: "{0}", got "{1}"'.format(typ, self.Peak))
-
-    @property
-    def Peak(self):
-        return self.token.typ
-
-    @property
-    def CurLoc(self):
-        return self.token.loc
-
-    def hasConsumed(self, typ):
-        if self.Peak == typ:
-            self.Consume(typ)
-            return True
-        return False
-
-    def NextToken(self):
-        t = self.token
-        if t.typ != 'EOF':
-            self.token = self.tokens.__next__()
-        return t
-
-    def addDeclaration(self, decl):
-        self.currentPart.add_declaration(decl)
-
-    def parseImport(self):
-        self.Consume('import')
-        name = self.Consume('ID').val
-        self.mod.imports.append(name)
-        self.Consume(';')
-
-    def parse_package(self):
-        """ Parse a package definition """
-        self.Consume('module')
-        name = self.Consume('ID')
-        self.Consume(';')
-        self.logger.debug('Parsing package {}'.format(name.val))
-        self.mod = Package(name.val, name.loc)
-        self.currentPart = self.mod
-        while self.Peak != 'EOF':
-            self.parse_top_level()
-        self.Consume('EOF')
-
-    def parse_top_level(self):
-        """ Parse toplevel declaration """
-        if self.Peak == 'function':
-            self.parse_function_def()
-        elif self.Peak == 'var':
-            self.parse_variable_def()
-            # TODO handle variable initialization
-        elif self.Peak == 'const':
-            self.parseConstDef()
-        elif self.Peak == 'type':
-            self.parse_type_def()
-        elif self.Peak == 'import':
-            self.parseImport()
-        else:
-            self.Error('Expected function, var, const or type')
-
-    def parseDesignator(self):
-        """ A designator designates an object with a name. """
-        name = self.Consume('ID')
-        return Identifier(name.val, name.loc)
-
-    def parseIdSequence(self):
-        ids = [self.Consume('ID')]
-        while self.hasConsumed(','):
-            ids.append(self.Consume('ID'))
-        return ids
-
-    # Type system
-    def PostFixId(self):
-        pfe = self.PrimaryExpression_Id()
-        while self.Peak in ['.']:
-            if self.hasConsumed('.'):
-                field = self.Consume('ID')
-                pfe = Member(pfe, field.val, field.loc)
-            else:
-                raise Exception()
-        return pfe
-
-    def PrimaryExpression_Id(self):
-        if self.Peak == 'ID':
-            return self.parseDesignator()
-        self.Error('Expected ID, got {0}'.format(self.Peak))
-
-    def parse_type_spec(self):
-        """ Parse type specification """
-        if self.Peak == 'struct':
-            self.Consume('struct')
-            self.Consume('{')
-            mems = []
-            while self.Peak != '}':
-                mem_t = self.parse_type_spec()
-                for i in self.parseIdSequence():
-                    mems.append(StructField(i.val, mem_t))
-                self.Consume(';')
-            self.Consume('}')
-            theT = StructureType(mems)
-        elif self.Peak == 'enum':
-            # TODO)
-            raise NotImplementedError()
-        else:
-            theT = self.PostFixId()
-
-        # Check for pointer or array suffix:
-        while self.Peak in ['*', '[']:
-            if self.hasConsumed('*'):
-                theT = PointerType(theT)
-            elif self.hasConsumed('['):
-                if self.Peak == ']':
-                    size = 0
-                    self.Consume(']')
-                else:
-                    size = self.Expression()
-                    self.Consume(']')
-                theT = ArrayType(theT, size)
-            else:
-                raise Exception()
-        return theT
-
-    def parse_type_def(self):
-        self.Consume('type')
-        newtype = self.parse_type_spec()
-        typename = self.Consume('ID')
-        self.logger.debug('Parsing type {}'.format(typename.val))
-        self.Consume(';')
-        df = DefinedType(typename.val, newtype, typename.loc)
-        self.addDeclaration(df)
-
-    # Variable declarations:
-    def parse_variable_def(self):
-        """ Parse variable declaration """
-        self.Consume('var')
-        t = self.parse_type_spec()
-        for name in self.parseIdSequence():
-            v = Variable(name.val, t)
-            v.loc = name.loc
-            self.addDeclaration(v)
-        self.Consume(';')
-
-    def parseConstDef(self):
-        self.Consume('const')
-        t = self.parse_type_spec()
-        while True:
-            name = self.Consume('ID')
-            self.Consume('=')
-            val = self.Expression()
-            c = Constant(name.val, t, val)
-            self.addDeclaration(c)
-            c.loc = name.loc
-            if not self.hasConsumed(','):
-                break
-        self.Consume(';')
-
-    def parse_function_def(self):
-        loc = self.Consume('function').loc
-        returntype = self.parse_type_spec()
-        fname = self.Consume('ID').val
-        self.logger.debug('Parsing function {}'.format(fname))
-        f = Function(fname, loc)
-        self.addDeclaration(f)
-        savePart = self.currentPart
-        self.currentPart = f
-        self.Consume('(')
-        parameters = []
-        if not self.hasConsumed(')'):
-            while True:
-                typ = self.parse_type_spec()
-                name = self.Consume('ID')
-                param = FormalParameter(name.val, typ)
-                param.loc = name.loc
-                self.addDeclaration(param)
-                parameters.append(param)
-                if not self.hasConsumed(','):
-                    break
-            self.Consume(')')
-        paramtypes = [p.typ for p in parameters]
-        f.typ = FunctionType(paramtypes, returntype)
-        if self.Peak == ';':
-            self.Consume(';')
-            f.body = None
-        else:
-            f.body = self.parseCompound()
-        self.currentPart = savePart
-
-    def parse_if(self):
-        loc = self.Consume('if').loc
-        self.Consume('(')
-        condition = self.Expression()
-        self.Consume(')')
-        yes = self.Statement()
-        no = self.Statement() if self.hasConsumed('else') else Empty()
-        return If(condition, yes, no, loc)
-
-    def parse_switch(self):
-        loc = self.Consume('switch').loc
-        self.Consume('(')
-        condition = self.Expression()
-        self.Consume(')')
-        return Switch(condition, loc)
-
-    def parse_while(self):
-        loc = self.Consume('while').loc
-        self.Consume('(')
-        condition = self.Expression()
-        self.Consume(')')
-        statements = self.Statement()
-        return While(condition, statements, loc)
-
-    def parse_for(self):
-        loc = self.Consume('for').loc
-        self.Consume('(')
-        init = self.Statement()
-        self.Consume(';')
-        condition = self.Expression()
-        self.Consume(';')
-        final = self.Statement()
-        self.Consume(')')
-        statements = self.Statement()
-        return For(init, condition, final, statements, loc)
-
-    def parseReturn(self):
-        loc = self.Consume('return').loc
-        if self.Peak == ';':
-            expr = Literal(0, loc)
-        else:
-            expr = self.Expression()
-        self.Consume(';')
-        return Return(expr, loc)
-
-    def parseCompound(self):
-        self.Consume('{')
-        statements = []
-        while not self.hasConsumed('}'):
-            statements.append(self.Statement())
-        return Compound(statements)
-
-    def Statement(self):
-        # Determine statement type based on the pending token:
-        if self.Peak == 'if':
-            return self.parse_if()
-        elif self.Peak == 'while':
-            return self.parse_while()
-        elif self.Peak == 'for':
-            return self.parse_for()
-        elif self.Peak == 'switch':
-            return self.parse_switch()
-        elif self.Peak == '{':
-            return self.parseCompound()
-        elif self.hasConsumed(';'):
-            return Empty()
-        elif self.Peak == 'var':
-            self.parse_variable_def()
-            return Empty()
-        elif self.Peak == 'return':
-            return self.parseReturn()
-        else:
-            x = self.UnaryExpression()
-            if self.Peak == '=':
-                # We enter assignment mode here.
-                loc = self.Consume('=').loc
-                rhs = self.Expression()
-                return Assignment(x, rhs, loc)
-            else:
-                return ExpressionStatement(x, x.loc)
-
-    # Expression section:
-    # We not implement these C constructs:
-    # a(2), f = 2
-    # and this:
-    # a = 2 < x : 4 ? 1;
-
-    def Expression(self):
-        exp = self.LogicalAndExpression()
-        while self.Peak == 'or':
-            loc = self.Consume('or').loc
-            e2 = self.LogicalAndExpression()
-            exp = Binop(exp, 'or', e2, loc)
-        return exp
-
-    def LogicalAndExpression(self):
-        o = self.EqualityExpression()
-        while self.Peak == 'and':
-            loc = self.Consume('and').loc
-            o2 = self.EqualityExpression()
-            o = Binop(o, 'and', o2, loc)
-        return o
-
-    def EqualityExpression(self):
-        ee = self.SimpleExpression()
-        while self.Peak in ['<', '==', '>', '>=', '<=', '!=']:
-            op = self.Consume(self.Peak)
-            ee2 = self.SimpleExpression()
-            ee = Binop(ee, op.typ, ee2, op.loc)
-        return ee
-
-    def SimpleExpression(self):
-        """ Shift operations before + and - ? """
-        e = self.AddExpression()
-        while self.Peak in ['>>', '<<']:
-            op = self.Consume(self.Peak)
-            e2 = self.AddExpression()
-            e = Binop(e, op.typ, e2, op.loc)
-        return e
-
-    def AddExpression(self):
-        e = self.Term()
-        while self.Peak in ['+', '-']:
-            op = self.Consume(self.Peak)
-            e2 = self.Term()
-            e = Binop(e, op.typ, e2, op.loc)
-        return e
-
-    def Term(self):
-        t = self.BitwiseOr()
-        while self.Peak in ['*', '/']:
-            op = self.Consume(self.Peak)
-            t2 = self.BitwiseOr()
-            t = Binop(t, op.typ, t2, op.loc)
-        return t
-
-    def BitwiseOr(self):
-        a = self.BitwiseAnd()
-        while self.Peak == '|':
-            op = self.Consume(self.Peak)
-            b = self.BitwiseAnd()
-            a = Binop(a, op.typ, b, op.loc)
-        return a
-
-    def BitwiseAnd(self):
-        a = self.CastExpression()
-        while self.Peak == '&':
-            op = self.Consume(self.Peak)
-            b = self.CastExpression()
-            a = Binop(a, op.typ, b, op.loc)
-        return a
-
-    # Domain of unary expressions:
-
-    def CastExpression(self):
-        """
-          the C-style type cast conflicts with '(' expr ')'
-          so introduce extra keyword 'cast'
-        """
-        if self.Peak == 'cast':
-            loc = self.Consume('cast').loc
-            self.Consume('<')
-            t = self.parse_type_spec()
-            self.Consume('>')
-            self.Consume('(')
-            ce = self.Expression()
-            self.Consume(')')
-            return TypeCast(t, ce, loc)
-        elif self.Peak == 'sizeof':
-            return self.sizeof_expression()
-        else:
-            return self.UnaryExpression()
-
-    def sizeof_expression(self):
-        """ Compiler internal function to determine size of a type """
-        loc = self.Consume('sizeof').loc
-        self.Consume('(')
-        typ = self.parse_type_spec()
-        self.Consume(')')
-        return Sizeof(typ, loc)
-
-    def UnaryExpression(self):
-        if self.Peak in ['&', '*']:
-            op = self.Consume(self.Peak)
-            ce = self.CastExpression()
-            if op.val == '*':
-                return Deref(ce, op.loc)
-            else:
-                return Unop(op.typ, ce, op.loc)
-        else:
-            return self.PostFixExpression()
-
-    def PostFixExpression(self):
-        pfe = self.PrimaryExpression()
-        while self.Peak in ['[', '.', '->', '(', '++']:
-            if self.hasConsumed('['):
-                i = self.Expression()
-                self.Consume(']')
-                pfe = Index(pfe, i, i.loc)
-            elif self.hasConsumed('->'):
-                field = self.Consume('ID')
-                pfe = Deref(pfe, pfe.loc)
-                pfe = Member(pfe, field.val, field.loc)
-            elif self.hasConsumed('.'):
-                field = self.Consume('ID')
-                pfe = Member(pfe, field.val, field.loc)
-            elif self.Peak == '++':
-                loc = self.Consume('++').loc
-                pfe = Unop('++', pfe, loc)
-            elif self.hasConsumed('('):
-                # Function call
-                args = []
-                if not self.hasConsumed(')'):
-                    args.append(self.Expression())
-                    while self.hasConsumed(','):
-                        args.append(self.Expression())
-                    self.Consume(')')
-                pfe = FunctionCall(pfe, args, pfe.loc)
-            else:
-                raise Exception()
-        return pfe
-
-    def PrimaryExpression(self):
-        if self.hasConsumed('('):
-            e = self.Expression()
-            self.Consume(')')
-            return e
-        elif self.Peak == 'NUMBER':
-            val = self.Consume('NUMBER')
-            return Literal(val.val, val.loc)
-        elif self.Peak == 'REAL':
-            val = self.Consume('REAL')
-            return Literal(val.val, val.loc)
-        elif self.Peak == 'true':
-            val = self.Consume('true')
-            return Literal(True, val.loc)
-        elif self.Peak == 'false':
-            val = self.Consume('false')
-            return Literal(False, val.loc)
-        elif self.Peak == 'STRING':
-            val = self.Consume('STRING')
-            return Literal(val.val, val.loc)
-        elif self.Peak == 'ID':
-            return self.parseDesignator()
-        self.Error('Expected NUM, ID or (expr), got {0}'.format(self.Peak))

--- a/python/ppci/c3/scope.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,92 +0,0 @@
-from .astnodes import Constant, Variable, Function, BaseType, Symbol
-from .astnodes import ArrayType, StructureType, DefinedType, PointerType
-from .astnodes import StructField
-
-
-class Scope:
-    """ A scope contains all symbols in a scope. It also has a parent scope,
-        when looking for a symbol, also the parent scopes are checked. """
-    def __init__(self, parent=None):
-        self.symbols = {}
-        self.parent = parent
-
-    def __iter__(self):
-        # Iterate in a deterministic manner:
-        return iter(self.Constants + self.Variables + self.Functions)
-
-    @property
-    def Syms(self):
-        """ Get all the symbols defined in this scope """
-        syms = self.symbols.values()
-        return sorted(syms, key=lambda v: v.name)
-
-    @property
-    def Types(self):
-        return [s for s in self.Syms if isinstance(s, DefinedType)]
-
-    @property
-    def Constants(self):
-        return [s for s in self.Syms if type(s) is Constant]
-
-    @property
-    def Variables(self):
-        return [s for s in self.Syms if isinstance(s, Variable)]
-
-    @property
-    def Functions(self):
-        return [s for s in self.Syms if type(s) is Function]
-
-    def getSymbol(self, name):
-        if name in self.symbols:
-            return self.symbols[name]
-        # Look for symbol:
-        elif self.parent:
-            return self.parent.getSymbol(name)
-        else:
-            raise KeyError(name)
-
-    def __getitem__(self, key):
-        return self.getSymbol(key)
-
-    def hasSymbol(self, name):
-        if name in self.symbols:
-            return True
-        elif self.parent:
-            return self.parent.hasSymbol(name)
-        else:
-            return False
-
-    def __contains__(self, name):
-        return self.hasSymbol(name)
-
-    def addSymbol(self, sym):
-        assert sym.name not in self.symbols
-        assert isinstance(sym, Symbol)
-        self.symbols[sym.name] = sym
-
-    def __repr__(self):
-        return 'Scope with {} symbols'.format(len(self.symbols))
-
-
-def createTopScope(target):
-    scope = Scope()
-    for tn in ['u64', 'u32', 'u16', 'u8']:
-        scope.addSymbol(BaseType(tn))
-    # buildin types:
-    intType = BaseType('int')
-    intType.bytesize = target.byte_sizes['int']
-    scope.addSymbol(intType)
-    scope.addSymbol(BaseType('double'))
-    scope.addSymbol(BaseType('void'))
-    scope.addSymbol(BaseType('bool'))
-    byteType = BaseType('byte')
-    byteType.bytesize = target.byte_sizes['byte']
-    scope.addSymbol(byteType)
-
-    # Construct string type from others:
-    ln = StructField('len', intType)
-    txt = StructField('txt', ArrayType(byteType, 0))
-    strType = DefinedType('string', PointerType(StructureType([ln, txt])),
-                          None)
-    scope.addSymbol(strType)
-    return scope

--- a/python/ppci/c3/visitor.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,115 +0,0 @@
-from .astnodes import *
-
-
-class Visitor:
-    """
-        Visitor that can visit all nodes in the AST
-        and run pre and post functions.
-    """
-    def visit(self, node, f_pre=None, f_post=None):
-        self.f_pre = f_pre
-        self.f_post = f_post
-        self.do(node)
-
-    def do(self, node):
-        # Run pre function:
-        if self.f_pre:
-            self.f_pre(node)
-
-        # Descent into subnodes:
-        if type(node) is Package:
-            for decl in node.declarations:
-                self.do(decl)
-        elif type(node) is Function:
-            for s in node.declarations:
-                self.do(s)
-            self.do(node.typ)
-            if node.body:
-                self.do(node.body)
-        elif type(node) is Compound:
-            for s in node.statements:
-                self.do(s)
-        elif type(node) is If:
-            self.do(node.condition)
-            self.do(node.truestatement)
-            self.do(node.falsestatement)
-        elif type(node) is While:
-            self.do(node.condition)
-            self.do(node.statement)
-        elif type(node) is For:
-            self.do(node.init)
-            self.do(node.condition)
-            self.do(node.final)
-            self.do(node.statement)
-        elif type(node) is Assignment:
-            self.do(node.lval)
-            self.do(node.rval)
-        elif type(node) is FunctionCall:
-            for arg in node.args:
-                self.do(arg)
-            self.do(node.proc)
-        elif type(node) is Return:
-            self.do(node.expr)
-        elif type(node) is Binop:
-            self.do(node.a)
-            self.do(node.b)
-        elif type(node) is Unop:
-            self.do(node.a)
-        elif type(node) is ExpressionStatement:
-            self.do(node.ex)
-        elif type(node) is TypeCast:
-            self.do(node.a)
-            self.do(node.to_type)
-        elif type(node) is Sizeof:
-            self.do(node.query_typ)
-        elif type(node) is Member:
-            self.do(node.base)
-        elif type(node) is Index:
-            self.do(node.base)
-            self.do(node.i)
-        elif type(node) is Deref:
-            self.do(node.ptr)
-        elif type(node) is Constant:
-            self.do(node.typ)
-            self.do(node.value)
-        elif type(node) is DefinedType:
-            self.do(node.typ)
-        elif isinstance(node, Variable):
-            self.do(node.typ)
-        elif type(node) is PointerType:
-            self.do(node.ptype)
-        elif type(node) is StructureType:
-            for m in node.mems:
-                self.do(m.typ)
-        elif type(node) is ArrayType:
-            self.do(node.element_type)
-            self.do(node.size)
-        elif type(node) is FunctionType:
-            for pt in node.parametertypes:
-                self.do(pt)
-            self.do(node.returntype)
-        elif type(node) in [Identifier, Literal, Empty]:
-            # Those nodes do not have child nodes.
-            pass
-        else:
-            raise Exception('Could not visit "{0}"'.format(node))
-
-        # run post function
-        if self.f_post:
-            self.f_post(node)
-
-
-class AstPrinter:
-    """ Prints an AST as text """
-    def printAst(self, pkg, f):
-        self.indent = 2
-        self.f = f
-        visitor = Visitor()
-        visitor.visit(pkg, self.print1, self.print2)
-
-    def print1(self, node):
-        print(' ' * self.indent + str(node), file=self.f)
-        self.indent += 2
-
-    def print2(self, node):
-        self.indent -= 2

--- a/python/ppci/codegen/__init__.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-from .codegen import CodeGenerator

--- a/python/ppci/codegen/canon.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,141 +0,0 @@
-from .. import ir
-from .. import irutils
-from itertools import chain
-
-def make(function, frame):
-    """
-        Create canonicalized version of the IR-code. This means:
-        - Calls out of expressions.
-        - Other things?
-    """
-    # Change the tree. This modifies the IR-tree!
-    # Move all parameters into registers
-    parmoves = []
-    for p in function.arguments:
-        pt = newTemp()
-        frame.parMap[p] = pt
-        parmoves.append(ir.Move(pt, frame.argLoc(p.num)))
-    function.entry.instructions = parmoves + function.entry.instructions
-
-    for block in function.Blocks:
-        for stmt in block.instructions:
-            rewriteStmt(stmt, frame)
-        linearize(block)
-    # TODO: schedule here?
-
-# Visit all nodes with some function:
-# TODO: rewrite into visitor.
-
-# Rewrite rewrites call instructions into Eseq instructions.
-
-
-def rewriteStmt(stmt, frame):
-    if isinstance(stmt, ir.Jump):
-        pass
-    elif isinstance(stmt, ir.CJump):
-        stmt.a = rewriteExp(stmt.a, frame)
-        stmt.b = rewriteExp(stmt.b, frame)
-    elif isinstance(stmt, ir.Move):
-        stmt.src = rewriteExp(stmt.src, frame)
-        stmt.dst = rewriteExp(stmt.dst, frame)
-    elif isinstance(stmt, ir.Terminator):
-        pass
-    elif isinstance(stmt, ir.Exp):
-        stmt.e = rewriteExp(stmt.e, frame)
-    else:
-        raise NotImplementedError('STMT NI: {}'.format(stmt))
-
-newTemp = irutils.NamedClassGenerator('canon_reg', ir.Temp).gen
-
-def rewriteExp(exp, frame):
-    if isinstance(exp, ir.Binop):
-        exp.a = rewriteExp(exp.a, frame)
-        exp.b = rewriteExp(exp.b, frame)
-        return exp
-    elif isinstance(exp, ir.Const):
-        return exp
-    elif isinstance(exp, ir.Temp):
-        return exp
-    elif isinstance(exp, ir.Parameter):
-        return frame.parMap[exp]
-    elif isinstance(exp, ir.LocalVariable):
-        offset = frame.allocVar(exp)
-        return ir.Add(frame.fp, ir.Const(offset), "Offset", ir.i32)
-    elif isinstance(exp, ir.GlobalVariable):
-        #frame.load_global_address(ir.label_name(exp))
-        return exp
-    elif isinstance(exp, ir.Mem):
-        exp.e = rewriteExp(exp.e, frame)
-        return exp
-    elif isinstance(exp, ir.Addr):
-        exp.e = rewriteExp(exp.e, frame)
-        return exp
-    elif isinstance(exp, ir.Call):
-        exp.arguments = [rewriteExp(p, frame) for p in exp.arguments]
-        # Rewrite call into eseq:
-        t = newTemp()
-        return ir.Eseq(ir.Move(t, exp), t)
-    else:
-        raise NotImplementedError('NI: {}, {}'.format(exp, type(exp)))
-
-# The flatten functions pull out seq instructions to the sequence list.
-
-def flattenExp(exp):
-    if isinstance(exp, ir.Binop):
-        exp.a, sa = flattenExp(exp.a)
-        exp.b, sb = flattenExp(exp.b)
-        return exp, sa + sb
-    elif isinstance(exp, ir.Temp):
-        return exp, []
-    elif isinstance(exp, ir.Const):
-        return exp, []
-    elif isinstance(exp, ir.Mem):
-        exp.e, s = flattenExp(exp.e)
-        return exp, s
-    elif isinstance(exp, ir.GlobalVariable):
-        return exp, []
-    elif isinstance(exp, ir.Addr):
-        exp.e, s = flattenExp(exp.e)
-        return exp, s
-    elif isinstance(exp, ir.Eseq):
-        s = flattenStmt(exp.stmt)
-        exp.e, se = flattenExp(exp.e)
-        return exp.e, s + se
-    elif isinstance(exp, ir.Call):
-        sp = []
-        p = []
-        for p_, sp_ in (flattenExp(p) for p in exp.arguments):
-            p.append(p_)
-            sp.extend(sp_)
-        exp.arguments = p
-        return exp, sp
-    else:
-        raise NotImplementedError('NI: {}'.format(exp))
-
-
-def flattenStmt(stmt):
-    if isinstance(stmt, ir.Jump):
-        return [stmt]
-    elif isinstance(stmt, ir.CJump):
-        stmt.a, sa = flattenExp(stmt.a)
-        stmt.b, sb = flattenExp(stmt.b)
-        return sa + sb + [stmt]
-    elif isinstance(stmt, ir.Move):
-        stmt.dst, sd = flattenExp(stmt.dst)
-        stmt.src, ss = flattenExp(stmt.src)
-        return sd + ss + [stmt]
-    elif isinstance(stmt, ir.Terminator):
-        return [stmt]
-    elif isinstance(stmt, ir.Exp):
-        stmt.e, se = flattenExp(stmt.e)
-        return se + [stmt]
-    else:
-        raise NotImplementedError('STMT NI: {}'.format(stmt))
-
-
-def linearize(block):
-    """ 
-      Move seq instructions to top and flatten these in an instruction list
-    """
-    i = list(flattenStmt(s) for s in block.instructions)
-    block.instructions = list(chain.from_iterable(i))

--- a/python/ppci/codegen/codegen.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,63 +0,0 @@
-from .. import ir
-from ..irutils import Verifier
-from ..transform import RemoveAddZero
-from ..target import Target
-from .. import CompilerError
-from .canon import make as canonicalize
-from .registerallocator import RegisterAllocator
-import logging
-
-
-class CodeGenerator:
-    """ Generic code generator """
-    def __init__(self, target):
-        # TODO: schedule traces in better order.
-        # This is optional!
-        assert isinstance(target, Target), target
-        self.logger = logging.getLogger('codegen')
-        self.target = target
-        self.ins_sel = target.ins_sel
-        self.ra = RegisterAllocator()
-        self.verifier = Verifier()
-
-    def generateFunc(self, irfunc, outs):
-        """ Generate code for one function into a frame """
-        self.logger.debug('Generating code for {}'.format(irfunc.name))
-        # Create a frame for this function:
-        frame = self.target.FrameClass(ir.label_name(irfunc))
-
-        # Canonicalize the intermediate language:
-        canonicalize(irfunc, frame)
-        RemoveAddZero().run(irfunc)
-        self.logger.debug('after canonicalize', extra={'irfunc': irfunc})
-        self.verifier.verify_function(irfunc)
-        self.ins_sel.munchFunction(irfunc, frame)
-        self.logger.debug('Selected instructions', extra={'ppci_frame': frame})
-
-        # Do register allocation:
-        self.ra.allocFrame(frame)
-        self.logger.debug('Registers allocated, now adding final glue')
-        # TODO: Peep-hole here?
-
-        # Add label and return and stack adjustment:
-        frame.EntryExitGlue3()
-
-        # Materialize the register allocated instructions into a stream of
-        # real instructions.
-        self.target.lower_frame_to_stream(frame, outs)
-        self.logger.debug('Instructions materialized')
-        return frame
-
-    def generate(self, ircode, outs):
-        """ Generate code into output stream """
-        assert isinstance(ircode, ir.Module)
-        outs.select_section('data')
-        for global_variable in ircode.Variables:
-            self.target.emit_global(outs, ir.label_name(global_variable))
-        outs.select_section('code')
-
-        # Munch program into a bunch of frames. One frame per function.
-        # Each frame has a flat list of abstract instructions.
-        # Generate code for all functions:
-        self.frames = [self.generateFunc(f, outs) for f in ircode.Functions]
-        return self.frames

--- a/python/ppci/codegen/flowgraph.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-from .graph import DiGraph, DiNode
-
-
-class FlowGraphNode(DiNode):
-    """ A node in the flow graph """
-    def __init__(self, g, ins):
-        super().__init__(g)
-        self.ins = ins
-        self.uses = set(ins.src)
-        self.defs = set(ins.dst)
-        self.live_in = set()
-        self.live_out = set()
-
-    def __repr__(self):
-        r = '{}'.format(self.ins)
-        if self.uses:
-            r += ' uses:' + ', '.join(str(u) for u in self.uses)
-        if self.defs:
-            r += ' defs:' + ', '.join(str(d) for d in self.defs)
-        return r
-
-
-
-class FlowGraph(DiGraph):
-    def __init__(self, instrs):
-        """ Create a flowgraph from a list of abstract instructions """
-        super().__init__()
-        self._map = {}
-        # Add nodes:
-        for ins in instrs:
-            n = FlowGraphNode(self, ins)
-            self._map[ins] = n
-            self.add_node(n)
-
-        # Make edges:
-        prev = None
-        for ins in instrs:
-            n = self._map[ins]
-            if prev:
-                self.addEdge(prev, n)
-            if ins.jumps:
-                prev = None
-                for j in ins.jumps:
-                    to_n = self._map[j]
-                    self.addEdge(n, to_n)
-            else:
-                prev = n

--- a/python/ppci/codegen/graph.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,107 +0,0 @@
-
-class Graph:
-    """
-       Generic graph base class.
-       Can dump to graphiz dot format for example!
-    """
-    def __init__(self):
-        self.nodes = set()
-        self.edges = set()
-        self.adj_map = {}
-
-    def add_node(self, n):
-        self.nodes.add(n)
-        if n not in self.adj_map:
-            self.adj_map[n] = set()
-
-    def delNode(self, n):
-        self.nodes.remove(n)
-
-    def addEdge(self, n, m):
-        """ Add an edge from n to m """
-        self.edges.add((n, m))
-        self.edges.add((m, n))
-        self.adj_map[n].add(m)
-        self.adj_map[m].add(n)
-
-    def hasEdge(self, n, m):
-        return (n, m) in self.edges
-
-    def delEdge(self, n, m):
-        self.edges.remove((n, m))
-        self.edges.remove((m, n))
-
-    def adjecent(self, n):
-        """ Return all nodes with edges to n """
-        return self.adj_map[n] & self.nodes
-
-    def to_dot(self, f):
-        """ Generate graphviz dot representation """
-        for n in self.nodes:
-            print('  {} [label="{}" shape=box3d];'.format(id(n), n), file=f)
-        for n, m in self.edges:
-            print('  {} -> {};'.format(id(n), id(m)), file=f)
-
-
-class Node:
-    """
-       Node in a graph.
-    """
-    def __init__(self, g):
-        self.g = g
-        self.addDegree = 0    # Hack to increase degree
-
-    @property
-    def Adjecent(self):
-        return self.g.adjecent(self)
-
-    @property
-    def Degree(self):
-        return len(self.Adjecent) + self.addDegree
-
-
-class DiGraph(Graph):
-    """ Directed graph. """
-    def __init__(self):
-        super().__init__()
-        self.suc_map = {}
-        self.pre_map = {}
-
-    def addEdge(self, n, m):
-        """ Add a directed edge from n to m """
-        assert n in self.nodes
-        assert m in self.nodes
-        self.edges.add((n, m))
-        self.suc_map[n].add(m)
-        self.pre_map[m].add(n)
-        self.adj_map[n].add(m)
-        self.adj_map[m].add(n)
-
-    def add_node(self, n):
-        super().add_node(n)
-        if n not in self.suc_map:
-            self.suc_map[n] = set()
-        if n not in self.pre_map:
-            self.pre_map[n] = set()
-
-    def hasEdge(self, n, m):
-        return (n, m) in self.edges
-
-    def successors(self, n):
-        return self.suc_map[n] & self.nodes
-
-    def predecessors(self, n):
-        return self.pre_map[n] & self.nodes
-
-
-class DiNode(Node):
-    @property
-    def Succ(self):
-        return self.g.successors(self)
-
-    @property
-    def Pred(self):
-        return self.g.predecessors(self)
-
-    def __gt__(self, other):
-        return self in other.Succ

--- a/python/ppci/codegen/interferencegraph.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,102 +0,0 @@
-import logging
-from .graph import Graph, Node
-
-
-class InterferenceGraphNode(Node):
-    def __init__(self, g, varname):
-        super().__init__(g)
-        self.temps = [varname]
-        self.moves = set()
-        self.color = None
-
-    def __repr__(self):
-        return '{}({})'.format(self.temps, self.color)
-
-    def __gt__(self, other):
-        return str(self.temps) > str(other.temps)
-
-class InterferenceGraph(Graph):
-    """
-        Interference graph.
-    """
-    def __init__(self, flowgraph):
-        """ Create a new interference graph from a flowgraph """
-        super().__init__()
-        self.logger = logging.getLogger('interferencegraph')
-        # Calculate liveness in CFG:
-        ###
-        # Liveness:
-        #  in[n] = use[n] UNION (out[n] - def[n])
-        #  out[n] = for s in n.succ in union in[s]
-        ###
-        for n in flowgraph.nodes:
-            n.live_in = set()
-            n.live_out = set()
-
-        # Sort flowgraph nodes backwards:
-        cfg_nodes = list(flowgraph.nodes)
-        self.logger.debug('CFG nodes: {}'.format(cfg_nodes))
-        cfg_nodes.sort(reverse=True)
-
-        # Dataflow fixed point iteration:
-        n_iterations = 0
-        change = True
-        while change:
-            change = False
-            for n in cfg_nodes:
-                _in = n.live_in
-                _out = n.live_out
-                n.live_in = n.uses | (n.live_out - n.defs)
-                if n.Succ:
-                    n.live_out = set.union(*(s.live_in for s in n.Succ))
-                else:
-                    n.live_out = set()
-                n.live_out = n.live_out | n.defs
-                change = change or (_in != n.live_in) or (_out != n.live_out)
-            n_iterations += 1
-
-        self.logger.debug('Iterations: {} * {}'.format(n_iterations, len(cfg_nodes)))
-        # Construct interference graph:
-        for n in flowgraph.nodes:
-            for tmp in n.live_out:
-                n1 = self.getNode(tmp)
-                for tmp2 in (n.live_out - {tmp}):
-                    n2 = self.getNode(tmp2)
-                    self.addEdge(n1, n2)
-
-    def to_dot(self, f):
-        """ Generate graphviz dot representation """
-        for n in self.nodes:
-            print('  {} [label="{}" shape=box3d];'.format(id(n), n), file=f)
-        for n, m in self.edges:
-            print('  {} -> {};'.format(id(n), id(m)), file=f)
-
-    def to_txt(self):
-        for node in self.nodes:
-            print('{} interferes: {}'.format(node, node.Adjecent))
-
-    def getNode(self, tmp):
-        # Linear search
-        # TODO: can be improved for speed!
-        for n in self.nodes:
-            if tmp in n.temps:
-                return n
-        n = InterferenceGraphNode(self, tmp)
-        self.add_node(n)
-        return n
-
-    def Combine(self, n, m):
-        """ Combine n and m into n """
-        n.temps.extend(m.temps)
-        n.moves.update(m.moves)
-        # Reroute all edges:
-        e1 = [e for e in self.edges if e[0] is m]
-        e2 = [e for e in self.edges if e[1] is m]
-        for e in e1:
-            self.edges.remove(e)
-            self.addEdge(n, e[1])
-        for e in e2:
-            self.edges.remove(e)
-            self.addEdge(n, e[0])
-        # Remove node m:
-        self.delNode(m)

--- a/python/ppci/codegen/registerallocator.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,201 +0,0 @@
-import logging
-from .flowgraph import FlowGraph
-from .interferencegraph import InterferenceGraph
-
-# Nifty first function:
-def first(x):
-    """ Take the first element of a collection after sorting the things """
-    x = list(x)
-    x.sort()
-    return next(iter(x))
-
-
-class RegisterAllocator:
-    """
-        Target independent register allocator.
-
-        Algorithm is iterated register coalescing by Appel and George.
-
-        Chaitin's algorithm: remove all nodes with less than K neighbours.
-        These nodes can be colored when added back.
-
-        The process consists of the following steps:
-        - build interference graph from the instruction list
-        - remove low degree non move related nodes.
-        - (optional) coalesc registers to remove redundant moves
-        - (optional) spill registers
-        - select registers
-    """
-    def __init__(self):
-        self.logger = logging.getLogger('registerallocator')
-
-    def InitData(self, f):
-        self.f = f
-        # Register information:
-        self.regs = set(f.regs)
-        self.K = len(self.regs)
-
-        # Move related sets:
-        self.coalescedMoves = set()
-        self.constrainedMoves = set()
-        self.frozenMoves = set()
-        self.activeMoves = set()
-        self.worklistMoves = set()
-
-    def Build(self):
-        """ 1. Construct interference graph from instruction list """
-        self.f.cfg = FlowGraph(self.f.instructions)
-        self.logger.debug('Constructed flowgraph', extra={'ra_cfg':self.f.cfg})
-        self.f.ig = InterferenceGraph(self.f.cfg)
-        self.logger.debug('Constructed interferencegraph', extra={'ra_ig':self.f.ig})
-
-        self.Node = self.f.ig.getNode
-
-        # Divide nodes into pre-colored and initial:
-        pre_tmp = list(self.f.tempMap.keys())
-        self.precolored = set(self.Node(tmp) for tmp in pre_tmp)
-        self.workSet = set(self.f.ig.nodes - self.precolored)
-
-        for n in self.precolored:
-            n.addDegree = 100 + len(self.f.ig.nodes) + self.K
-
-        # Initialize color map:
-        self.color = {}
-        for tmp, c in self.f.tempMap.items():
-            self.color[self.Node(tmp)] = c
-
-        self.moves = [i for i in self.f.instructions if i.ismove]
-        for mv in self.moves:
-            self.Node(mv.src[0]).moves.add(mv)
-            self.Node(mv.dst[0]).moves.add(mv)
-
-    def NodeMoves(self, n):
-        return n.moves & (self.activeMoves | self.worklistMoves)
-
-    def MoveRelated(self, n):
-        return bool(self.NodeMoves(n))
-
-    @property
-    def SpillWorkSet(self):
-        c = lambda n: n.Degree >= self.K
-        return set(filter(c, self.workSet))
-
-    @property
-    def FreezeWorkSet(self):
-        c = lambda n: n.Degree < self.K and self.MoveRelated(n)
-        return set(filter(c, self.workSet))
-
-    @property
-    def SimplifyWorkSet(self):
-        c = lambda n: n.Degree < self.K and not self.MoveRelated(n)
-        return set(filter(c, self.workSet))
-
-    def makeWorkList(self):
-        """ Divide initial nodes into worklists """
-        self.selectStack = []
-
-        # Fill initial move set:
-        for m in self.moves:
-            self.worklistMoves.add(m)
-
-    def Simplify(self):
-        """ 2. Remove nodes from the graph """
-        n = first(self.SimplifyWorkSet)
-        self.workSet.remove(n)
-        self.selectStack.append(n)
-        # Pop out of graph:
-        self.f.ig.delNode(n)
-
-    def EnableMoves(self, nodes):
-        for n in nodes:
-            for m in self.NodeMoves(n):
-                if m in self.activeMoves:
-                    self.activeMoves.remove(m)
-                    self.worklistMoves.add(m)
-
-    def Coalesc(self):
-        """ Coalesc conservative. """
-        m = first(self.worklistMoves)
-        x = self.Node(m.dst[0])
-        y = self.Node(m.src[0])
-        u, v = (y, x) if y in self.precolored else (x, y)
-        self.worklistMoves.remove(m)
-        if u is v:
-            self.coalescedMoves.add(m)
-        elif v in self.precolored or self.f.ig.hasEdge(u, v):
-            self.constrainedMoves.add(m)
-        elif u not in self.precolored and self.Conservative(u, v):
-            self.coalescedMoves.add(m)
-            self.workSet.remove(v)
-            self.f.ig.Combine(u, v)
-        else:
-            self.activeMoves.add(m)
-
-    def Conservative(self, u, v):
-        """ Briggs conservative criteria for coalesc """
-        nodes = u.Adjecent | v.Adjecent
-        c = lambda n: n.Degree >= self.K
-        k = len(list(filter(c, nodes)))
-        return k < self.K
-
-    def Freeze(self):
-        """ Give up coalescing on some node """
-        u = first(self.FreezeWorkSet)
-        self.freezeMoves(u)
-
-    def freezeMoves(self, u):
-        """ Freeze moves for node u """
-        for m in self.NodeMoves(u):
-            if m in self.activeMoves:
-                self.activeMoves.remove(m)
-            else:
-                sekf.worklistMoves.remove(m)
-            self.frozenMoves.add(m)
-            # Check other part of the move for still being move related:
-            v = m.src[0] if u is m.dst[0] else m.dst[0]
-
-    def SelectSpill(self):
-        raise NotImplementedError("Spill is not implemented")
-
-    def AssignColors(self):
-        """ Add nodes back to the graph to color it. """
-        while self.selectStack:
-            n = self.selectStack.pop(-1)  # Start with the last added
-            self.f.ig.add_node(n)
-            takenregs = set(self.color[m] for m in n.Adjecent)
-            okColors = self.regs - takenregs
-            if okColors:
-                self.color[n] = first(okColors)
-                n.color = self.color[n]
-            else:
-                raise NotImplementedError('Spill required here!')
-
-    def ApplyColors(self):
-        # Remove coalesced moves:
-        for mv in self.coalescedMoves:
-            self.f.instructions.remove(mv)
-
-        # Use allocated registers:
-        lookup = lambda t: self.color[self.Node(t)]
-        for i in self.f.instructions:
-            i.src = tuple(map(lookup, i.src))
-            i.dst = tuple(map(lookup, i.dst))
-
-    def allocFrame(self, f):
-        """ Do iterated register allocation for a single stack frame. """
-        self.InitData(f)
-        self.Build()
-        self.makeWorkList()
-        while True:
-            if self.SimplifyWorkSet:
-                self.Simplify()
-            elif self.worklistMoves:
-                self.Coalesc()
-            elif self.FreezeWorkSet:
-                self.Freeze()
-            elif self.SpillWorkSet:
-                raise NotImplementedError('Spill not implemented')
-            else:
-                break # Done!
-        self.AssignColors()
-        self.ApplyColors()

--- a/python/ppci/common.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,112 +0,0 @@
-from collections import namedtuple
-import logging
-
-"""
-   Error handling routines
-   Diagnostic utils
-   Source location structures
-"""
-
-class Token:
-    """
-        Token is used in the lexical analyzer. The lexical analyzer takes
-        a text and splits it into tokens.
-    """
-    def __init__(self, typ, val, loc):
-        self.typ = typ
-        self.val = val
-        assert type(loc) is SourceLocation
-        self.loc = loc
-
-    def __repr__(self):
-        return 'Token({0}, {1})'.format(self.typ, self.val)
-
-
-class SourceLocation:
-    def __init__(self, filename, row, col, ln):
-        self.filename = filename
-        self.row = row
-        self.col = col
-        self.length = ln
-
-    def __repr__(self):
-        return '{}, {}, {}'.format(self.filename, self.row, self.col)
-
-
-SourceRange = namedtuple('SourceRange', ['p1', 'p2'])
-
-
-class CompilerError(Exception):
-    def __init__(self, msg, loc=None):
-        self.msg = msg
-        self.loc = loc
-        if loc:
-            assert type(loc) is SourceLocation, \
-                   '{0} must be SourceLocation'.format(type(loc))
-            self.row = loc.row
-            self.col = loc.col
-        else:
-            self.row = self.col = 0
-
-    def __repr__(self):
-        return '"{}"'.format(self.msg)
-
-
-class DiagnosticsManager:
-    def __init__(self):
-        self.diags = []
-        self.sources = {}
-        self.logger = logging.getLogger('diagnostics')
-
-    def addSource(self, name, src):
-        self.logger.debug('Adding source, filename="{}"'.format(name))
-        self.sources[name] = src
-
-    def addDiag(self, d):
-        self.logger.error(str(d.msg))
-        self.diags.append(d)
-
-    def error(self, msg, loc):
-        self.addDiag(CompilerError(msg, loc))
-
-    def clear(self):
-        del self.diags[:]
-        self.sources.clear()
-
-    def printErrors(self):
-        if len(self.diags) > 0:
-            print('{0} Errors'.format(len(self.diags)))
-            for d in self.diags:
-                self.printError(d)
-
-    def printError(self, e):
-        def printLine(row, txt):
-            print(str(row) + ':' + txt)
-        print('==============')
-        if not e.loc:
-            print('Error: {0}'.format(e))
-        else:
-            if e.loc.filename not in self.sources:
-                print('Error: {0}'.format(e))
-                return
-            print("File: {}".format(e.loc.filename))
-            source = self.sources[e.loc.filename]
-            lines = source.split('\n')
-            ro, co = e.row, e.col
-            prerow = ro - 2
-            if prerow < 1:
-               prerow = 1
-            afterrow = ro + 3
-            if afterrow > len(lines):
-               afterrow = len(lines)
-
-            # print preceding source lines:
-            for r in range(prerow, ro):
-               printLine(r, lines[r-1])
-            # print source line containing error:
-            printLine(ro, lines[ro-1])
-            print(' '*(len(str(ro)+':')+co-1) + '^ Error: {0}'.format(e.msg))
-            # print trailing source line:
-            for r in range(ro+1, afterrow+1):
-              printLine(r, lines[r-1])
-        print('==============')

--- a/python/ppci/ir.py	Fri Jun 20 16:36:49 2014 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,459 +0,0 @@
-"""
-Intermediate representation (IR) code classes.
-"""
-
-
-def label_name(dut):
-    """ Returns the assembly code label name """
-    if isinstance(dut, Block):
-        f = dut.function
-        return label_name(f) + '_' + dut.name
-    elif isinstance(dut, Function) or isinstance(dut, GlobalVariable):
-        return label_name(dut.module) + '_' + dut.name
-    elif isinstance(dut, Module):
-        return dut.name
-    else:
-        raise NotImplementedError(str(dut))
-
-
-class Typ:
-    def __init__(self):
-        pass
-
-
-i32 = Typ()
-i8 = Typ()
-
-class Module:
-    """ Container unit for variables and functions. """
-    def __init__(self, name):
-        self.name = name
-        self.functions = []
-        self.variables = []
-
-    def __repr__(self):
-        return 'module {0}'.format(self.name)
-
-    def add_function(self, f):
-        """ Add a function to this module """
-        self.functions.append(f)
-        f.module = self
-
-    def add_variable(self, v):
-        assert type(v) is GlobalVariable
-        self.variables.append(v)
-        v.module = self
-
-    def get_variables(self):
-        return self.variables
-
-    Variables = property(get_variables)
-
-    def get_functions(self):
-        return self.functions
-
-    Functions = property(get_functions)
-
-    def find_function(self, name):
-        for f in self.funcs:
-            if f.name == name:
-                return f
-        raise KeyError(name)
-
-
-class Function:
-    """ Represents a function. """
-    def __init__(self, name, module=None):
-        self.name = name
-        self.entry = Block('entry')
-        self.entry.function = self
-        self.epiloog = Block('epilog')
-        self.epiloog.function = self
-        self.epiloog.addInstruction(Terminator())
-        self.return_value = Temp('{}_retval'.format(name))
-        self.arguments = []
-        self.localvars = []
-        if module:
-            module.add_function(self)
-
-    def __repr__(self):
-        args = ','.join(str(a) for a in self.arguments)
-        return 'function i32 {}({})'.format(self.name, args)
-
-    def add_block(self, bb):
-        #self.bbs.append(bb)
-        bb.function = self
-
-    def removeBlock(self, bb):
-        #self.bbs.remove(bb)
-        bb.function = None
-
-    def getBlocks(self):
-        bbs = [self.entry]
-        worklist = [self.entry]
-        while worklist:
-            b = worklist.pop()
-            for sb in b.Successors:
-                if sb not in bbs:
-                    bbs.append(sb)
-                    worklist.append(sb)
-        bbs.remove(self.entry)
-        if self.epiloog in bbs:
-            bbs.remove(self.epiloog)
-        bbs.insert(0, self.entry)
-        bbs.append(self.epiloog)
-        return bbs
-
-    def findBasicBlock(self, name):
-        for bb in self.bbs:
-            if bb.name == name:
-                return bb
-        raise KeyError(name)
-
-    Blocks = property(getBlocks)
-
-    @property
-    def Entry(self):
-        return self.entry
-
-    def check(self):
-        for b in self.Blocks:
-            b.check()
-
-    def addParameter(self, p):
-        assert type(p) is Parameter
-        p.num = len(self.arguments)
-        self.arguments.append(p)
-
-    def addLocal(self, l):
-        assert type(l) is LocalVariable
-        self.localvars.append(l)
-
-
-class Block:
-    """
-        Uninterrupted sequence of instructions with a label at the start.
-    """
-    def __init__(self, name, function=None):
-        self.name = name
-        self.function = function
-        self.instructions = []
-
-    parent = property(lambda s: s.function)
-
-    def __repr__(self):
-        return '{0}:'.format(self.name)
-
-    def addInstruction(self, i):
-        i.parent = self
-        assert not isinstance(self.LastInstruction, LastStatement)
-        self.instructions.append(i)
-
-    def replaceInstruction(self, i1, i2):
-        idx = self.instructions.index(i1)
-        i1.parent = None
-        i1.delete()
-        i2.parent = self
-        self.instructions[idx] = i2
-
-    def removeInstruction(self, i):
-        i.parent = None
-        #i.delete()
-        self.instructions.remove(i)
-
-    @property
-    def Instructions(self):
-        return self.instructions
-
-    @property
-    def LastInstruction(self):
-        if not self.Empty:
-            return self.instructions[-1]
-
-    @property
-    def Empty(self):
-        return len(self.instructions) == 0
-
-    @property
-    def FirstInstruction(self):
-        return self.instructions[0]
-
-    def getSuccessors(self):
-        if not self.Empty:
-            return self.LastInstruction.Targets
-        return []
-
-    Successors = property(getSuccessors)
-
-    def getPredecessors(self):
-        preds = []
-        for bb in self.parent.Blocks:
-            if self in bb.Successors:
-                preds.append(bb)
-        return preds
-
-    Predecessors = property(getPredecessors)
-
-    def precedes(self, other):
-        raise NotImplementedError()
-
-
-# Instructions:
-
-class Value:
-    """ A value has a type and a name """
-    def __init__(self, name, ty):
-        assert isinstance(ty, Typ)
-        self.name = name
-        self.ty = ty
-
-
-class User(Value):
-    """ Value that uses other values """
-    def __init__(self, name, ty):
-        super().__init__(name, ty)
-        # Create a collection to store the values this value uses.
-        # TODO: think of better naming..
-        self.uses = set()
-
-    def add_use(self, v):
-        assert isinstance(v, Value)
-        self.uses.add(v)
-
-
-class Expression(User):
-    """ Base class for an expression """
-    pass
-
-
-class Const(Expression):
-    """ Represents a constant value """
-    def __init__(self, value):
-        self.value = value
-
-    def __repr__(self):
-        return 'Const {}'.format(self.value)
-
-
-class Call(Expression):
-    """ Call a function with some arguments """
-    def __init__(self, f, arguments):
-        assert type(f) is str
-        self.f = f
-        self.arguments = arguments
-
-    def __repr__(self):
-        args = ', '.join(str(arg) for arg in self.arguments)
-        return '{}({})'.format(self.f, args)
-
-
-# Data operations
-class Binop(Expression):
-    """ Generic binary operation """
-    ops = ['+', '-', '*', '/', '|', '&', '<<', '>>']
-
-    def __init__(self, a, operation, b, name, ty):
-        super().__init__(name, ty)
-        assert operation in Binop.ops
-        #assert type(value1) is type(value2)
-        assert isinstance(a, Value), str(a)
-        assert isinstance(b, Value), str(b)
-        self.a = a
-        self.b = b
-        self.operation = operation
-
-    def __repr__(self):
-        a, b = self.a, self.b
-        return '({} {} {})'.format(a, self.operation, b)
-
-
-class Add(Binop):
-    """ Add a and b """
-    def __init__(self, a, b, name, ty):
-        super().__init__(a, '+', b, name, ty)
-
-
-def Sub(a, b):
-    """ Substract b from a """
-    return Binop(a, '-', b)
-
-
-def Mul(a, b, name, ty):
-    """ Multiply a by b """
-    return Binop(a, '*', b, name, ty)
-
-
-def Div(a, b):
-    """ Divide a in b pieces """
-    return Binop(a, '/', b)
-
-
-def Phi(User):
-    """ Imaginary phi instruction to make SSA possible. """
-    def __init__(self, name, ty):
-        super().__init__(name, ty)
-        self.inputs = []
-
-    def add_input(self, value, block):
-        self.inputs.append((value, block))
-
-
-class Eseq(Expression):
-    """ Sequence of instructions where the last is an expression """
-    def __init__(self, stmt, e):
-        self.stmt = stmt
-        self.e = e
-
-    def __repr__(self):
-        return '({}, {})'.format(self.stmt, self.e)
-
-
-class Alloc(Expression):
-    """ Allocates space on the stack """
-    def __init__(self):
-        super().__init__()
-
-    def __repr__(self):
-        return 'Alloc'
-
-
-class Variable(Expression):
-    def __init__(self, name, ty):
-        super().__init__(name, ty)
-        self.name = name
-
-    def __repr__(self):
-        return 'Var {}'.format(self.name)
-
-
-class LocalVariable(Variable):
-    def __repr__(self):
-        return 'Local {}'.format(self.name)
-
-
-class GlobalVariable(Variable):
-    def __repr__(self):
-        return 'Global {}'.format(self.name)
-
-
-class Parameter(Variable):
-    def __repr__(self):
-        return 'Param {}'.format(self.name)
-
-
-class Temp(Expression):
-    """ Temporary storage, same as register """
-    def __init__(self, name):
-        self.name = name
-
-    def __repr__(self):
-        return 'TMP_{}'.format(self.name)
-
-
-class Mem(Expression):
-    """ Memory access """
-    def __init__(self, e):
-        self.e = e
-
-    def __repr__(self):
-        return '[{}]'.format(self.e)
-
-
-class Load(Value):
-    """ Load a value from memory """
-    def __init__(self, address, name, ty):
-        super().__init__(name, ty)
-        assert isinstance(address, Value)
-        self.address = address
-
-    def __repr__(self):
-        return 'load {}'.format(self.address)
-
-
-class Store:
-    """ Store a value into memory """
-    def __init__(self, address, value):
-        self.address = address
-
-
-class Addr(Expression):
-    """ Address of label """
-    def __init__(self, e):
-        self.e = e
-
-    def __repr__(self):
-        return '&{}'.format(self.e)
-
-
-class Statement:
-    """ Base class for all instructions. """
-    @property
-    def IsTerminator(self):
-        return isinstance(self, LastStatement)
-
-
-class Move(Statement):
-    """ Move source to destination """
-    def __init__(self, dst, src):
-        self.dst = dst
-        self.src = src
-
-    def __repr__(self):
-        return '{} = {}'.format(self.dst, self.src)
-
-
-class Exp(Statement):
-    def __init__(self, e):
-        self.e = e
-
-    def __repr__(self):
-        return '{}'.format(self.e)
-
-
-# Branching:
-class LastStatement(Statement):
-    def changeTarget(self, old, new):
-        idx = self.Targets.index(old)
-        self.Targets[idx] = new
-
-
-class Terminator(LastStatement):
-    """ Instruction that terminates the terminal block """
-    def __init__(self):
-        self.Targets = []
-
-    def __repr__(self):
-        return 'Terminator'
-
-
-class Jump(LastStatement):
-    """ Jump statement to some target location """
-    def __init__(self, target):
-        self.Targets = [target]
-
-    def setTarget(self, t):
-        self.Targets[0] = t
-
-    target = property(lambda s: s.Targets[0], setTarget)
-
-    def __repr__(self):
-        return 'JUMP {}'.format(self.target.name)
-
-
-class CJump(LastStatement):
-    """ Conditional jump to true or false labels. """
-    conditions = ['==', '<', '>', '>=', '<=', '!=']
-
-    def __init__(self, a, cond, b, lab_yes, lab_no):
-        assert cond in CJump.conditions
-        self.a = a
-        self.cond = cond
-        self.b = b
-        self.Targets = [lab_yes, lab_no]
-
-    lab_yes = property(lambda s: s.Targets[0])
-    lab_no = property(lambda s: s.Targets[1])
-
-    def __repr__(self):
-        return 'IF {} {} {} THEN {} ELSE {}'\
-               .format(self.a, self.cond, self.b, self.lab_yes, self.lab_no)