--- a/ast/Decl.d	Fri Apr 18 23:45:45 2008 +0200
+++ b/ast/Decl.d	Wed May 21 21:11:55 2008 +0200
@@ -5,11 +5,16 @@
 
 import lexer.Token;
 
-import sema.SymbolTable;
+import tango.io.Stdout;
+
+import sema.Scope,
+       sema.DType,
+       basic.SmallArray;
 
 enum DeclType
 {
     VarDecl,
+    ImportDecl,
     FuncDecl,
     StructDecl,
 }
@@ -21,6 +26,12 @@
         this.declType = declType;
     }
 
+    void simplify()
+    {
+    }
+
+    DType type() { return null; }
+
     DeclType declType;
     Scope env;
 }
@@ -31,43 +42,148 @@
             Exp e = null)
     {
         super(DeclType.VarDecl);
-        this.type = type;
+        this.varType = type;
         this.identifier = identifier;
         this.init = e;
     }
 
-    Identifier type, identifier;
+    void simplify()
+    {
+    }
+
+    override DType type()
+    {
+        return env.find(identifier).type;
+    }
+
+    Identifier varType, identifier;
     Exp init;
 }
 
+class ImportDecl : Decl
+{
+    this()
+    {
+        super(DeclType.ImportDecl);
+    }
+
+    char[] get()
+    {
+        char[] res;
+        foreach(i ; packages)
+            res ~= i.get ~ ".";
+        res ~= name.get;
+        return res;
+    }
+
+    bool isStatic = false;
+
+    Identifier[] packages;
+    Identifier name;
+    Identifier aliasedName;
+
+    Identifier[2][] explicitSymbols;
+}
+
 class FuncDecl : Decl
 {
-    this(Identifier type, Identifier identifier, 
-            VarDecl[] funcArgs, Stmt[] statements)
+    this(Identifier type, Identifier identifier)
     {
         super(DeclType.FuncDecl);
-        this.type = type;
+        this.returnType = type;
         this.identifier = identifier;
-        this.funcArgs = funcArgs;
-        this.statements = statements;
+    }
+
+    void addParam(Identifier type, Identifier name = null)
+    {
+        funcArgs ~= new VarDecl(type, name, null);
+    }
+
+    void setBody(CompoundStatement stmts)
+    {
+        statements = stmts.statements;
+        emptyFunction = false;
     }
 
-    Identifier type, identifier;
+    void simplify()
+    {
+        if(auto t = cast(DFunction)env.find(identifier).type)
+        {
+            if(auto s = cast(DStruct)t.returnType)
+            {
+                VarDecl[] funcArgs;
+                auto i = new Identifier("ret.val");
+                i.env = env;
+                i.env.add(i);
+                i.env.find(i).setType( s );
+                auto var = new VarDecl(returnType, i);
+                var.env = env;
+                funcArgs ~= var;
+                funcArgs ~= this.funcArgs;
+                this.funcArgs = funcArgs;
+                t.returnType = DType.Void;
+                this.returnType = new Identifier("void");
+                env.find(identifier).setType(t);
+                sret = true;
+
+                myType = null;
+            }
+        }
+
+        foreach ( funcArg ; funcArgs )
+            funcArg.simplify();
+        foreach ( stmt ; statements )
+            stmt.simplify();
+    }
+
+    override DFunction type()
+    {
+        if (myType !is null)
+            return myType;
+
+        auto t = new DFunction(identifier);
+        t.returnType = env.findType(returnType);
+        SmallArray!(DType) array;
+        foreach (a; funcArgs)
+            array ~= a.type();
+        t.params = array.safe();
+        t.firstParamIsReturnValue = this.sret;
+        myType = t;
+        return myType;
+    }
+
+    Identifier returnType, identifier;
     VarDecl[] funcArgs;
     Stmt[] statements;
+    bool sret = false;
+    bool emptyFunction = true;
+    private DFunction myType;
 }
 
 class StructDecl : Decl
 {
-    this(Identifier identifier, 
-            VarDecl[] vars)
+    this(Identifier identifier)
     {
         super(DeclType.StructDecl);
         this.identifier = identifier;
-        this.vars = vars;
+    }
+
+    void addMember(Decl decl)
+    {
+        decls ~= decl;
+    }
+
+    void simplify()
+    {
+    }
+
+    override DType type()
+    {
+        return env.findType(identifier);
     }
 
     Identifier identifier;
-    VarDecl[] vars;
+    Decl[] decls;
+    private DType myType;
 }
 

--- a/ast/Exp.d	Fri Apr 18 23:45:45 2008 +0200
+++ b/ast/Exp.d	Wed May 21 21:11:55 2008 +0200
@@ -1,55 +1,168 @@
 module ast.Exp;
 
-import tango.text.Util : jhash;
+import tango.text.Util;
+import tango.io.Stdout;
+
+import ast.Decl,
+       ast.Stmt;
 
 import lexer.Token;
 
-import sema.SymbolTable;
+import sema.Scope,
+       sema.DType;
 
 enum ExpType
 {
     Binary,
     Negate,
+    Deref,
     IntegerLit,
+    MemberReference,
+    Index,
     Identifier,
+    ArrayIdentifier,
+    PointerIdentifier,
     AssignExp,
     CallExp,
+    CastExp,
+    StringExp,
 }
 
 class Exp
 {
-    this(ExpType expType) 
+    this(ExpType expType, SLoc loc)
     {
         this.expType = expType;
+        this.loc = loc;
     }
 
+    /// Get the type of the expression
+    DType type() { return null; }
+
+    /// Indicates which type the expression is - to avoid a lot of casts
     ExpType expType;
+
+    /// The environment of the expression
     Scope env;
+
+    int stmtIndex;
+
+    /**
+      The "main" location of the expression.
+      What exactly this represents varies but for most things its the start
+      while for a binary expression its the operator.
+     **/
+    SourceLocation loc;
+
+    /// Return the starting location of this expression
+    SourceLocation startLoc() { return loc; }
+
+    /// Get the full extents of the expression
+    SourceRange sourceRange() { return SourceRange(loc, loc + 1); }
+
+    Exp simplify()
+    {
+        return this;
+    }
 }
 
 class CallExp : Exp
 {
     this(Exp exp, Exp[] args)
     {
-        super(ExpType.CallExp);
+        super(ExpType.CallExp, exp.loc);
         this.exp = exp;
         this.args = args;
     }
 
+    override DType type()
+    {
+        DFunction f = cast(DFunction)exp.type();
+        assert(f !is null, "Can only call functions");
+        return f.returnType;
+    }
+
     Exp exp;
     Exp[] args;
+    bool sret = false;
+
+    override SourceRange sourceRange()
+    {
+        SourceRange res = exp.sourceRange;
+        if (args.length > 0)
+            res = res + args[$ - 1].sourceRange;
+        return res;
+    }
+
+    Exp simplify()
+    {
+        if(auto t = type.asStruct)
+        {
+            DFunction func_t = cast(DFunction)exp.type();
+            assert(func_t !is null, "Calling on something that isn't a function");
+            if (cast(DStruct)func_t.returnType is null)
+                return this;
+
+            auto call = cast(Identifier)exp;
+            FuncDecl f = env.parentFunction;
+            auto i = new Identifier("temp.var");
+            i.env = f.env;
+            f.env.add(i);
+            f.env.find(i).setType(t);
+            auto ty = new Identifier(t.name);
+            auto var = new VarDecl(ty, i, null);
+            Exp[] args; 
+            args ~= i;
+            args ~= this.args;
+            auto callExp = new CallExp(exp, args);
+            callExp.env = f.env;
+            var.env = f.env;
+            auto stmtVar = new DeclStmt(var);
+            auto stmtCall = new ExpStmt(callExp);
+            Stmt[] stmts;
+            foreach( index, s ; f.statements)
+            {
+                if(stmtIndex == index)
+                {
+                    stmts ~= stmtVar;
+                    stmts ~= stmtCall;
+                }
+                stmts ~= s;
+            }
+            f.statements = stmts;
+            callExp.sret = true;
+
+            return i;
+        }
+        return this;
+    }
 }
 
 class AssignExp : Exp
 {
-    this(Identifier identifier, Exp exp)
+    this(SLoc op, Exp identifier, Exp exp)
     {
-        super(ExpType.AssignExp);
+        super(ExpType.AssignExp, op);
         this.identifier = identifier;
         this.exp = exp;
     }
 
-    Identifier identifier;
+    Exp simplify()
+    {
+        identifier = identifier.simplify;
+        exp = exp.simplify;
+
+        return this;
+    }
+
+    override SourceRange sourceRange()
+    {
+        return identifier.sourceRange + exp.sourceRange;
+    }
+
+    override DType type() { return identifier.type(); }
+
+    Exp identifier;
     Exp exp;
 }
 
@@ -57,21 +170,63 @@
 {
     public enum Operator
     {
+        Assign,
+
         Eq, Ne,
+
         Lt, Le,
         Gt, Ge,
-        Mul, Div,
+
         Add, Sub,
+        Mul, Div, Mod,
     }
 
-    this(Operator op, Exp left, Exp right)
+    char[][] getOp = ["=","==","!=","<","<=",">",">=","+","-","*","/","%"];
+
+    this(SLoc op_loc, Operator op, Exp left, Exp right)
     {
-        super(ExpType.Binary);
+        super(ExpType.Binary, op_loc);
         this.op = op;
         this.left = left;
         this.right = right;
     }
 
+    override DType type()
+    {
+        if (myType)
+            return myType;
+
+        if (op == Operator.Eq || 
+            op == Operator.Ne ||
+            op == Operator.Lt ||
+            op == Operator.Le ||
+            op == Operator.Gt ||
+            op == Operator.Ge)
+        {
+            myType = DType.Bool;
+            return myType;
+        }
+
+        DType l = left.type;
+        DType r = right.type;
+        if (l is r)
+            myType = l;
+        else if (l.hasImplicitConversionTo(r))
+            myType = r;
+        else if (r.hasImplicitConversionTo(l))
+            myType = l;
+        else
+            return null;
+        return myType;
+    }
+
+    override SLoc startLoc() { return left.startLoc(); }
+
+    override SourceRange sourceRange()
+    {
+        return left.sourceRange + right.sourceRange;
+    }
+
     char[] resultType()
     {
         if (op >= Operator.Eq && op <= Operator.Ge)
@@ -79,39 +234,76 @@
         return null;
     }
 
+    Exp simplify()
+    {
+        left = left.simplify;
+        right = right.simplify;
+        return this;
+    }
+
     Operator op;
     Exp left, right;
+    private DType myType;
 }
 
 class NegateExp : Exp
 {
-    this(Exp exp)
+    this(SLoc op, Exp exp)
+    {
+        super(ExpType.Negate, op);
+        this.exp = exp;
+    }
+
+    Exp simplify()
+    {
+        exp = exp.simplify;
+        return this;
+    }
+
+    override DType type() { return exp.type(); }
+
+    override SourceRange sourceRange()
     {
-        super(ExpType.Negate);
+        return SourceRange(loc) + exp.sourceRange;
+    }
+
+    public Exp exp;
+}
+
+class DerefExp : Exp
+{
+    this(SLoc op, Exp exp)
+    {
+        super(ExpType.Deref, op);
         this.exp = exp;
     }
 
+    Exp simplify()
+    {
+        exp = exp.simplify;
+        return this;
+    }
+
+    override DType type() 
+    { 
+        return exp.type().asPointer.pointerOf; 
+    }
+
+    override SourceRange sourceRange()
+    {
+        return SourceRange(loc) + exp.sourceRange;
+    }
+
     public Exp exp;
 }
 
 class IntegerLit : Exp
 {
-    this(Token t)
+    this(SLoc loc, char[] t)
     {
-        super(ExpType.IntegerLit);
-        this.token = t;
-    }
-
-    Token token;
-}
-
-class Identifier : Exp
-{
-    this(Token t)
-    {
-        super(ExpType.Identifier);
-        this.token = t;
-        name = t.get;
+        super(ExpType.IntegerLit, loc);
+        range = SourceRange(loc, loc + t.length);
+        this.name = substitute(t, "_", "");
     }
 
     char[] get()
@@ -119,6 +311,223 @@
         return name;
     }
 
+    Exp simplify()
+    {
+        return this;
+    }
+
+    override DType type() { return DType.Int; }
+
+    override SourceRange sourceRange()
+    {
+        return range;
+    }
+
+    char[] name;
+    private SourceRange range;
+}
+
+class MemberReference : Exp
+{
+    this(SLoc dot, Exp target, Identifier child)
+    {
+        super(ExpType.MemberReference, dot);
+        this.target = target;
+        this.child = child;
+    }
+
+    Exp simplify()
+    {
+        target = target.simplify;
+        return this;
+    }
+
+    override DType type()
+    {
+        if (myType)
+            return myType;
+
+        DStruct st = cast(DStruct)target.type;
+        assert(st, "Only structs have members");
+        if (auto t = st.typeOf(child.name))
+            myType = t;
+        // no error reporting here
+        else assert(0, "Referencing non-existant member");
+
+        return myType;
+    }
+
+    override SLoc startLoc() { return target.startLoc(); }
+
+    override SourceRange sourceRange()
+    {
+        return target.sourceRange + child.sourceRange;
+    }
+
+    Identifier child;
+    Exp target;
+    private DType myType;
+}
+
+class IndexExp : Exp
+{
+    this(Exp target, SLoc left_bracket, Exp index, SLoc right_bracket)
+    {
+        super(ExpType.Index, target.startLoc);
+        this.target = target;
+        this.left_bracket = left_bracket;
+        this.index = index;
+        this.right_bracket = right_bracket;
+    }
+
+    override DType type()
+    {
+        DType type = target.type();
+        if (type.isArray())
+            return type.asArray().arrayOf;
+        else if (type.isPointer())
+            return type.asPointer().pointerOf;
+        else assert(0, "Can only index pointers and arrays");
+    }
+
+    override SourceRange sourceRange()
+    {
+        return target.sourceRange + SourceRange(right_bracket);
+    }
+
+    Exp simplify()
+    {
+        target = target.simplify;
+        index = index.simplify;
+        return this;
+    }
+
+    Exp target;
+    Exp index;
+    SLoc left_bracket, right_bracket;
+}
+
+class CastExp : Exp
+{
+    this(SLoc loc, Identifier castType, Exp exp)
+    {
+        super(ExpType.CastExp, loc);
+        this.castType = castType;
+        this.exp = exp;
+    }
+
+    override DType type()
+    {
+        return env.findType(this.castType);
+    }
+
+    Exp simplify()
+    {
+        castType.simplify;
+        exp.simplify;
+        return this;
+    }
+
+    override SourceRange sourceRange()
+    {
+        return SourceRange(loc) + exp.sourceRange;
+    }
+
+    Identifier castType;
+    Exp exp;
+}
+
+class StringExp : Exp
+{
+    this(SLoc loc, char[] str)
+    {
+        super(ExpType.StringExp, loc);
+        this.str = str;
+    }
+
+    char[] str;
+}
+
+class PointerIdentifier : Identifier
+{
+    this(Identifier pointerOf)
+    {
+        super(ExpType.PointerIdentifier, pointerOf.loc);
+        this.pointerOf = pointerOf;
+        this.name = pointerOf.name;
+    }
+
+    override DType type()
+    {
+        return pointerOf.type.getPointerTo();
+    }
+
+    Identifier pointerOf;
+}
+
+class ArrayIdentifier : Identifier
+{
+    this(Identifier arrayOf, IntegerLit size)
+    {
+        super(ExpType.ArrayIdentifier, arrayOf.loc);
+        this.arrayOf = arrayOf;
+        this.size = Integer.parse(size.get);
+        this.name = arrayOf.name;
+    }
+
+    override DType type()
+    {
+        return arrayOf.type.getAsArray(size);
+    }
+
+    Identifier arrayOf;
+    int size;
+
+    private DType myType;
+}
+
+class Identifier : Exp
+{
+    this(SLoc loc, char[] name)
+    {
+        super(ExpType.Identifier, loc);
+        this.name = name;
+    }
+
+    protected this(ExpType t, SLoc loc)
+    {
+        super(t, loc);
+    }
+
+    override DType type()
+    {
+        if (myType !is null)
+            return myType;
+        myType = env.find(this).type;
+        return myType;
+    }
+
+    this(char[] name)
+    {
+        super(ExpType.Identifier, SLoc.Invalid);
+        this.name = name;
+    }
+
+    char[] get()
+    {
+        return name;
+    }
+    
+    char[] getMangled()
+    {
+        DType t = type;
+
+        if(name == "main")
+            return "main";
+
+        return "_D"~name~t.mangle;
+    }
+
     hash_t toHash()
     {
         return jhash(name);
@@ -138,8 +547,17 @@
         return 0;
     }
 
-    Token token;
+    Exp simplify()
+    {
+        return this;
+    }
+
+    void setType(DType myType)
+    {
+        this.myType = myType;
+    }
+
     char[] name;
+    private DType myType;
 }
 
-

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ast/Module.d	Wed May 21 21:11:55 2008 +0200
@@ -0,0 +1,22 @@
+module ast.Module;
+
+import sema.Scope;
+
+import ast.Decl;
+
+class Module
+{
+    this(char[] moduleName)
+    {
+        this.moduleName = moduleName;
+    }
+
+    void addDecl(Decl decl)
+    {
+        decls ~= decl;
+    }
+
+    Decl[] decls;
+    char[] moduleName;
+    Scope env;
+}

--- a/ast/Stmt.d	Fri Apr 18 23:45:45 2008 +0200
+++ b/ast/Stmt.d	Wed May 21 21:11:55 2008 +0200
@@ -1,18 +1,26 @@
 module ast.Stmt;
 
+import Array = tango.core.Array,
+       Integer = tango.text.convert.Integer,
+       tango.io.Stdout;
+
 import ast.Exp,
        ast.Decl;
 
-import sema.SymbolTable;
+import sema.Scope,
+       basic.SourceLocation,
+       misc.Error;
 
 enum StmtType
 {
     Stmt,
+    Compound,
     Decl,
     Exp,
     Return,
     If,
     While,
+    Switch,
 }
 
 class Stmt
@@ -22,8 +30,30 @@
         this.stmtType = stmtType;
     }
 
+    void simplify()
+    {
+    }
+
     StmtType stmtType;
     Scope env;
+    int stmtIndex;
+}
+
+class CompoundStatement : Stmt
+{
+    this(Stmt[] stmts)
+    {
+        super(StmtType.Compound);
+        this.statements = stmts;
+    }
+
+    void simplify()
+    {
+        foreach ( stmt ; statements )
+            stmt.simplify;
+    }
+
+    Stmt[] statements;
 }
 
 class ReturnStmt : Stmt
@@ -33,6 +63,34 @@
         super(StmtType.Return);
     }
 
+    void simplify()
+    {
+        FuncDecl f = env.parentFunction;
+        if(exp)
+           exp.simplify;
+        if(f !is null && f.sret)
+        {
+            auto i = new Identifier("ret.val");
+            i.env = f.env;
+            auto ass = new AssignExp(SLoc.Invalid, i, exp);
+            ass.env = f.env;
+            auto assStmt = new ExpStmt(ass);
+            assStmt.env = f.env;
+
+            Stmt[] stmts;
+            foreach(index, stmt ; f.statements)
+            {
+                if(stmtIndex == index)
+                    stmts ~= assStmt;
+
+                stmts ~= stmt;
+            }
+            f.statements = stmts;
+            
+            exp = null;
+        }
+    }
+
     public Exp exp;
 }
 
@@ -44,6 +102,11 @@
         this.decl = decl;
     }
 
+    void simplify()
+    {
+        decl.simplify;
+    }
+
     public Decl decl;
 }
 
@@ -55,12 +118,17 @@
         this.exp = exp;
     }
 
+    void simplify()
+    {
+        exp = exp.simplify;
+    }
+
     public Exp exp;
 }
 
 class IfStmt : Stmt
 {
-    this(Exp cond, Stmt[] then, Stmt[] el = null)
+    this(Exp cond, Stmt then, Stmt el = null)
     {
         super(StmtType.If);
         this.cond = cond;
@@ -68,21 +136,113 @@
         this.else_body = el;
     }
 
+    void simplify()
+    {
+        cond.simplify;
+        then_body.simplify;
+        if (else_body)
+            else_body.simplify;
+    }
+
     Exp cond;
-    Stmt[] then_body;
-    Stmt[] else_body;
+    Stmt then_body;
+    Stmt else_body;
 }
 
 class WhileStmt : Stmt
 {
-    this(Exp cond, Stmt[] stmts)
+    this(Exp cond, Stmt stmts)
     {
         super(StmtType.While);
         this.cond = cond;
-        this.stmts = stmts;
+        this.whileBody = stmts;
+    }
+
+    void simplify()
+    {
+        cond.simplify;
+        whileBody.simplify;
     }
 
     Exp cond;
-    Stmt[] stmts;
+    Stmt whileBody;
 }
 
+class SwitchStmt : Stmt
+{
+    this(Exp target)
+    {
+        super(StmtType.Switch);
+        cond = target;
+    }
+
+    void addCase(IntegerLit[] values, Stmt[] stmts)
+    {
+        long[] new_values;
+        foreach (lit; values)
+            new_values ~= Integer.parse(lit.get);
+        cases ~= Case(values, stmts, new_values);
+
+        // Make sure there is no two cases with the same value
+        // Does it belong here?
+        new_values = new_values.dup;
+        Array.sort(new_values);
+        long[] all_values = Array.unionOf(old_values, new_values);
+        if (all_values.length != old_values.length + new_values.length)
+        {
+            // overlap!
+            auto e = new Error(
+                    "Can't have multiple cases with the same value."
+                    " Values appearing in multiple cases: %0");
+            //e.loc(values[0].token.location);
+
+            all_values = Array.intersectionOf(old_values, new_values);
+            char[][] vals;
+            foreach (val; all_values)
+                vals ~= Integer.toString(val);
+            e.arg(vals);
+            /*
+            foreach (c; cases)
+                foreach (i, v; c.values_converted)
+                    if (Array.bsearch(all_values, v))
+                        e.tok(c.values[i].token);
+            */
+            throw e;
+        }
+        old_values = all_values;
+    }
+
+    void setDefault(Stmt[] stmts)
+    {
+        if (defaultBlock.length != 0)
+            throw new Error("Switch statements can't have multiple defaults");
+        defaultBlock = stmts;
+        if (cases.length > 0)
+            cases[$ - 1].followedByDefault = true;
+    }
+
+    void simplify()
+    {
+        cond.simplify;
+        foreach ( stmt ; defaultBlock )
+            stmt.simplify;
+        foreach ( c ; cases )
+            foreach ( stmt ; c.stmts )
+                stmt.simplify;
+    }
+
+    Exp cond;
+    Case[] cases;
+    Stmt[] defaultBlock;
+
+    struct Case
+    {
+        IntegerLit[] values;
+        Stmt[] stmts;
+        long[] values_converted;
+        bool followedByDefault = false;
+    }
+
+    private long[] old_values;
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/basic/Message.d	Wed May 21 21:11:55 2008 +0200
@@ -0,0 +1,172 @@
+module basic.Message;
+
+import tango.core.Exception,
+       Array = tango.core.Array,
+       tango.io.Stdout,
+       tango.text.Util;
+
+import tango.stdc.stdlib;
+
+import llvm.type;
+
+import lexer.Token,
+       lexer.Lexer,
+       sema.DType;
+
+import basic.SourceLocation,
+       basic.SourceManager;
+
+public import basic.Messages;
+
+enum ExitLevel
+{
+    Normal = 1,
+    Lexer = 2,
+    Parser = 3,
+    Semantic = 3,
+}
+
+class MessageHandler
+{
+public:
+
+    this(SourceManager src_mgr)
+    {
+        this.src_mgr = src_mgr;
+    }
+
+    Message report(uint opcode, SLoc location)
+    {
+        Message m = new Message(opcode, location, src_mgr, this);
+        messages ~= m;
+        return m;
+    }
+
+    void checkErrors(ExitLevel exitlevel = ExitLevel.Normal)
+    {
+        if(messages.length == 0)
+            return;
+
+        if(warnings)
+            checkWarnings;
+        foreach(m ; messages)
+            if(m.type == MessageType.Error)
+            {
+                Stdout(m).newline;
+            }
+
+        exit(exitlevel);
+    }
+
+    void checkWarnings()
+    {
+        foreach(m ; messages)
+            if(m.type == MessageType.Warning)
+            {
+                Stdout(m).newline;
+            }
+    }
+
+    void showWarnings(bool value)
+    {
+        warnings = value;
+    }
+
+private:
+    Message[] messages;
+    SourceManager src_mgr;
+    bool warnings;
+}
+
+class Message
+{
+
+    this(int opcode, SLoc location, SourceManager src_mgr, MessageHandler msg_handler)
+    {
+        this.src_mgr = src_mgr;
+        this.location = location;
+        args ~= Messages[opcode].message;
+        this.type = Messages[opcode].type;
+        this.msg_handler = msg_handler;
+    }
+
+    char[] toString()
+    {
+        char[256] tmp = void;
+        char[] msg = layout(tmp, args);
+
+        Lexer l = new Lexer(location, src_mgr, new MessageHandler(src_mgr));
+
+        Token t = l.next;
+        
+        if (src_mgr.getRawData(location).length > 0)
+            msg = src_mgr.getLocationAsString(location) ~ ": " ~ msg;
+        else
+            msg = msg.dup;
+
+
+        char[] line = src_mgr.getLine(location);
+        char[] marks = line.dup;
+        marks[] = ' ';
+        size_t p = src_mgr.getColumn(location);
+        marks[p .. p + t.length] = '^';
+
+        msg ~= "\n    ";
+        msg ~= line;
+        msg ~= "\n    ";
+        msg ~= marks;
+
+        return msg;
+    }
+
+    Message arg(char[] s)
+    {
+        if (args.length == 11)
+            throw new Exception("Sorry, errors only support up to 10 args");
+        args ~= s;
+        return this;
+    }
+
+    Message arg(char[][] s)
+    {
+        char[] res = s[0 .. $ - 1].join(", ");
+        if (s.length > 1)
+            res ~= " and ";
+        res ~= s[$ - 1];
+        return arg(res);
+    }
+
+    Message arg(char c)
+    {
+        return arg([c]);
+    }
+
+    Message arg(DType[] types)
+    {
+        char[][] res;
+        foreach (type; types)
+            res ~= type.name();
+        return arg(res);
+    }
+
+    Message fatal(ExitLevel exitlevel = ExitLevel.Normal)
+    {
+        msg_handler.checkErrors(exitlevel);
+        return this;
+    }
+
+    /*
+    Message loc(SLoc loc)
+    {
+        location = loc;
+        return this;
+    }
+    */
+
+    MessageType type;
+private:
+    char[][] args;
+    SLoc location;
+    SourceManager src_mgr;
+    MessageHandler msg_handler;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/basic/Messages.d	Wed May 21 21:11:55 2008 +0200
@@ -0,0 +1,73 @@
+module basic.Messages;
+
+enum : uint
+{
+    // Lex
+    InvalidSymbol,
+    InvalidIlligaleType,
+    UnexpectedEOFBlock,
+    OnlyOneDotFloating,
+    OnlyOneEFloating,
+
+    // Parse
+    UnexpectedTokMulti,
+    UnexpectedTokSingle,
+    UnexpectedTok,
+    CaseValueMustBeInt,
+    UnexpectedBeginStmt,
+    UnexpectedTokType,
+    ExpectedIdAfterDot,
+    ExpectedExp,
+    ExpectedCastType,
+    InvalidDeclType,
+    InvalidType,
+    //   - imports/module
+    ExpectedIdAfterPackage,
+    RenameMustBeSingleIdent,
+
+
+    // Imports
+    CannotFindModule,
+}
+
+enum MessageType
+{
+    Warning,
+    Error,
+}
+
+MessageEntry[uint] Messages;
+
+struct MessageEntry
+{
+    MessageType type;
+    char[] message;
+}
+    
+private alias MessageType.Error Err;
+private alias MessageType.Warning War;
+private alias MessageEntry E;
+static this()
+{
+    Messages = [
+        UnexpectedEOFBlock  : E(Err, "Unexpected end of file. Unclosed comment block"),
+        InvalidSymbol       : E(Err, "Read invalid symbol: '%0'"),
+        OnlyOneDotFloating  : E(Err, "Only one '.' is allowed in an floating number"),
+        OnlyOneEFloating    : E(Err, "Only one E is allowed in an floating number"),
+
+        UnexpectedTokMulti  : E(Err, "Unexpected token, got %0 expected one of %1"),
+        UnexpectedTokSingle : E(Err, "Unexpected token, got %0 expected %1"),
+        UnexpectedTok       : E(Err, "Unexpected token %0"),
+        CaseValueMustBeInt  : E(Err, "Cases can only be integer literals"),
+        UnexpectedBeginStmt : E(Err, "Unexpected begining of statement."),
+        UnexpectedTokType   : E(Err, "Unexpected token in Type parsing. Got %0"),
+        ExpectedIdAfterDot  : E(Err, "Expected identifier after '.'"),
+        ExpectedExp         : E(Err, "Expected expression"),
+        ExpectedCastType    : E(Err, "Expected cast type"),
+        InvalidDeclType     : E(Err, "Invalid declaration type"),
+        InvalidType         : E(Err, "Invalid type"),
+        ExpectedIdAfterPackage : E(Err, "Identifier expected following package"),
+        CannotFindModule    : E(Err, "Cannot find module '%0'")
+    ];
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/basic/SmallArray.d	Wed May 21 21:11:55 2008 +0200
@@ -0,0 +1,106 @@
+module basic.SmallArray;
+
+/**
+  This struct acts like a normal dynamic array, with one difference.
+  A size is given, which is how many elements are preallocated on the stack.
+
+  Example:
+  --------
+  SmallArray!(float, 4) array;
+  array ~= 1.0;
+  array ~= 2.0;
+  array ~= 3.0;
+  float[] three_floats = array[0 .. 3];
+  // The slice gives a reference to the stack, remember to .dup
+  array ~= 4.0;
+  // not using the heap yet, but after the next line all values will have been
+  // copied to the heap.
+  array ~= 5.0;
+  --------
+
+  Compared to a normal dynamic array there is 8 bytes overhead (on 32 bit cpus)
+  and ofcourse size * T.sizeof bytes for the stack allocated array.
+ */
+struct SmallArray(T, ubyte size = 8)
+{
+    T[] opSlice(size_t low, size_t high)
+    {
+        assert(high <= len && low <= high, "Array index out of range");
+        return ptr[low .. high];
+    }
+
+    T[] opSlice()
+    {
+        return ptr[0 .. len];
+    }
+    alias opSlice unsafe;
+
+    T[] safe()
+    {
+        if (len <= size)
+            return static_array[0 .. len].dup;
+        return array[0 .. len];
+    }
+
+    T[] opSliceAssign(T val, size_t low, size_t high)
+    {
+        assert(high <= len && low <= high, "Array index out of range");
+        return ptr[low .. high] = val;
+    }
+
+    T[] opSliceAssign(T val)
+    {
+        return ptr[0 .. len] = val;
+    }
+
+    T opIndex(size_t index)
+    {
+        assert(index < len, "Array index out of range");
+        return ptr[index];
+    }
+
+    T opIndexAssign(T val, size_t index)
+    {
+        assert(index < len, "Array index out of range");
+        return ptr[index] = val;
+    }
+
+    void opCatAssign(T val)
+    {
+        if (len < size)
+            static_array[len] = val;
+        else if (len == size)
+        {
+            T[] tmp = static_array[].dup;
+            array = tmp;
+            array ~= val;
+        }
+        else
+            array ~= val;
+
+        ++len;
+        if (len <= size)
+            ptr = static_array.ptr;
+        else
+            ptr = array.ptr;
+    }
+
+    size_t length() { return len; }
+
+    static SmallArray opCall()
+    {
+        SmallArray array;
+        array.ptr = array.static_array.ptr;
+        return array;
+    }
+
+private:
+    T* ptr;
+    size_t len;
+    union
+    {
+        T[] array;
+        T[size] static_array;
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/basic/SourceLocation.d	Wed May 21 21:11:55 2008 +0200
@@ -0,0 +1,145 @@
+module basic.SourceLocation;
+
+/// Shorter alias for SourceLocation
+public alias SourceLocation SLoc;
+
+/// SourceLocation points to a place in some buffer
+struct SourceLocation
+{
+    /// Returns true, if the location is from a real file
+    bool isReal() { return (val & 0x80_00_00_00) == 0; }
+    /// Returns true, if the location is not from a real file
+    bool isVirtual() { return (val & 0x80_00_00_00) != 0; }
+
+    /// Check if this location is invalid or not
+    bool isValid() { return val != uint.max; }
+    /// ditto
+    bool isInvalid() { return val == uint.max; }
+
+    /**
+      Extracts the file id.
+
+      Warning: In release mode this may return junk, if the loc is not from a
+      file
+     **/
+    uint fileID() {
+        assert(isValid, "Location is invalid");
+        assert(isReal, "You can only extract fileID from a real location");
+        // Here we can rely on two facts, first that the high bit is zero
+        // since its a real position, second that FileOffset is saved in the
+        // high end, so all we need is some shifting
+        return val >> Bits.FileOffset;
+    }
+
+    /**
+      Extracts the offset into the "file". (actually in to the referenced
+      chunk)
+
+      Warning: In release mode this may return junk, if the loc is not from a
+      file
+     **/
+    uint fileOffset() {
+        assert(isValid, "Location is invalid");
+        assert(isReal, "You can only extract fileOffset from real locations");
+        // FileOffset is stored in the lower bits, so all that is needed is a
+        // binary and with all ones in the lower bits.
+        return val & (1 << Bits.FileOffset) - 1;
+    }
+
+    /// Get a new location, placed n bytes after the given location
+    SourceLocation opAdd(int n)
+    {
+        SourceLocation res = *this;
+        res.val += n;
+        return res;
+    }
+
+    /// Get a new location, placed n bytes before the given location
+    SourceLocation opSub(int n)
+    {
+        SourceLocation res = *this;
+        res.val -= n;
+        return res;
+    }
+
+    /// Creates a SourceLocation from a File ID
+    static SourceLocation fromFileID(uint fileID)
+    {
+        assert(fileID < Bits.MaxFileID, "To large fileID");
+        SourceLocation res;
+        res.val = fileID << Bits.FileOffset;
+        return res;
+    }
+
+    /**
+      Used for invalid/unknown locations. (also the default value, but this is
+      more explicit)
+     **/
+    static const SourceLocation Invalid = {val: uint.max};
+
+private:
+    /**
+      A SourceLocation consists of 1 bit, indicating real or virtual, meaning
+      if the location points to a file(real), a string mixin or has been
+      affected by #line(virtual). That information is saved in the most
+      significant bit.
+      The rest depends on which type we are dealing with.
+      Real:
+           13 bits for a file identifier
+           18 bits for offset into that "file" (one file may be split)
+      Virtual:
+           Unknown for now. Likely skewed toward more ids and some meta data
+      An invalid location is uint.max, this might happen by accident but its
+      unlikely.
+     **/
+    uint val = uint.max;
+
+    /**
+      This enum contains some constants that are useful for manipulating
+      SourceLocation's, like the size of various “members” of val.
+     **/
+    static enum Bits {
+        /// Number of bits used for the offset into file buffers
+        FileOffset = 18,
+        /// Number of bits used to identify which file buffer this is from
+        FileID = 31 - FileOffset,
+
+        /// Indicates how much can be indexed within one block(2^FileOffset)
+        MaxFileOffset = 1 << FileOffset,
+        MaxFileID = 1 << FileID,
+    }
+}
+
+/// A simple pair used to describe a range in a buffer and not just a point.
+struct SourceRange
+{
+    SourceLocation begin, end;
+
+    static SourceRange opCall(SourceLocation loc)
+    {
+        return SourceRange(loc, loc + 1);
+    }
+
+    static SourceRange opCall(SourceLocation begin, SourceLocation end)
+    {
+        SourceRange res;
+        res.begin = begin;
+        res.end = end;
+        return res;
+    }
+
+    bool isValid() { return begin.isValid && end.isValid; }
+    bool isInvalid() { return begin.isInvalid || end.isInvalid; }
+
+    bool isReal() { return begin.isReal && end.isReal; }
+
+    /// Get a new range spanning both ranges
+    SourceRange opAdd(SourceRange that)
+    {
+        assert(this.isValid && that.isValid, "Invalid range");
+        return SourceRange(
+                this.begin.val < that.begin.val? this.begin : that.begin,
+                this.end.val > that.end.val? this.end : that.end);
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/basic/SourceManager.d	Wed May 21 21:11:55 2008 +0200
@@ -0,0 +1,284 @@
+module basic.SourceManager;
+
+import tango.core.Memory : GC;
+import tango.io.UnicodeFile;
+import tango.io.Stdout;
+import tango.text.convert.Layout;
+
+public import basic.SourceLocation;
+
+private alias char[] string;
+
+/**
+  SourceManager is used to handle input files, by loading them in in chunks
+  that can be referenced elsewhere.
+
+  It will also help extract the line/col of locations and convert between
+  real and virtual locations
+ **/
+class SourceManager
+{
+    this()
+    {
+        layout = new Layout!(char);
+    }
+
+    /**
+      Will load in the file belonging to the filename
+
+        filename = The file to load. Theres some assumptions about this file.
+            1. The file has a BOM or is valid utf-8
+            2. The file is not empty, unreadable, a folder etc.
+     **/
+    SourceLocation addFile(string filename)
+    {
+        scope file = new UnicodeFile!(char)(filename, Encoding.UTF_8);
+        auto file_data = file.read();
+        return createCheckpoints(file_data, filename);
+    }
+
+    /**
+      Returns a string slice containing the part of the file after loc (a
+      pointer might be better, it allows negative indexing)
+     **/
+    string getRawData(SourceLocation loc)
+    {
+        CP cp = checkpoints[loc.fileID];
+        auto length = cp.data_end - cp.data.ptr;
+        return cp.data.ptr[loc.fileOffset .. length];
+    }
+
+    /**
+      Extracts the line number of the given location
+      O("file size") if cache isn't built, O(log "lines in file") else
+     **/
+    uint getLineNumber(SourceLocation loc)
+    {
+        assert(loc.isValid, "Location is invalid");
+        assert(loc.isReal, "Virtual locations not supported yet");
+        assert(loc.fileID < checkpoints.length, "Non-existent location");
+
+        CP* cp = &checkpoints[loc.fileID];
+        auto cache = &linecache[cp.meta_index];
+        if (!cache.isCached)
+            cache.build(cp.data_start[0 .. cp.data_end - cp.data_start]);
+        return cache.lineOf(getFileOffset(loc));
+    }
+
+    /**
+      Extracts the full byte offset into a file, at which a location
+      is pointing.
+     **/
+    uint getFileOffset(SourceLocation loc)
+    {
+        return loc.fileOffset
+            + checkpoints[loc.fileID].part * loc.Bits.MaxFileOffset;
+    }
+
+    /**
+      Extracts a string containing the entire line loc appears in.
+     **/
+    string getLine(SourceLocation loc)
+    {
+        // The line is extracted by getting two pointers to the exact location
+        // and decreasing one until the nearest newline while the other ptr is
+        // increased to the nearest newline.
+        CP* cp = &checkpoints[loc.fileID];
+        char* ptr = cp.data.ptr + loc.fileOffset;
+        char* ptr_lo = ptr;
+        while (cp.inRange(ptr_lo) && *ptr_lo != '\n' && *ptr_lo != '\r')
+            --ptr_lo;
+        while (cp.inRange(ptr) && *ptr != '\n' && *ptr != '\r')
+            ++ptr;
+        return ptr_lo[1 .. ptr - ptr_lo];
+    }
+
+    /**
+      Gets the column of where the loc appears.
+     **/
+    int getColumn(SourceLocation loc)
+    {
+        // Use same approach as getLine
+
+        CP* cp = &checkpoints[loc.fileID];
+        char* ptr = cp.data.ptr + loc.fileOffset;
+        char* ptr_lo = ptr;
+        while (cp.inRange(ptr_lo) && *ptr_lo != '\n' && *ptr_lo != '\r')
+            --ptr_lo;
+        return cast(int)ptr - cast(int)ptr_lo - 1;
+    }
+
+    /**
+      Get the original source text of a SourceRange
+     **/
+    string getText(SourceRange loc)
+    {
+        assert(loc.isValid, "Range is invalid");
+        assert(loc.isReal, "Virtual locations not supported yet");
+        auto begin  = getFileOffset(loc.begin);
+        auto end    = getFileOffset(loc.end);
+        return checkpoints[loc.begin.fileID].data_start[begin .. end];
+    }
+
+    /**
+      Get the original source text
+     **/
+    string getText(SourceLocation loc, size_t length)
+    {
+        return getText(SourceRange(loc, loc + length));
+    }
+
+    /**
+      Convert a location into a string. Something like "file(line)"
+     **/
+    string getLocationAsString(SourceLocation loc)
+    {
+        assert(loc.isValid, "Location is invalid");
+        return layout.convert("{}({})",
+            checkpoints[loc.fileID].filename,
+            getLineNumber(loc));
+    }
+    string getLocationAsString(SourceRange loc)
+    {
+        return layout.convert("{}({}:{})",
+            checkpoints[loc.begin.fileID].filename,
+            getFileOffset(loc.begin),
+            getFileOffset(loc.end));
+    }
+
+    /**
+      Get the file name of a loc.
+     **/
+    string getFile(SourceLocation loc)
+    {
+        return checkpoints[loc.fileID].filename;
+    }
+
+private:
+    synchronized
+        SourceLocation createCheckpoints(string data, string source_file)
+    {
+        // The line-cache is added, but not built,
+        // getLineNumber makes sure it is called when needed.
+        linecache ~= FileLineCache();
+        uint meta_index = linecache.length - 1;
+
+        // SourceLocation's can only index relatively short buffers, therefore
+        // the file is split into several checkpoints.
+        uint checkpoint_counter = 0;
+        char* data_start = data.ptr;
+        char* data_end = data.ptr + data.length;
+        while (data.length > 0)
+        {
+            uint to_take = min(data.length, SourceLocation.Bits.MaxFileOffset);
+            checkpoints ~=
+                CP(source_file,
+                        data_start,
+                        data_end,
+                        data[0 .. to_take],
+                        checkpoint_counter++,
+                        meta_index);
+            data = data[to_take .. $];
+        }
+        checkpoint_counter = checkpoints.length - checkpoint_counter;
+        return SourceLocation.fromFileID(checkpoint_counter);
+    }
+
+    /// Contains the read/generated data.
+    CP[] checkpoints;
+    /// Cache used to speed up finding of line-starts.
+    FileLineCache[] linecache;
+    /// Used for formatting locations as strings.
+    Layout!(char) layout;
+
+    // These really should be magically available everywhere and templated.
+    int min(int a, int b) { return a < b? a : b; }
+    int max(int a, int b) { return a >= b? a : b; }
+
+    // A Check Point is used to store a file in multiple parts, to overcome
+    // the limitation of SourceLocation only having a rather limited amount of
+    // bits to index any one file.
+    struct CP
+    {
+        // read-only
+        char[] filename;
+        // ditto
+        char* data_start;
+        char* data_end;
+        // ditto
+        char[] data;
+        // ditto
+        uint part = 0;
+        // ditto
+        uint meta_index = 0;
+
+        bool inRange(char* p)
+        {
+            return p >= data_start && p < data_end;
+        }
+    }
+
+    struct FileLineCache
+    {
+        /// Contains the offset of the i'th line on index i
+        uint[] line_starts;
+
+        /// Indicates weather the cache has been built or not
+        bool isCached = false;
+
+        /**
+          This method does a binary search to find the line that contains the
+          given offset.
+         **/
+        uint lineOf(uint offset)
+        {
+            size_t  beg = 0,
+                    end = line_starts.length,
+                    mid = end >> 1;
+
+            while( beg < end )
+            {
+                if( line_starts[mid] <= offset )
+                    beg = mid + 1;
+                else
+                    end = mid;
+                mid = beg + ( end - beg ) / 2;
+            }
+            return mid;
+        }
+
+        /**
+          Builds the cache data - always make sure this has been called before
+          calling lineOf.
+         **/
+        void build(char[] data)
+        {
+            // j starts at 1, because we need an additional place in the array
+            // to indicate that line 1 starts at index 0.
+            size_t j = 1;
+            char* it = data.ptr, end = data.ptr + data.length;
+            for (; it != end; ++it)
+                if (*it == '\n')
+                    ++j;
+            // Allocate without initialization. Saves a bit of time
+            line_starts.length = j;
+            line_starts[0] = 0;
+
+            // Go over the data again, writing the line starts in our new array
+            j = 1;
+            for (size_t i = 0; i < data.length; i++)
+            {
+                if (data[i] == '\n')
+                    line_starts[j++] = i;
+                else if (data[i] == '\r')
+                {
+                    line_starts[j++] = i;
+                    i += cast(size_t)(data[i+1] == '\n');
+                }
+            }
+
+            isCached = true;
+        }
+    }
+}
+

--- a/dang/compiler.d	Fri Apr 18 23:45:45 2008 +0200
+++ b/dang/compiler.d	Wed May 21 21:11:55 2008 +0200
@@ -2,51 +2,65 @@
 
 import tango.io.Stdout,
        tango.core.Signal,
+       tango.core.Memory,
+       tango.sys.Process,
+       tango.time.StopWatch,
+       tango.io.FileConduit,
        tango.io.FilePath;
 
 import lexer.Lexer,
        parser.Parser;
 
-import misc.DataSource;
+import basic.SourceManager;
 
-import ast.Decl;
+import basic.Message;
+
+import ast.Module;
 
 import tools.AstPrinter,
        tools.DotPrinter;
 
-import gen.LuaGen,
-       gen.LLVMGen;
+import gen.CodeGen;
 
 import sema.Visitor,
-       sema.SymbolTableBuilder,
-       sema.Declarations;
+       sema.AstAction,
+       sema.ScopeBuilder,
+       sema.ScopeCheck,
+       sema.TypeCheck;
 
-import dang.OptParse;
+import tango.stdc.posix.unistd;
+
+import Opt = dang.OptParse;
 
 void checkFiles(char[][] *files)
 {
-    bool error = false;
+    GC.disable();
+    bool non_existant_files = false;
+    bool duplicate_files = false;
 
     char[][] validFiles;
 
-    foreach(file ; *files)
+    foreach (file; *files)
     {
-        auto path = new FilePath(file);
+        scope path = new FilePath(file);
 
-        if(!path.exists)
+        if (!path.exists)
         {
-            Stdout("File '"~file~"' does not exists").newline;
-            error = true;
+            Stderr.formatln("'{}' does not exist", file).newline;
+            non_existant_files = true;
 
             continue;
         }
         
         bool fileInStack = false;
-        foreach(vFile ; validFiles)
-            if(vFile == file)
+        foreach (vFile; validFiles)
+            if (vFile == file)
+            {
                 fileInStack = true;
+                duplicate_files = true;
+            }
 
-        if(fileInStack)
+        if (fileInStack)
             continue;
 
         validFiles ~= file;
@@ -54,9 +68,12 @@
 
     *files = validFiles;
 
-    if(error)
-        throw new Exception("Some file(s) did not exist");
+    if (non_existant_files)
+        throw new Exception("All files given must exist");
+    if (duplicate_files)
+        Stderr("warning: duplicate files ignored").newline;
 }
+
 void main(char[][] args)
 {
     char[][] filesToHandle;
@@ -67,118 +84,182 @@
     Signal!(Lexer) postLex;
 
     Signal!(Lexer) preParse;
-    Signal!(Decl[], DataSource) postParse;
+    Signal!(Module[], SourceManager) postParse;
 
     preStart.attach(&checkFiles);
 
-    auto argParse = new OptionParser;
+    auto argParse = new Opt.OptionParser(`Dang "D" compiler v0.0`);
+
+    bool optimize = false;
+    bool inline = false;
+
 
-    argParse.addOption(
-            ["-h", "--help"],{
-                argParse.helpText();
-                return;
-            }
-    ).help("Show this help message");
+    SourceManager src_mgr = new SourceManager;
+    MessageHandler messages = new MessageHandler(src_mgr);
+
+    argParse.addOption(["-h", "--help"], Opt.Action.Help)
+        .help("Show this help message");
 
-    argParse.addOption(
-            ["--ast-dump-dot"], {
-                postParse.attach(
-                    (Decl[] decls, DataSource src) {
-                        auto print = new DotPrinter();
-                        print.print(decls);
-                    });
-            }
-    ).help("Output the AST as dot-graphicz");
+    argParse.addOption(["--ast-dump-dot"],
+            "what-to-do", Opt.Action.StoreConst, "dot")
+        .help("Output the AST in the dot format");
+    argParse.addOption(["--ast-dump-code"],
+            "what-to-do", Opt.Action.StoreConst, "code")
+        .help("Output the AST as code");
+    argParse.addOption(["--gen-llvm"],
+            "what-to-do", Opt.Action.StoreConst, "gen-llvm")
+        .help("Compile to LLVM code (default)");
+    argParse.addOption(["-c"],
+            "what-to-do", Opt.Action.StoreConst, "compile")
+        .help("Compile to .o or executeable");
 
     argParse.addOption(
-            ["--ast-dump-code"], {
-                postParse.attach(
-                    (Decl[] decls, DataSource src) {
-                        auto print = new AstPrinter(src);
-                        print.print(decls);
-                    });
+            ["-O","--optimize"], {
+                optimize = true;
             }
-    ).help("Output the AST as dot-graphicz");
+    ).help("Tell LLVM to do its standard optimizations");
 
     argParse.addOption(
-            ["--gen-lua"], {
-                postParse.attach(
-                    (Decl[] decls, DataSource src) {
-                        auto luaGen = new LuaGen();
-                        luaGen.gen(decls);
-                    });
+            ["--inline"], {
+                inline = true;
             }
-    ).help("Compile to Lua code");
+    ).help("Tell LLVM that its allowed to inline functions");
 
-    argParse.addOption(
-            ["--gen-llvm"], {
-                postParse.attach(
-                    (Decl[] decls, DataSource src) {
-                        auto llvmGen = new LLVMGen();
-                        llvmGen.gen(decls);
-                    });
-            }
-    ).help("Compile to LLVM code");
+    argParse
+        .addOption(["--time"], Opt.Action.SetTrue, "time")
+        .help("Time the various operations performed.");
 
     auto options = argParse.parse(args);
 
     filesToHandle ~= options.args;
     
-    try
-    {
-        preStart(&filesToHandle);
-    }
-    catch(Exception e)
-    {
-        return;
-    }
+    // Will throw exception if some files don't exist
+    preStart(&filesToHandle);
+
+    struct Measurement { char[] label; double time; }
+    Measurement[] timings;
 
-    foreach(file ; filesToHandle)
+    auto what = options["what-to-do"];
+    if (what == "" || what == "gen-llvm")
+        postParse.attach(
+            (Module[] modules, SourceManager sm) {
+                foreach(m ; modules)
+                {
+                    StopWatch w; w.start;
+                    auto llvmGen = new CodeGen();
+                    auto file = new FileConduit(m.moduleName~".bc", FileConduit.WriteCreate);
+                    llvmGen.gen(m, file.fileHandle, optimize, inline);
+                    timings ~= Measurement("Generating LLVM bytecode", w.stop); 
+                }
+            });
+    else if (what == "compile")
+        postParse.attach(
+            (Module[] modules, SourceManager sm) {
+                foreach(m ; modules)
+                {
+                    StopWatch w; w.start;
+                    auto llvmGen = new CodeGen();
+                    auto llc = new Process("llc","-o=-");
+                    auto gcc = new Process("gcc","-c","-o","out.o","-x","assembler","-");
+                    llc.execute();
+                    int i = dup(llc.stdin.fileHandle);
+                    llc.stdin.detach;
+                    llvmGen.gen(m, i, optimize, inline);
+                    llc.wait();
+                    gcc.execute();
+                    gcc.stdin.copy(llc.stdout);
+                    gcc.stdin.detach;
+                    gcc.wait();
+                    timings ~= Measurement("Generating assemble bytecode", w.stop);
+                }
+
+            });
+    else if (what == "dot")
+        postParse.attach(
+            (Module[] m, SourceManager sm) {
+                StopWatch w; w.start;
+  //              auto print = new DotPrinter();
+//                print.print(m);
+                timings ~= Measurement("Generating dot output", w.stop);
+            });
+    else if (what == "code")
+        postParse.attach(
+            (Module[] modules, SourceManager sm) {
+                StopWatch w; w.start;
+                auto print = new AstPrinter(sm);
+                foreach ( m ; modules )
+                    print.print(m);
+                timings ~= Measurement("Converting AST to text", w.stop);
+            });
+    StopWatch total;
+    total.start;
+
+    Module[] modules;
+
+    StopWatch watch;
+    watch.start;
+    foreach (file; filesToHandle)
     {
         preLex(file);
 
-        auto src = DataSource(file);
-        auto lexer = new Lexer(src);
-/*
-        auto t = lexer.next;
-        while(t.getType != "EOF")
-        {
-            Stdout(t.getType)(" : ")(t.get).newline;
-            t = lexer.next;
-        }
-        lexer = new Lexer(src);
-*/
+        auto start = src_mgr.addFile(file);
+        auto lexer = new Lexer(start, src_mgr, messages);
         postLex(lexer);
 
         preParse(lexer);
 
-        auto parser = new Parser;
-        auto decls = parser.parse(lexer);
+        auto parser = new Parser(messages);
+        auto action = new AstAction(src_mgr);
+        modules ~= cast(Module)parser.parse(src_mgr, lexer, action);
+        timings ~= Measurement("Lex + Parse of '"~file~"'", watch.stop);
+        messages.checkErrors(ExitLevel.Parser);
+/*
+        StopWatch watch2;
+        watch.start;
+        watch2.start;
+        Module[] mods = (new LoadModule).visit(m, src_mgr, messages);
+        (new ScopeBuilder).visit(m);
+        auto scope_builder = watch2.stop;
+        watch2.start;
+        (new ScopeCheck).visit(m);
+        auto scope_check = watch2.stop;
+        watch2.start;
+        (new TypeCheck).visit(m);
+        auto type_check = watch2.stop;
+        watch2.start;
 
-        (new SymbolTableBuilder).visit(decls);
-        (new Declarations).visit(decls);
+        foreach (decl; m.decls)
+            decl.simplify();
+        auto simplify = watch2.stop;
+        auto extra_stuff = watch.stop;
+        timings ~= Measurement("Extra stuff", watch.stop);
+        timings ~= Measurement("  - Building scopes", scope_builder);
+        timings ~= Measurement("  - Checking scopes", scope_check);
+        timings ~= Measurement("  - Checking types", type_check);
 
-        postParse(decls, src);
+        postParse(m, src_mgr);*/
     }
 
-/*    if (args.length > 1 && args[1] == "lex")
-    {
-        Token t;
+    (new ScopeBuilder).visit(modules);
+    StopWatch watch2;
+    watch.start;
+    watch2.start;
+    (new ScopeCheck).visit(modules);
+    auto scope_check = watch2.stop;
+    watch2.start;
+    (new TypeCheck).visit(modules);
+    auto type_check = watch2.stop;
+    watch2.start;
 
-        t = lexer.next();
-        while(t.type != Tok.EOF)
-        {
-            Stdout(src.get(t.position, t.length)).newline;
-            t = lexer.next();
-        }
-    }
-    else
-    {
-        auto decl = parser.parse(lexer);
-        if(args.length > 1 && args[1] == "dump-ast")
-        {
-            auto buffer = new AstBuffer(src.data);
-            decl.print(buffer);
-        }
-    }*/
+    foreach (m; modules)
+        foreach (decl; m.decls)
+            decl.simplify();
+
+    timings ~= Measurement("Total", total.stop);
+    postParse(modules, src_mgr);
+
+    if (options.flag("time"))
+        foreach (m; timings)
+            Stderr.formatln("{,-45} {}ms", m.label, m.time*1e3);
 }
+

--- a/dsss.conf	Fri Apr 18 23:45:45 2008 +0200
+++ b/dsss.conf	Wed May 21 21:11:55 2008 +0200
@@ -1,9 +1,20 @@
 [lexer]
 [parser]
 [ast]
+[gen]
+
 
 [dang/compiler.d]
 Target = Dang
+buildflags =  -llstdc++ \
+ -llLLVMSystem -llLLVMSupport -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \
+ -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \
+ -llLLVMInstrumentation -llllvm-c-ext -lldl
 
 [tests/run.d]
 Target = tests/run
+buildflags = -llllvm-c-ext -llstdc++ \
+ -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \
+ -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \
+ -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gen/CodeGen.d	Wed May 21 21:11:55 2008 +0200
@@ -0,0 +1,825 @@
+module gen.CodeGen;
+
+import tango.io.Stdout,
+       Int = tango.text.convert.Integer;
+import tango.core.Array : find, partition;
+
+import LLVM = llvm.llvm;
+
+import ast.Module,
+       ast.Decl,
+       ast.Stmt,
+       ast.Exp;
+
+import misc.Error,
+       basic.SmallArray;
+
+import lexer.Token;
+
+import sema.Scope,
+       sema.Visitor;
+
+alias LLVM.Value Value;
+alias LLVM.Type Type;
+alias LLVM.Function Function;
+alias LLVM.PointerType PointerType;
+alias LLVM.FunctionType FunctionType;
+alias LLVM.IntPredicate IntPredicate;
+alias LLVM.ParamAttr ParamAttr;
+alias LLVM.ConstantInt ConstantInt;
+alias LLVM.GlobalVariable GlobalVariable;
+alias LLVM.IntegerType IntegerType;
+alias LLVM.BasicBlock BasicBlock;
+alias LLVM.StructType StructType;
+alias LLVM.ArrayType ArrayType;
+
+private char[] genBuildCmp(char[] p)
+{
+    return `
+        Value build`~p~`(Value l, Value r, char[] n)
+        {
+            return b.buildICmp(IntPredicate.`~p~`, l, r, n);
+        }`;
+}
+
+class CodeGen
+{
+private:
+    mixin(genBuildCmp("EQ"));
+    mixin(genBuildCmp("NE"));
+    mixin(genBuildCmp("SLT"));
+    mixin(genBuildCmp("SLE"));
+    mixin(genBuildCmp("SGT"));
+    mixin(genBuildCmp("SGE"));
+
+public:
+    this()
+    {
+        alias BinaryExp.Operator op;
+        b = new LLVM.Builder;
+        
+        opToLLVM = [
+            op.Add      : &b.buildAdd,
+            op.Sub      : &b.buildSub,
+            op.Mul      : &b.buildMul,
+            op.Div      : &b.buildSDiv,
+            op.Eq       : &buildEQ,
+            op.Ne       : &buildNE,
+            op.Lt       : &buildSLT,
+            op.Le       : &buildSLE,
+            op.Gt       : &buildSGT,
+            op.Ge       : &buildSGE
+        ];
+        table = new SimpleSymbolTable();
+
+        createBasicTypes();
+    }
+
+    ~this()
+    {
+//        b.dispose();
+    }
+
+    void gen(Module mod, uint handle, bool optimize, bool inline)
+    {
+        this.mod = mod;
+        // create module
+        m = new LLVM.Module("main_module");
+        scope(exit) m.dispose();
+
+        table.enterScope;
+
+        BytePtr = PointerType.Get(Type.Int8);
+        auto temp = FunctionType.Get(Type.Void, [BytePtr, BytePtr, Type.Int32, Type.Int32]);
+        llvm_memcpy = m.addFunction(temp, "llvm.memcpy.i32");
+
+        auto registerFunc =
+            (FuncDecl fd)
+            {
+                Type[] param_types;
+                foreach (i, p; fd.funcArgs)
+                {
+                    DType t = p.env.find(p.identifier).type;
+                    if(auto st = t.asStruct)
+                    {
+                        Type pointer = PointerType.Get(llvm(st));
+                        param_types ~= pointer;
+                    }
+                    else if(auto ar = t.asArray)
+                    {
+                        Type pointer = PointerType.Get(llvm(ar));
+                        param_types ~= pointer;
+                    }
+                    else
+                        param_types ~= llvm(t);
+                }
+                auto ret_t = fd.env.find(fd.identifier).type;
+                if(auto st = cast(DStruct)ret_t)
+                    ret_t = DType.Void;
+                else if(auto f = cast(DFunction)ret_t)
+                    ret_t = f.returnType;
+                auto func_t = FunctionType.Get(llvm(ret_t), param_types);
+                auto llfunc = m.addFunction(func_t, fd.identifier.getMangled);
+
+                foreach (i, p; fd.funcArgs)
+                {
+                    if(i == 0 && fd.sret)
+                        llfunc.addParamAttr(0, ParamAttr.StructRet);
+
+                    DType t = p.env.find(p.identifier).type;
+                    if(auto st = t.asStruct)
+                    {
+                        if(i == 0 && fd.sret)
+                            continue;
+                        llfunc.addParamAttr(i,ParamAttr.ByVal);
+                    }
+                    else if(auto ar = t.asArray)
+                    {
+                        llfunc.addParamAttr(i,ParamAttr.ByVal);
+                    }
+                }
+            };
+        auto visitor = new VisitFuncDecls(registerFunc);
+        visitor.visit([mod]);
+        // Before beginning we move all top level var-decls to the start
+        // and then we generate the var-decls first
+        // partition is NOT required to be stable, but that should not create
+        // any problems.
+        partition(mod.decls, (Decl d) { return d.declType == DeclType.VarDecl; });
+
+        foreach (decl; mod.decls)
+            genRootDecl(decl);
+
+        table.leaveScope;
+
+//        debug m.verify();
+
+        if(optimize)
+            m.optimize(inline);
+
+        m.writeBitcodeToFileHandle(handle);
+    }
+
+    void genRootDecl(Decl decl)
+    {
+        switch(decl.declType)
+        {
+            case DeclType.FuncDecl:
+                FuncDecl funcDecl = cast(FuncDecl)decl;
+
+                // Empty function - declare;
+                if(funcDecl.emptyFunction)
+                    return;
+
+                llvm(funcDecl.type);
+                auto llfunc = m.getNamedFunction(funcDecl.identifier.getMangled);
+                auto func_tp = cast(PointerType)llfunc.type;
+                auto func_t = cast(FunctionType)func_tp.elementType();
+                auto ret_t = func_t.returnType();
+
+
+                auto bb = llfunc.appendBasicBlock("entry");
+                b.positionAtEnd(bb);
+
+                table.enterScope;
+                foreach (i, v; funcDecl.funcArgs)
+                {
+                    llfunc.getParam(i).name = v.identifier.get;
+                    auto name = v.identifier.get;
+                    if(!cast(PointerType)llfunc.getParam(i).type)
+                    {
+                        auto AI = b.buildAlloca(llfunc.getParam(i).type, name);
+ //                       Value va = b.buildLoad(val, name);
+                        b.buildStore(llfunc.getParam(i), AI);
+                        table[name] = AI;
+                    }
+                    else
+                        table[name] = llfunc.getParam(i);
+                }
+
+                foreach (stmt; funcDecl.statements)
+                    genStmt(stmt);
+
+                // if the function didn't end with a return, we automatically
+                // add one (return 0 as default)
+                if (b.getInsertBlock().terminated() is false)
+                    if (ret_t is Type.Void)
+                        b.buildRetVoid();
+                    else
+                        b.buildRet(ConstantInt.GetS(ret_t, 0));
+
+                table.leaveScope;
+                break;
+
+            case DeclType.VarDecl:
+                auto varDecl = cast(VarDecl)decl;
+                auto id = varDecl.env.find(varDecl.identifier);
+                Type t = llvm(id.type);
+                GlobalVariable g = m.addGlobal(t, id.get);
+                g.initializer = ConstantInt.GetS(t, 0);
+                table[varDecl.identifier.get] = g;
+                break;
+        
+            case DeclType.StructDecl:
+                auto structDecl = cast(StructDecl)decl;
+                llvm(structDecl.type);
+                //m.addTypeName(structDecl.identifier.get, llvm(structDecl.type));
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    void genDecl(Decl decl)
+    {
+        switch(decl.declType)
+        {
+            case DeclType.VarDecl:
+                auto varDecl = cast(VarDecl)decl;
+                auto name = varDecl.identifier.get;
+                auto sym = varDecl.env.find(varDecl.identifier);
+                auto AI = b.buildAlloca(llvm(sym.type), name);
+                table[name] = AI;
+                if (varDecl.init)
+                    buildAssign(varDecl.identifier, varDecl.init);
+                break;
+        
+            default:
+        }
+    }
+
+    struct PE
+    {
+        static char[] NoImplicitConversion =
+            "Can't find an implicit conversion between %0 and %1";
+        static char[] VoidRetInNonVoidFunc =
+            "Only void functions can return without an expression";
+    }
+
+    void sextSmallerToLarger(ref Value left, ref Value right)
+    {
+        if (left.type != right.type)
+        {
+            // try to find a convertion - only works for iX
+            IntegerType l = cast(IntegerType) left.type;
+            IntegerType r = cast(IntegerType) right.type;
+            if (l is null || r is null)
+                throw error(__LINE__, PE.NoImplicitConversion)
+                    .arg(left.type.toString)
+                    .arg(right.type.toString);
+
+            if (l.numBits() < r.numBits())
+                left = b.buildSExt(left, r, ".cast");
+            else
+                right = b.buildSExt(right, l, ".cast");
+        }
+    }
+
+    Value genExpression(Exp exp)
+    {
+        switch(exp.expType)
+        {
+            case ExpType.Binary:
+                auto binaryExp = cast(BinaryExp)exp;
+
+                auto left = genExpression(binaryExp.left);
+                auto right = genExpression(binaryExp.right);
+
+//                sextSmallerToLarger(left, right);
+
+                OpBuilder op = opToLLVM[binaryExp.op];
+
+                return op(left, right, ".");
+
+            case ExpType.IntegerLit:
+                auto integetLit = cast(IntegerLit)exp;
+                auto val = integetLit.get;
+                return ConstantInt.GetS(Type.Int32, Integer.parse(val));
+            case ExpType.Negate:
+                auto negateExp = cast(NegateExp)exp;
+                auto target = genExpression(negateExp.exp);
+                return b.buildNeg(target, "neg");
+            case ExpType.Deref:
+                auto derefExp = cast(DerefExp)exp;
+                auto target = genExpression(derefExp.exp);
+                return b.buildLoad(target, "deref");
+            case ExpType.AssignExp:
+                auto assignExp = cast(AssignExp)exp;
+                return buildAssign(assignExp.identifier, assignExp.exp);
+            case ExpType.Index:
+                auto indexExp = cast(IndexExp)exp;
+                return b.buildLoad(getPointer(exp), ".");
+            case ExpType.CallExp:
+                auto callExp = cast(CallExp)exp;
+                auto id = exp.env.find(cast(Identifier)callExp.exp);
+                Value[] args;
+                foreach (arg; callExp.args)
+                {
+                    Value v = genExpression(arg);
+                    args ~= v;
+
+                }
+                llvm(id.type);
+                // BUG: doesn't do implicit type-conversion
+                if(callExp.sret)
+                    return b.buildCall(m.getNamedFunction(id.getMangled), args, "");
+                return b.buildCall(m.getNamedFunction(id.getMangled), args, ".call");
+            case ExpType.CastExp:
+                auto castExp = cast(CastExp)exp;
+                auto value = genExpression(castExp.exp);
+
+                if(!castExp.type.hasImplicitConversionTo(castExp.type))
+                    assert(0, "Invalid cast");
+
+                Value v;
+                if(castExp.exp.type.byteSize <= castExp.type.byteSize)
+                    v = b.buildZExt(value, llvm(castExp.type), "cast");
+                else
+                    v = b.buildTrunc(value, llvm(castExp.type), "cast");
+
+                return v;
+
+            case ExpType.Identifier:
+                auto identifier = cast(Identifier)exp;
+                auto id = exp.env.find(identifier);
+                if(id.type.isStruct || id.type.isArray)
+                    return table.find(id.get);
+                else
+                    return b.buildLoad(table.find(id.get), id.get);
+            case ExpType.MemberReference:
+                auto v = getPointer(exp);
+//                return v;
+                return b.buildLoad(v, v.name);
+        }
+        assert(0, "Reached end of switch in genExpression");
+        return null;
+    }
+
+    void genStmt(Stmt stmt)
+    {
+        switch(stmt.stmtType)
+        {
+            case StmtType.Compound:
+                auto stmts = cast(CompoundStatement)stmt;
+                foreach (s; stmts.statements)
+                    genStmt(s);
+                break;
+            case StmtType.Return:
+                auto ret = cast(ReturnStmt)stmt;
+                DFunction type = stmt.env.parentFunction().type();
+                Type t = llvm(type.returnType);
+                if (ret.exp is null)
+                    if (t is Type.Void)
+                    {
+                        b.buildRetVoid();
+                        return;
+                    }
+                    else
+                        throw error(__LINE__, PE.VoidRetInNonVoidFunc);
+
+                Value v = genExpression(ret.exp);
+/*                if (v.type != t)
+                {
+                    IntegerType v_t = cast(IntegerType) v.type;
+                    IntegerType i_t = cast(IntegerType) t;
+                    if (v_t is null || i_t is null)
+                        throw error(__LINE__, PE.NoImplicitConversion)
+                            .arg(v.type.toString)
+                            .arg(t.toString);
+
+                    if (v_t.numBits() < i_t.numBits())
+                        v = b.buildSExt(v, t, ".cast");
+                    else
+                        v = b.buildTrunc(v, t, ".cast");
+                }*/
+                b.buildRet(v);
+                break;
+            case StmtType.Decl:
+                auto declStmt = cast(DeclStmt)stmt;
+                genDecl(declStmt.decl);
+                break;
+            case StmtType.Exp:
+                auto expStmt = cast(ExpStmt)stmt;
+                genExpression(expStmt.exp);
+                break;
+            case StmtType.If:
+                auto ifStmt = cast(IfStmt)stmt;
+                Value cond = genExpression(ifStmt.cond);
+                if (cond.type !is Type.Int1)
+                {
+                    Value False = ConstantInt.GetS(cond.type, 0);
+                    cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
+                }
+                auto func_name = stmt.env.parentFunction().identifier.getMangled;
+                Function func = m.getNamedFunction(func_name);
+                bool has_else = (ifStmt.else_body !is null);
+
+                auto thenBB = func.appendBasicBlock("then");
+                auto elseBB = has_else? func.appendBasicBlock("else") : null;
+                auto mergeBB = func.appendBasicBlock("merge");
+
+                b.buildCondBr(cond, thenBB, has_else? elseBB : mergeBB);
+                b.positionAtEnd(thenBB);
+                genStmt(ifStmt.then_body);
+                thenBB = b.getInsertBlock();
+                if (b.getInsertBlock().terminated() is false)
+                    b.buildBr(mergeBB);
+
+                if (has_else)
+                {
+                    b.positionAtEnd(elseBB);
+                    genStmt(ifStmt.else_body);
+                    elseBB = b.getInsertBlock();
+                    if (elseBB.terminated() is false)
+                        b.buildBr(mergeBB);
+                }
+
+                b.positionAtEnd(mergeBB);
+                break;
+            case StmtType.While:
+                auto wStmt = cast(WhileStmt)stmt;
+                auto func_name = stmt.env.parentFunction().identifier.get;
+                Function func = m.getNamedFunction(func_name);
+
+                auto condBB = func.appendBasicBlock("cond");
+                auto bodyBB = func.appendBasicBlock("body");
+                auto doneBB = func.appendBasicBlock("done");
+
+                b.buildBr(condBB);
+                b.positionAtEnd(condBB);
+                Value cond = genExpression(wStmt.cond);
+                if (cond.type !is Type.Int1)
+                {
+                    Value False = ConstantInt.GetS(cond.type, 0);
+                    cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
+                }
+                b.buildCondBr(cond, bodyBB, doneBB);
+
+                b.positionAtEnd(bodyBB);
+                genStmt(wStmt.whileBody);
+                if (b.getInsertBlock().terminated() is false)
+                    b.buildBr(condBB);
+
+                b.positionAtEnd(doneBB);
+                break;
+            case StmtType.Switch:
+                auto sw = cast(SwitchStmt)stmt;
+                Value cond = genExpression(sw.cond);
+
+                auto func_name = stmt.env.parentFunction().identifier.get;
+                Function func = m.getNamedFunction(func_name);
+
+                BasicBlock oldBB = b.getInsertBlock();
+                BasicBlock defBB;
+                BasicBlock endBB = func.appendBasicBlock("sw.end");
+                if (sw.defaultBlock)
+                {
+                    defBB = Function.InsertBasicBlock(endBB, "sw.def");
+                    b.positionAtEnd(defBB);
+                    foreach (case_statement; sw.defaultBlock)
+                        genStmt(case_statement);
+                    if (!defBB.terminated())
+                        b.buildBr(endBB);
+                    b.positionAtEnd(oldBB);
+                }
+                else
+                    defBB = endBB;
+                auto SI = b.buildSwitch(cond, defBB, sw.cases.length);
+                foreach (c; sw.cases)
+                {
+                    BasicBlock prevBB;
+                    foreach (i, val; c.values)
+                    {
+                        auto BB = Function.InsertBasicBlock(defBB, "sw.bb");
+                        SI.addCase(ConstantInt.GetS(cond.type, c.values_converted[i]), BB);
+
+                        if (i + 1 == c.values.length)
+                        {
+                            b.positionAtEnd(BB);
+                            foreach (case_statement; c.stmts)
+                                genStmt(case_statement);
+                            if (!BB.terminated())
+                                b.buildBr(c.followedByDefault? defBB : endBB);
+                        }
+
+                        if (prevBB !is null && !prevBB.terminated())
+                        {
+                            b.positionAtEnd(prevBB);
+                            b.buildBr(BB);
+                        }
+                        prevBB = BB;
+                    }
+                }
+                b.positionAtEnd(endBB);
+                break;
+        }
+    }
+
+    Value getPointer(Exp exp)
+    {
+        switch(exp.expType)
+        {
+            case ExpType.Identifier:
+                auto identifier = cast(Identifier)exp;
+                auto id = exp.env.find(identifier);
+                return table.find(id.get);
+            case ExpType.Deref:
+                auto derefExp = cast(DerefExp)exp;
+                auto target = getPointer(derefExp.exp);
+                return b.buildLoad(target, "deref");
+            case ExpType.Index:
+                auto indexExp = cast(IndexExp)exp;
+                auto type = indexExp.target.type;
+                auto index = genExpression(indexExp.index);
+                Value[2] gep_indices;
+                gep_indices[0] = ConstantInt.Get(IntegerType.Int32, 0, false);
+                gep_indices[1] = index;
+                if (type.isArray())
+                {
+                    auto array = getPointer(indexExp.target);
+                    return b.buildGEP(array, gep_indices[0 .. 2], "index");
+                }
+                else if (type.isPointer())
+                {
+                    auto array = genExpression(indexExp.target);
+                    return b.buildGEP(array, gep_indices[1 .. 2], "index");
+                }
+                else assert(0, "Can only index pointers and arrays");
+            case ExpType.MemberReference:
+                auto mem = cast(MemberReference)exp;
+                switch(mem.target.expType)
+                {
+                    case ExpType.Identifier:
+                        auto identifier = cast(Identifier)mem.target;
+                        auto child = mem.child;
+                        auto id = exp.env.find(identifier);
+                        Value v = table.find(id.get);
+                        DType t = id.type;
+                        auto st = t.asStruct;
+
+                        int i = st.indexOf(child.get);
+
+                        Value[] vals;   
+                        vals ~= ConstantInt.Get(IntegerType.Int32, 0, false);
+                        vals ~= ConstantInt.Get(IntegerType.Int32, i, false);
+
+                        Value val = b.buildGEP(v, vals, id.get~"."~child.get);
+                        return val;
+
+                    case ExpType.MemberReference:
+                        auto v = getPointer(mem.target);
+                        auto child = mem.child;
+                        auto symChild = child.env.find(child);
+                        DType t = mem.target.type;
+                        auto st = t.asStruct;
+
+                        int i = st.indexOf(child.get);
+
+                        Value[] vals;   
+                        vals ~= ConstantInt.Get(IntegerType.Int32, 0, false);
+                        vals ~= ConstantInt.Get(IntegerType.Int32, i, false);
+
+                        Value val = b.buildGEP(v, vals, "."~child.get);
+                        return val;
+
+                    default:
+                        Value val = genExpression(exp);
+                        auto AI = b.buildAlloca(val.type, ".s");
+                        return b.buildStore(val, AI);
+                }
+            default:
+                Value val = genExpression(exp);
+                auto AI = b.buildAlloca(val.type, ".s");
+                return b.buildStore(val, AI);
+        }
+        assert(0, "Reached end of switch in getPointer");
+        return null;
+    }
+
+    private Value buildAssign(Exp target, Exp exp)
+    {
+        Value t = getPointer(target);
+        Value v = genExpression(exp);
+
+        auto a = cast(PointerType)t.type;
+
+        assert(a, "Assing to type have to be of type PointerType");
+
+        Type value_type = v.type;
+        if (auto value_ptr = cast(PointerType)v.type)
+        {
+            value_type = value_ptr.elementType;
+
+            if (a.elementType is value_type && cast(StructType)value_type)
+            {
+                // bitcast "from" to i8*
+                Value from = b.buildBitCast(v, BytePtr, ".copy_from");
+                // bitcast "to" to i8*
+                Value to = b.buildBitCast(t, BytePtr, ".copy_to");
+                // call llvm.memcpy.i32( "to", "from", type_size, alignment (32 in clang) );
+                b.buildCall(llvm_memcpy, [to, from, ConstantInt.GetS(Type.Int32, 4), ConstantInt.GetS(Type.Int32, 32)], null);
+                // return "to"
+                return t;
+            }
+        }
+
+        if (value_type != a.elementType)
+        {
+            IntegerType v_t = cast(IntegerType) value_type;
+            IntegerType i_t = cast(IntegerType) a.elementType;
+            if (v_t is null || i_t is null)
+                throw error(__LINE__, PE.NoImplicitConversion)
+                    .arg(a.elementType.toString)
+                    .arg(v.type.toString);
+
+            if (v_t.numBits() < i_t.numBits())
+                v = b.buildSExt(v, a.elementType, ".cast");
+            else
+                v = b.buildTrunc(v, a.elementType, ".cast");
+        }
+        return b.buildStore(v, t);
+    }
+
+    Error error(uint line, char[] msg)
+    {
+        return new Error(msg);
+    }
+
+    /**
+      Get the LLVM Type corresponding to a DType.
+
+      Currently using the built-in associative array - not sure if it works
+      well when the hashes are so uniform.
+
+      Other possibilities would be to find a hash-function that works on
+      something as small as 4 bytes or to create a sparse array perhaps.
+     */
+    Type llvm(DType t)
+    {
+        if (auto llvm_t = t in type_map)
+            return *llvm_t;
+        return llvmCreateNew(t);
+    }
+
+    // Create an LLVM type and insert it into the type map, and return the
+    // result
+    Type llvmCreateNew(DType t)
+    {
+        if (auto i = cast(DInteger)t)
+        {
+            Type res = IntegerType.Get(i.byteSize() * 8);
+            type_map[t] = res;
+            return res;
+        }
+        else if (auto s = t.asStruct)
+        {
+            SmallArray!(Type, 8) members;
+            DType[] array;
+            array.length = s.members.length;
+
+            foreach(m; s.members)
+                array[m.index] = m.type;
+
+            foreach(m; array)
+                members ~= llvm(m);
+
+            Type res = StructType.Get(members.unsafe());
+            type_map[t] = res;
+            m.addTypeName(s.name, res);
+            return res;
+        }
+        else if (auto f = t.asFunction)
+        {
+            // We should never have a function returning structs, because of
+            // the simplify step
+            assert(f.returnType.isStruct() == false, "Can't return structs");
+            Type ret_t = llvm(f.returnType);
+
+            SmallArray!(Type, 8) params;
+            foreach(param; f.params)
+                if (param.isStruct)
+                    params ~= PointerType.Get(llvm(param));
+                else if (param.isArray)
+                    params ~= PointerType.Get(llvm(param));
+                else
+                    params ~= llvm(param);
+
+            Type res = FunctionType.Get(ret_t, params.unsafe());
+            type_map[t] = res;
+            auto id = new Identifier(f.name);
+            id.setType(f);
+
+            auto f_t = m.getNamedFunction(id.getMangled);
+            if(f_t is null)
+            {
+                auto llfunc = m.addFunction(res, id.getMangled);
+
+                foreach (i, param; f.params)
+                    if (param.isStruct)
+                        llfunc.addParamAttr(i, ParamAttr.ByVal);
+
+                if (f.firstParamIsReturnValue)
+                {
+                    llfunc.removeParamAttr(0, ParamAttr.ByVal);
+                    llfunc.addParamAttr(0, ParamAttr.StructRet);
+                }
+            }
+            return res;
+        }
+        else if (auto f = t.asPointer)
+        {
+            Type res = PointerType.Get(llvm(f.pointerOf));
+            type_map[t] = res;
+            return res;
+        }
+        else if (auto f = t.asArray)
+        {
+            Type res = ArrayType.Get(llvm(f.arrayOf), f.size);
+            type_map[t] = res;
+            return res;
+        }
+        assert(0, "Only integers, structs and functions are supported");
+    }
+
+    // Might as well insert all the basic types from the start
+    void createBasicTypes()
+    {
+        type_map[DType.Void] = Type.Void;
+
+        type_map[DType.Bool]   = Type.Int1;
+        type_map[DType.Byte]   = Type.Int8;
+        type_map[DType.UByte]  = Type.Int8;
+        type_map[DType.Short]  = Type.Int16;
+        type_map[DType.UShort] = Type.Int16;
+        type_map[DType.Int]    = Type.Int32;
+        type_map[DType.UInt]   = Type.Int32;
+        type_map[DType.Long]   = Type.Int64;
+        type_map[DType.ULong]  = Type.Int64;
+    }
+
+private:
+
+    // llvm stuff
+    Module mod;
+    LLVM.Module m;
+    LLVM.Builder b;
+    Function llvm_memcpy;
+    Type BytePtr;
+    Type[DType] type_map;
+
+    FuncDecl[char[]] functions;
+
+    SimpleSymbolTable table;
+    alias Value delegate(Value, Value, char[]) OpBuilder;
+    static OpBuilder[BinaryExp.Operator] opToLLVM;
+}
+
+private class VisitFuncDecls : Visitor!(void)
+{
+    void delegate(FuncDecl) dg;
+    this(void delegate(FuncDecl funcDecl) dg)
+    {
+        this.dg = dg;
+    }
+
+    override void visitModule(Module m)
+    {
+        foreach (decl; m.decls)
+            if (auto f = cast(FuncDecl)decl)
+                dg(f);
+    }
+}
+
+private class SimpleSymbolTable
+{
+    Value[char[]][] namedValues;
+
+    void enterScope()
+    {
+        namedValues ~= cast(Value[char[]])["__dollar":null];
+    }
+
+    void leaveScope()
+    {
+        namedValues.length = namedValues.length - 1;
+    }
+
+    Value put(Value val, char[] key)
+    {
+        namedValues[$ - 1][key] = val;
+        return val;
+    }
+
+    Value find(char[] key)
+    {
+        foreach_reverse (map; namedValues)
+            if(auto val_ptr = key in map)
+                return *val_ptr;
+        return null;
+    }
+
+    alias find opIndex;
+    alias put opIndexAssign;
+}
+

--- a/gen/LLVMGen.d	Fri Apr 18 23:45:45 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,575 +0,0 @@
-module gen.LLVMGen;
-
-import tango.io.Stdout,
-       Int = tango.text.convert.Integer;
-import tango.core.Array : find;
-
-import ast.Decl,
-       ast.Stmt,
-       ast.Exp;
-
-import lexer.Token;
-
-import sema.SymbolTableBuilder;
-
-class LLVMGen
-{
-public:
-    this()
-    {
-        typeToLLVM =
-        [
-            "int"[]  : "i32"[],
-            "byte"   : "i8",
-            "short"  : "i16",
-            "long"   : "i64",
-            "bool"   : "i1",
-            "float"  : "float",
-            "double" : "double",
-            "void"   : "void"
-        ];
-        alias BinaryExp.Operator op;
-        opToLLVM = [
-            op.Add      : "add"[],
-            op.Sub      : "sub",
-            op.Mul      : "mul",
-            op.Div      : "div",
-            op.Eq       : "icmp eq",
-            op.Ne       : "icmp ne",
-            op.Lt       : "icmp slt",
-            op.Le       : "icmp sle",
-            op.Gt       : "icmp sgt",
-            op.Ge       : "icmp sge"
-        ];
-        table = new SimpleSymbolTable();
-    }
-
-    void gen(Decl[] decls)
-    {
-        // Fill in scopes
-
-        table.enterScope;
-
-        foreach(decl ; decls)
-                genRootDecl(decl);
-
-        foreach(decl ; nestedFunc)
-                genRootDecl(decl);
-
-        table.leaveScope;
-    }
-
-    void genRootDecl(Decl decl)
-    {
-        switch(decl.declType)
-        {
-            case DeclType.FuncDecl:
-                FuncDecl funcDecl = cast(FuncDecl)decl;
-                auto return_type = typeToLLVM[funcDecl.type.token.get];
-
-                printBeginLine("define ");
-                print(return_type);
-                print(" @");
-                genIdentifier(funcDecl.identifier);
-                print("(");
-
-                table.enterScope;
-                Identifier[] args;
-                foreach(i, funcArg ; funcDecl.funcArgs)
-                {
-                    print(typeToLLVM[funcArg.type.token.get]);
-                    print(" %");
-                    print("."~Integer.toString(i));
-                    args ~= funcArg.identifier;
-                    table.find(funcArg.identifier.get);
-                    if(i+1 < funcDecl.funcArgs.length)
-                        print(", ");
-                }
-                
-                printEndLine(") {");
-                
-                indent;
-
-                foreach(i, arg ; args)
-                {
-                    auto sym = arg.env.find(arg);
-                    auto type = typeToLLVM[sym.type.get];
-                    printBeginLine("%"~arg.get);
-                    printEndLine(" = alloca " ~ type);
-                    printBeginLine("store " ~ type ~ " %.");
-                    print(Integer.toString(i));
-                    print(", " ~ type ~ "* %");
-                    printEndLine(arg.get);
-                }
-
-                printEndLine();
-
-                foreach (stmt; funcDecl.statements)
-                    genStmt(stmt);
-                if (return_type == "void")
-                {
-                    printBeginLine("ret void");
-                    printEndLine();
-                }
-                table.leaveScope;
-                dedent;
-                printBeginLine("}");
-                printEndLine();
-                
-                break;
-
-            case DeclType.VarDecl:
-                auto varDecl = cast(VarDecl)decl;
-                printBeginLine("@");
-                genIdentifier(varDecl.identifier);
-                
-                print(" = ");
-                if(varDecl.init)
-                {
-                    if(cast(IntegerLit)varDecl.init)
-                        printEndLine("global i32 " ~ (cast(IntegerLit)varDecl.init).token.get);
-                    else
-                        assert(0,"Declaring an variable to an expression is not allowed");
-                }
-                else
-                    printEndLine("i32 0");
-
-                printEndLine();
-
-                break;
-
-            case DeclType.StructDecl:
-                auto structDecl = cast(StructDecl)decl;
-                printBeginLine("%struct.");
-                genIdentifier(structDecl.identifier);
-                
-                print(" = type { ");
-                foreach (i, var; structDecl.vars)
-                {
-                    print(typeToLLVM[var.type.get]);
-                    if(i+1 < structDecl.vars.length)
-                        print(", ");
-                }
-
-                printEndLine(" }");
-
-                break;
-        
-            default:
-        }
-    }
-
-    void genDecl(Decl decl)
-    {
-        switch(decl.declType)
-        {
-            case DeclType.VarDecl:
-                auto varDecl = cast(VarDecl)decl;
-                printBeginLine("%");
-                print(table.find(varDecl.identifier.get));
-                print(" = alloca ");
-                if(varDecl.type.get in typeToLLVM)
-                    printEndLine(typeToLLVM[varDecl.type.get]);
-                else
-                    printEndLine("%struct."~varDecl.type.get);
-                if(varDecl.init)
-                {
-                    auto assignExp = new AssignExp(varDecl.identifier, varDecl.init);
-                    assignExp.env = decl.env;
-                    assignExp.identifier.env = decl.env;
-                    genExpression(assignExp);
-                }
-                break;
-
-            case DeclType.FuncDecl:
-                auto func = cast(FuncDecl)decl;
-                nestedFunc[func.identifier.get] = func;
-                break;
-        
-            default:
-        }
-    }
-
-    void unify(Ref* a, Ref* b)
-    {
-        if (a.type != b.type)
-        {
-            auto a_val = intTypes.find(a.type);
-            auto b_val = intTypes.find(b.type);
-            // swap types so a is always the "largest" type 
-            if (a_val < b_val)
-            {
-                Ref* tmp = b;
-                b = a;
-                a = tmp;
-            }
-
-            auto res = table.find("%.cast");
-            printBeginLine(res);
-            printCastFromTo(b, a);
-            print(*b);
-            print(" to ");
-            printEndLine(a.type);
-
-            b.type = a.type;
-            b.name = res;
-        }
-    }
-
-    Ref genExpression(Exp exp)
-    {
-        switch(exp.expType)
-        {
-            case ExpType.Binary:
-                auto binaryExp = cast(BinaryExp)exp;
-
-                auto left = genExpression(binaryExp.left);
-                auto right = genExpression(binaryExp.right);
-
-                unify(&left, &right);
-
-                auto res = Ref(left.type, table.find);
-                printBeginLine(res.name);
-                print(" = "~opToLLVM[binaryExp.op]~" ");
-                print(left);
-                print(", ");
-                printEndLine(right.name);
-
-                // exp always returns known type (== returns bool no matter
-                // what the params are)
-                if (binaryExp.resultType)
-                    res.type = typeToLLVM[binaryExp.resultType];
-
-                return res;
-            case ExpType.IntegerLit:
-                auto integetLit = cast(IntegerLit)exp;
-                auto t = integetLit.token;
-                return Ref("int", t.get, true);
-            case ExpType.Negate:
-                auto negateExp = cast(NegateExp)exp;
-                auto target = genExpression(negateExp.exp);
-                auto res = table.find;
-                printBeginLine(res);
-                print(" = sub "~target.type~" 0, ");
-                printEndLine(target.name);
-                return Ref(target.type, res);
-            case ExpType.AssignExp:
-                auto assignExp = cast(AssignExp)exp;
-                auto sym = exp.env.find(assignExp.identifier);
-
-                Ref val = genExpression(assignExp.exp);
-                Ref r = Ref(typeToLLVM[sym.type.get], val.name);
-
-                if (val.type != r.type)
-                {
-                    auto res = table.find("%.cast");
-                    printBeginLine(res);
-                    printCastFromTo(val.type, r.type);
-                    print(val);
-                    print(" to ");
-                    printEndLine(r.type);
-                    r.name = res;
-                }
-
-                printBeginLine("store ");
-                print(r);
-                print(", ");
-                print(r.type ~ "* %");
-                printEndLine(assignExp.identifier.get);
-                break;
-            case ExpType.CallExp:
-                auto callExp = cast(CallExp)exp;
-                auto func_sym = exp.env.find(cast(Identifier)callExp.exp);
-                auto func_type = typeToLLVM[func_sym.type.get];
-                Ref[] args;
-                foreach(i, arg ; callExp.args)
-                    args ~= genExpression(arg);
-
-                char[] res = "";
-                if (func_type != "void")
-                {
-                    res = table.find;
-                    printBeginLine(res);
-                    print(" = call ");
-                }
-                else
-                    printBeginLine("call ");
-
-                print(func_type);
-                print(" @");
-                
-                print(func_sym.id.get);
-
-                print("(");
-                foreach(i, arg ; args)
-                {
-                    print(arg);
-                    if(i+1 < args.length)
-                        print(", ");
-                }
-                printEndLine(")");
-                return Ref(func_sym.type.get, res);
-            case ExpType.Identifier:
-                auto identifier = cast(Identifier)exp;
-                auto sym = exp.env.find(identifier);
-                char[] res = table.find;
-                printBeginLine(res);
-                print(" = load ");
-                print(typeToLLVM[sym.type.get]);
-                print("* %");
-                printEndLine(sym.id.name);
-                return Ref(sym.type.get, res);
-        }
-        return Ref();
-    }
-
-    void genStmt(Stmt stmt)
-    {
-        switch(stmt.stmtType)
-        {
-            case StmtType.Return:
-                auto ret = cast(ReturnStmt)stmt;
-                auto sym = stmt.env.parentFunction();
-                auto type = typeToLLVM[sym.type.get];
-
-                Ref res = genExpression(ret.exp);
-
-                if (type != res.type)
-                {
-                    auto cast_res = table.find("%.cast");
-                    printBeginLine(cast_res);
-                    printCastFromTo(res.type, type);
-                    print(res);
-                    print(" to ");
-                    printEndLine(type);
-                    res.name = cast_res;
-                    res.type = type;
-                }
-                printBeginLine("ret ");
-                printEndLine(res);
-                break;
-            case StmtType.Decl:
-                auto declStmt = cast(DeclStmt)stmt;
-                genDecl(declStmt.decl);
-                break;
-            case StmtType.Exp:
-                auto expStmt = cast(ExpStmt)stmt;
-                genExpression(expStmt.exp);
-                break;
-            case StmtType.If:
-                auto ifStmt = cast(IfStmt)stmt;
-                Ref val = genExpression(ifStmt.cond);
-                auto cond = table.find("%.cond");
-                printBeginLine(cond);
-                print(" = icmp ne ");
-                print(val);
-                printEndLine(", 0");
-
-                auto then_branch = table.find("then");
-                auto else_branch = table.find("else");
-                auto done_label  = table.find("done");
-                printBeginLine("br i1 ");
-                print(cond);
-                print(", label %");
-                print(then_branch);
-                print(", label %");
-                printEndLine(ifStmt.else_body? else_branch : done_label);
-
-                printBeginLine(then_branch);
-                printEndLine(":");
-
-                indent();
-                foreach (s; ifStmt.then_body)
-                    genStmt(s);
-                printBeginLine("br label %");
-                printEndLine(done_label);
-                dedent();
-
-                if (ifStmt.else_body)
-                {
-                    printBeginLine(else_branch);
-                    printEndLine(":");
-
-                    indent();
-                    foreach (s; ifStmt.else_body)
-                        genStmt(s);
-                    printBeginLine("br label %");
-                    printEndLine(done_label);
-                    dedent();
-                }
-
-                printBeginLine(done_label);
-                printEndLine(":");
-
-                break;
-            case StmtType.While:
-                auto wStmt = cast(WhileStmt)stmt;
-
-                auto body_label = table.find("while_body");
-                auto cond_label = table.find("while_cond");
-                auto done_label  = table.find("while_done");
-
-                printBeginLine("br label %");
-                printEndLine(cond_label);
-
-                printBeginLine(cond_label);
-                printEndLine(":");
-
-                indent();
-
-                Ref val = genExpression(wStmt.cond);
-                auto cond = table.find("%.cond");
-
-                printBeginLine(cond);
-                print(" = icmp ne ");
-                print(val);
-                printEndLine(", 0");
-
-                printBeginLine("br i1 ");
-                print(cond);
-                print(", label %");
-                print(body_label);
-                print(", label %");
-                printEndLine(done_label);
-
-                dedent();
-
-                printBeginLine(body_label);
-                printEndLine(":");
-
-                indent();
-                foreach (s; wStmt.stmts)
-                    genStmt(s);
-                printBeginLine("br label %");
-                printEndLine(cond_label);
-                dedent();
-
-                printBeginLine(done_label);
-                printEndLine(":");
-
-                break;
-        }
-    }
-
-    void genIdentifier(Identifier identifier)
-    {
-        print(identifier.get);
-    }
-
-    void indent()
-    {
-        tabIndex ~= tabType;
-    }
-
-    void dedent()
-    {
-        tabIndex = tabIndex[0 .. $-tabType.length];
-    }
-
-    void printBeginLine(char[] line = "")
-    {
-        Stdout(tabIndex~line);
-    }
-    void printBeginLine(Ref r)
-    {
-        Stdout(tabIndex~r.type~" "~r.name);
-    }
-
-    void printEndLine(char[] line = "")
-    {
-        Stdout(line).newline;
-    }
-
-    void printEndLine(Ref r)
-    {
-        Stdout(r.type~" "~r.name).newline;
-    }
-
-    void print(char[] line)
-    {
-        Stdout(line);
-    }
-
-    void print(Ref r)
-    {
-        Stdout(r.type~" "~r.name);
-    }
-
-    void printCastFromTo(size_t t1, size_t t2)
-    {
-        if (t1 < t2)
-            print(" = zext ");
-        else
-            print(" = trunc ");
-    }
-
-    void printCastFromTo(char[] t1, char[] t2)
-    {
-        printCastFromTo(intTypes.find(t1), intTypes.find(t2));
-    }
-
-    void printCastFromTo(Ref* t1, Ref* t2)
-    {
-        printCastFromTo(intTypes.find(t1.type), intTypes.find(t2.type));
-    }
-
-private:
-
-    char[] tabIndex;
-    const char[] tabType = "    "; // 4 spaces
-    FuncDecl[char[]] functions;
-
-    SimpleSymbolTable table;
-    SymbolTable symbolTable;
-    static char[][char[]] typeToLLVM;
-    static char[][BinaryExp.Operator] opToLLVM;
-
-    static char[][] intTypes = [ "i1", "i8", "i16", "i32", "i64" ];
-
-    FuncDecl[char[]] nestedFunc;
-}
-
-struct Ref
-{
-    char[] type;
-    char[] name;
-    bool atomic = false;
-    static Ref opCall(char[] type = "void", char[] name = "", bool atomic = false)
-    {
-        Ref r;
-        if(auto llvm_t = type in LLVMGen.typeToLLVM)
-            r.type = *llvm_t;
-        else
-            r.type = type;
-        r.name = name;
-        r.atomic = atomic;
-        return r;
-    }
-}
-
-class SimpleSymbolTable
-{
-    int[char[]][] variables;
-
-    void enterScope()
-    {
-        variables ~= cast(int[char[]])["__dollar":-1];
-    }
-
-    void leaveScope()
-    {
-        variables.length = variables.length - 1;
-    }
-
-    char[] find(char[] v = "%.tmp")
-    {
-        foreach_reverse(map ; variables)
-        {
-            if(v in map)
-                return v~"."~Integer.toString(++map[v]);
-        }
-        variables[$-1][v] = 0;
-        return v;
-    }
-}
-

--- a/gen/LuaGen.d	Fri Apr 18 23:45:45 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,180 +0,0 @@
-module gen.LuaGen;
-
-import tango.io.Stdout,
-       Int = tango.text.convert.Integer;
-
-import ast.Decl,
-       ast.Stmt,
-       ast.Exp;
-
-import lexer.Token;
-
-class LuaGen
-{
-public:
-    this()
-    {
-    }
-    
-    void gen(Decl[] decls)
-    {
-
-        foreach(decl ; decls)
-                genDecl(decl);
-        printBeginLine("main()");
-        printEndLine;
-    }
-
-    void genDecl(Decl decl)
-    {
-        switch(decl.declType)
-        {
-            case DeclType.FuncDecl:
-                FuncDecl funcDecl = cast(FuncDecl)decl;
-
-                printBeginLine("function ");
-                genIdentifier(funcDecl.identifier);
-                print("(");
-                foreach(i, funcArg ; funcDecl.funcArgs)
-                {
-                    genIdentifier(funcArg.identifier);
-                    if(i+1 < funcDecl.funcArgs.length)
-                        print(", ");
-                }
-                printEndLine(")");
-                indent;
-                foreach(stmt ; funcDecl.statements)
-                {
-                    genStmt(stmt);
-                }
-                dedent;
-                printBeginLine("end");
-                printEndLine();
-                break;
-
-            case DeclType.VarDecl:
-                genVarDecl(cast(VarDecl)decl);
-
-            default:
-        }
-    }
-
-    void genStmt(Stmt stmt)
-    {
-        switch(stmt.stmtType)
-        {
-            case StmtType.Return:
-                auto ret = cast(ReturnStmt)stmt;
-                printBeginLine("return ");
-                genExpression(ret.exp);
-                printEndLine();
-                break;
-            case StmtType.Decl:
-                auto declStmt = cast(DeclStmt)stmt;
-                genDecl(declStmt.decl);
-                break;
-            case StmtType.Exp:
-                auto expStmt = cast(ExpStmt)stmt;
-                printBeginLine();
-                genExpression(expStmt.exp);
-                printEndLine();
-                break;
-
-        }
-    }
-
-    void genVarDecl(VarDecl decl)
-    {
-        printBeginLine("local ");
-        genIdentifier(decl.identifier);
-        if(decl.init)
-        {
-            print(" = ");
-            genExpression(decl.init);
-        }
-        printEndLine();
-
-    }
-
-    void genExpression(Exp exp)
-    {
-        switch(exp.expType)
-        {
-            case ExpType.Binary:
-                auto binaryExp = cast(BinaryExp)exp;
-                genExpression(binaryExp.left);
-                print(" " ~ [binaryExp.op] ~ " ");
-                genExpression(binaryExp.right);
-                break;
-            case ExpType.IntegerLit:
-                auto integetLit = cast(IntegerLit)exp;
-                auto t = integetLit.token;
-                print(t.get);
-                break;
-            case ExpType.Negate:
-                auto negateExp = cast(NegateExp)exp;
-                print("-(");
-                genExpression(negateExp.exp);
-                print(")");
-                break;
-            case ExpType.AssignExp:
-                auto assignExp = cast(AssignExp)exp;
-                genIdentifier(assignExp.identifier);
-                print(" = ");
-                genExpression(assignExp.exp);
-                break;
-            case ExpType.CallExp:
-                auto callExp = cast(CallExp)exp;
-                genExpression(callExp.exp);
-                print("(");
-                foreach(i, arg ; callExp.args)
-                {
-                    genExpression(arg);
-                    if(i+1 < callExp.args.length)
-                        print(", ");
-                }
-                print(")");
-                break;
-            case ExpType.Identifier:
-                auto identifier = cast(Identifier)exp;
-                print(identifier.token.get);
-                break;
-        }
-
-    }
-
-    void genIdentifier(Identifier identifier)
-    {
-        print(identifier.token.get);
-    }
-
-    void indent()
-    {
-        tabIndex ~= tabType;
-    }
-
-    void dedent()
-    {
-        tabIndex = tabIndex[0 .. $-tabType.length];
-    }
-
-    void printBeginLine(char[] line = "")
-    {
-        Stdout(tabIndex~line);
-    }
-
-    void printEndLine(char[] line = "")
-    {
-        Stdout(line).newline;
-    }
-
-    void print(char[] line)
-    {
-        Stdout(line);
-    }
-
-private:
-    char[] tabIndex;
-    const char[] tabType = "    "; // 4 spaces
-}
-