--- a/parser/Parser.d	Mon Jul 21 21:18:18 2008 +0200
+++ b/parser/Parser.d	Mon Jul 21 21:30:44 2008 +0200
@@ -499,617 +499,605 @@
         return a;
     }
 
-enum : uint 
-       { 
-           Single, 
-           Scope, 
-           All 
-       }
-
-       struct Att
-       {
-           Attribute a;
-           uint nested;
-       }
+    enum : uint
+    { 
+        Single, 
+        Scope, 
+        All 
+    }
 
-       /**
-         Parse statements.
-
-         This is the place to attack!
-        */
-       Stmt parseStatement()
-       {
-           Token t = peek;
+    struct Att
+    {
+        Attribute a;
+        uint nested;
+    }
 
-           if (t.isReturn)
-           {
-               Token ret = next();
-               Exp exp;
-               if (peek.type != Tok.Seperator)
-                   exp = parseExpression();
-               require(Tok.Seperator);
-               return action.actOnReturnStmt(ret, exp);
+    /**
+      Parse statements.
+
+      This is the place to attack!
+     */
+    Stmt parseStatement()
+    {
+        Token t = peek;
 
-               /*
-                  if (cond)
-                  single statement | compound statement
-                  [else
-                  single statement | compound statement]
-                */
-           }
-           else if (t.isIf)
-           {
-               Token _if = next();
-
-               require(Tok.OpenParentheses);
-               Exp cond = parseExpression();
-               require(Tok.CloseParentheses);
-
-               Stmt thenB = parseSingleOrCompoundStatement();
+        if (t.isReturn)
+        {
+            Token ret = next();
+            Exp exp;
+            if (peek.type != Tok.Seperator)
+                exp = parseExpression();
+            require(Tok.Seperator);
+            return action.actOnReturnStmt(ret, exp);
+        }
+        /*
+           if (cond)
+           single statement | compound statement
+           [else
+           single statement | compound statement]
+         */
+        else if (t.isIf)
+        {
+            Token _if = next();
 
-               // if there is no else part we use the if as token, to have
-               // something than can be passed along
-               Token _else = _if;
-               Stmt elseB;
-               if (peek.type == Tok.Else)
-               {
-                   _else = next();
-                   elseB = parseSingleOrCompoundStatement();
-               }
+            require(Tok.OpenParentheses);
+            Exp cond = parseExpression();
+            require(Tok.CloseParentheses);
 
-               return action.actOnIfStmt(_if, cond, thenB, _else, elseB);
+            Stmt thenB = parseSingleOrCompoundStatement();
 
-               /*
-                  while (cond)
-                  single statement | compound statement
-                */
-           }
-           else if (t.isWhile)
-           {
-               Token _while = next();
-               require(Tok.OpenParentheses);
-               Exp cond = parseExpression();
-               require(Tok.CloseParentheses);
-               Stmt bodyStmt = parseSingleOrCompoundStatement();
-               return action.actOnWhileStmt(_while, cond, bodyStmt);
+            // if there is no else part we use the if as token, to have
+            // something than can be passed along
+            Token _else = _if;
+            Stmt elseB;
+            if (peek.type == Tok.Else)
+            {
+                _else = next();
+                elseB = parseSingleOrCompoundStatement();
+            }
 
-               /*
-                  One of four things:
-                  A declaration of a function/variable `type id ...`
-                  A direct assignment `id = exp;`
-                  An indirect assignment `id.id = exp`
-                  Some sort of free standing expression
+            return action.actOnIfStmt(_if, cond, thenB, _else, elseB);
 
-                  The assignments should be handled as binary expressions?
-                */
-           }
-           else if (t.isFor)
-           {
-               Token _for = next();
-               require(Tok.OpenParentheses);
-               Stmt init;
-               if ( isa(Tok.Seperator))
-                   require(Tok.Seperator);
-               else
-                   init = parseStatement();
-
-               Exp cond;
-               if ( !isa(Tok.Seperator))
-                   cond = parseExpression();
-               require(Tok.Seperator);
+        }
+        /*
+           while (cond)
+           single statement | compound statement
+         */
+        else if (t.isWhile)
+        {
+            Token _while = next();
+            require(Tok.OpenParentheses);
+            Exp cond = parseExpression();
+            require(Tok.CloseParentheses);
+            Stmt bodyStmt = parseSingleOrCompoundStatement();
+            return action.actOnWhileStmt(_while, cond, bodyStmt);
 
-               Exp incre;
-               if ( !isa(Tok.CloseParentheses))
-                   incre = parseExpression();
-               require(Tok.CloseParentheses);
+        }
+        else if (t.isFor)
+        {
+            Token _for = next();
+            require(Tok.OpenParentheses);
+            Stmt init;
+            if ( isa(Tok.Seperator))
+                require(Tok.Seperator);
+            else
+                init = parseStatement();
 
-               Stmt bodyStmt = parseSingleOrCompoundStatement();
-               return action.actOnForStmt(_for, init, cond, incre, bodyStmt);
-           }
-           else if (t.isBasicType || t.isIdentifier)
-           {
-               Token iden = peek;
-               Token n = peek(1);
-               // Must be an decl, if we start with a basic type, or two
-               // identifiers in a row
-               if ( n.type == Tok.Star || n.type == Tok.OpenBracket)
-               {
-                   int len = peekParseType;
-                   if(peek(len).type == Tok.Identifier && len != 0)
-                       return action.actOnDeclStmt(parseVarDecl());
+            Exp cond;
+            if ( !isa(Tok.Seperator))
+                cond = parseExpression();
+            require(Tok.Seperator);
 
-                   Exp exp = parseExpression();
-                   require(Tok.Seperator);
-                   return action.actOnExprStmt(exp);
-               }
+            Exp incre;
+            if ( !isa(Tok.CloseParentheses))
+                incre = parseExpression();
+            require(Tok.CloseParentheses);
 
-               if (n.isIdentifier())
-                   return action.actOnDeclStmt(parseVarDecl());
+            Stmt bodyStmt = parseSingleOrCompoundStatement();
+            return action.actOnForStmt(_for, init, cond, incre, bodyStmt);
+        }
+        else if (t.isBasicType || t.isIdentifier)
+        {
+            Token iden = peek;
+            Token n = peek(1);
+            // Must be an decl, if we start with a basic type, or two
+            // identifiers in a row
+            if ( n.type == Tok.Star || n.type == Tok.OpenBracket)
+            {
+                int len = peekParseType;
+                if(peek(len).type == Tok.Identifier && len != 0)
+                    return action.actOnDeclStmt(parseVarDecl());
 
-               // Expression: a.b, a = b, a(b) etc.
-               Exp exp = parseExpression();
-               require(Tok.Seperator);
-               return action.actOnExprStmt(exp);
+                Exp exp = parseExpression();
+                require(Tok.Seperator);
+                return action.actOnExprStmt(exp);
             }
-            else if (t.isSwitch)
+
+            if (n.isIdentifier())
+                return action.actOnDeclStmt(parseVarDecl());
+
+            // Expression: a.b, a = b, a(b) etc.
+            Exp exp = parseExpression();
+            require(Tok.Seperator);
+            return action.actOnExprStmt(exp);
+        }
+        else if (t.isSwitch)
+        {
+            next();
+            require(Tok.OpenParentheses);
+            auto target = parseExpression();
+            auto res = action.actOnStartOfSwitchStmt(t, target);
+            require(Tok.CloseParentheses);
+            require(Tok.OpenBrace);
+            while (true)
             {
-                next();
-                require(Tok.OpenParentheses);
-                auto target = parseExpression();
-                auto res = action.actOnStartOfSwitchStmt(t, target);
-                require(Tok.CloseParentheses);
-                require(Tok.OpenBrace);
-                while (true)
+                Stmt[] statements;
+                if (isa(Tok.Default))
                 {
-                    Stmt[] statements;
-                    if (isa(Tok.Default))
-                    {
-                        Token _default = next();
-                        require(Tok.Colon);
-                        statements.length = 0;
-                        while (peek.type != Tok.Case
-                                && peek.type != Tok.Default
-                                && peek.type != Tok.CloseBrace)
-                            statements ~= parseStatement();
-                        action.actOnDefaultStmt(res, _default, statements);
-                        continue;
-                    }
-
-                    Token _case = peek;
-                    if (_case.type != Tok.Case)
-                        break;
-                    next();
-
-                    Exp[] literals;
-                    do
-                    {
-                        Exp e = parseExpression();
-                        literals ~= e;
-                    }
-                    while (skip(Tok.Comma));
+                    Token _default = next();
                     require(Tok.Colon);
-
+                    statements.length = 0;
                     while (peek.type != Tok.Case
                             && peek.type != Tok.Default
                             && peek.type != Tok.CloseBrace)
                         statements ~= parseStatement();
-
-                    action.actOnCaseStmt(res, _case, literals, statements);
-
-                    if (peek.type == Tok.CloseBrace)
-                        break;
+                    action.actOnDefaultStmt(res, _default, statements);
+                    continue;
                 }
-                require(Tok.CloseBrace);
-                return res;
-            }
-           else
-           {
-               if (t.type == Tok.Star)
-               {
-                   auto exp = parseExpression();
-                   require(Tok.Seperator);
-                   return action.actOnExprStmt(exp);
-               }
-               messages.report(UnexpectedBeginStmt, t.location).arg(t.getType);
-               return null;
-           }
-           messages.report(UnexpectedTok, t.location);
-           return null;
-       }
+
+                Token _case = peek;
+                if (_case.type != Tok.Case)
+                    break;
+                next();
+
+                Exp[] literals;
+                do
+                {
+                    Exp e = parseExpression();
+                    literals ~= e;
+                }
+                while (skip(Tok.Comma));
+                require(Tok.Colon);
+
+                while (peek.type != Tok.Case
+                        && peek.type != Tok.Default
+                        && peek.type != Tok.CloseBrace)
+                    statements ~= parseStatement();
+
+                action.actOnCaseStmt(res, _case, literals, statements);
 
-       Decl parseVarDecl()
-       {
-           // manually hardcoded to only support "type id [= exp];"
-           // as that is the only thing the codegen understands
-           Id type = parseType;
-           Id id = Id(next());
-           Exp init;
-           if (skip(Tok.Assign))
-               init = parseExpression();
-           require(Tok.Seperator);
-           Attribute att;
-           Decl d = action.actOnDeclarator(type, id, init, att);
-           return d;
-       }
+                if (peek.type == Tok.CloseBrace)
+                    break;
+            }
+            require(Tok.CloseBrace);
+            return res;
+        }
+        else if (t.type == Tok.Star)
+        {
+            auto exp = parseExpression();
+            require(Tok.Seperator);
+            return action.actOnExprStmt(exp);
+        }
+        else
+        {
+            messages.report(UnexpectedBeginStmt, t.location).arg(t.getType);
+            return null;
+        }
+    }
 
-       /**
-         Parses a function/method given the already parsed return type and name
-        */
-       Decl parseFunc(ref Id type, ref Id name, Attribute att)
-       {
-           Decl func = action.actOnStartOfFunctionDef(type, name, att);
-           parseFuncArgs(func);
+    Decl parseVarDecl()
+    {
+        // manually hardcoded to only support "type id [= exp];"
+        // as that is the only thing the codegen understands
+        Id type = parseType;
+        Id id = Id(next());
+        Exp init;
+        if (skip(Tok.Assign))
+            init = parseExpression();
+        require(Tok.Seperator);
+        Attribute att;
+        Decl d = action.actOnDeclarator(type, id, init, att);
+        return d;
+    }
 
-           if(peek.type == Tok.Seperator)
-           {
-               next();
-               return func;
-           }
-           Stmt stmt = parseCompoundStatement();
+    /**
+      Parses a function/method given the already parsed return type and name
+     */
+    Decl parseFunc(ref Id type, ref Id name, Attribute att)
+    {
+        Decl func = action.actOnStartOfFunctionDef(type, name, att);
+        parseFuncArgs(func);
 
-           return action.actOnEndOfFunction(func, stmt);
-       }
-
-       /**
-         Parse the function arguments, assumes current token is (.
+        if(peek.type == Tok.Seperator)
+        {
+            next();
+            return func;
+        }
+        Stmt stmt = parseCompoundStatement();
 
-         Both the intitial paren and the ending paren is consumed.
-        */
-       void parseFuncArgs(Decl func)
-       {
-           require(Tok.OpenParentheses); // Remove the "(" token.
+        return action.actOnEndOfFunction(func, stmt);
+    }
+
+    /**
+      Parse the function arguments, assumes current token is (.
 
-           while(peek.type != Tok.CloseParentheses)
-           {
-               auto t = parseType();
-               Id i;
-               if(peek.type == Tok.Identifier)
-                   i = parseIdentifier();
-               action.addFuncArg(func, t, i);
+      Both the intitial paren and the ending paren is consumed.
+     */
+    void parseFuncArgs(Decl func)
+    {
+        require(Tok.OpenParentheses); // Remove the "(" token.
 
-               if(peek.type == Tok.Comma)
-                   next();
-           }
+        while(peek.type != Tok.CloseParentheses)
+        {
+            auto t = parseType();
+            Id i;
+            if(peek.type == Tok.Identifier)
+                i = parseIdentifier();
+            action.addFuncArg(func, t, i);
 
-           require(Tok.CloseParentheses); // Remove the ")"
-       }
+            if(peek.type == Tok.Comma)
+                next();
+        }
 
-       /**
-         Parse either a block, or a single statement as allowed after if, while
-         and for.
-        */
-       Stmt parseSingleOrCompoundStatement()
-       {
-           if (peek.type == Tok.OpenBrace)
-               return parseCompoundStatement();
-           return parseStatement();
-       }
+        require(Tok.CloseParentheses); // Remove the ")"
+    }
 
-       /**
-         Parses a function-body or similar, expects an opening brace to be the
-         current token.
+    /**
+      Parse either a block, or a single statement as allowed after if, while
+      and for.
+     */
+    Stmt parseSingleOrCompoundStatement()
+    {
+        if (peek.type == Tok.OpenBrace)
+            return parseCompoundStatement();
+        return parseStatement();
+    }
+
+    /**
+      Parses a function-body or similar, expects an opening brace to be the
+      current token.
 
-         Will consume both the starting { and ending }
-        */
-       Stmt parseCompoundStatement()
-       {
-           Token lbrace = require(Tok.OpenBrace);
-           SmallArray!(Stmt, 32) stmts; // Try to use the stack only
-           while ( !isa(Tok.CloseBrace) && !isa(Tok.EOF) )
-               stmts ~= parseStatement();
-           Token rbrace = require(Tok.CloseBrace);
-           return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe());
-       }
+      Will consume both the starting { and ending }
+     */
+    Stmt parseCompoundStatement()
+    {
+        Token lbrace = require(Tok.OpenBrace);
+        SmallArray!(Stmt, 32) stmts; // Try to use the stack only
+        while ( !isa(Tok.CloseBrace) && !isa(Tok.EOF) )
+            stmts ~= parseStatement();
+        Token rbrace = require(Tok.CloseBrace);
+        return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe());
+    }
 
-       Id parseIdentifier()
-       {
-           Token tok = next();
+    Id parseIdentifier()
+    {
+        Token tok = next();
 
-           if (tok.type is Tok.Identifier)
-               return Id(tok);
+        if (tok.type is Tok.Identifier)
+            return Id(tok);
 
-           messages.report(UnexpectedTokSingle, tok.location)
-               .arg(tok.getType)
-               .arg(Tok.Identifier);
-       }
+        messages.report(UnexpectedTokSingle, tok.location)
+            .arg(tok.getType)
+            .arg(Tok.Identifier);
+    }
 
-       ModuleName parseModuleName()
-       {
-           auto id = parseIdentifier();
-           ModuleName mod;
-           while (skip(Tok.Dot))
-           {
-               mod.packages ~= id;
-               if (peek.type != Tok.Identifier) {
-                   messages.report(ExpectedIdAfterPackage, peek.location);
-                   goto Lerror;
-               }
-               id = parseIdentifier();
-           }
-           mod.id = id;
-           return mod;
+    ModuleName parseModuleName()
+    {
+        auto id = parseIdentifier();
+        ModuleName mod;
+        while (skip(Tok.Dot))
+        {
+            mod.packages ~= id;
+            if (peek.type != Tok.Identifier) {
+                messages.report(ExpectedIdAfterPackage, peek.location);
+                goto Lerror;
+            }
+            id = parseIdentifier();
+        }
+        mod.id = id;
+        return mod;
 Lerror:
-           while (!skip(Tok.Seperator))
-               next();
-           return mod;
-       }
+        while (!skip(Tok.Seperator))
+            next();
+        return mod;
+    }
 
 
-       /**
-         Parse a type - this includes pointer and array(at some point) types.
-        */
-       Id parseType()
-       {
-           Token type = next();
+    /**
+      Parse a type - this includes pointer and array(at some point) types.
+     */
+    Id parseType()
+    {
+        Token type = next();
 
-           Id currentType;
+        Id currentType;
 
-           if ( !(type.isBasicType || type.type == Tok.Identifier) )
-               messages.report(InvalidType, type.location);
+        if ( !(type.isBasicType || type.type == Tok.Identifier) )
+            messages.report(InvalidType, type.location);
 
-           currentType = Id(type);
-           type = peek;
+        currentType = Id(type);
+        type = peek;
 
-           while(type.type == Tok.Star || type.type == Tok.OpenBracket)
-           {
-               if(type.type == Tok.Star)
-               {
-                   currentType = PointerId(currentType);
-                   next();
-               }
-               else
-               {
-                   next();
-                   if(peek.type == Tok.Integer)
-                       currentType = StaticArrayId(
-                               currentType, 
-                               action.actOnNumericConstant(
-                                   require(Tok.Integer)));
-                   require(Tok.CloseBracket);
+        while(type.type == Tok.Star || type.type == Tok.OpenBracket)
+        {
+            if(type.type == Tok.Star)
+            {
+                currentType = PointerId(currentType);
+                next();
+            }
+            else
+            {
+                next();
+                if(peek.type == Tok.Integer)
+                    currentType = StaticArrayId(
+                            currentType, 
+                            action.actOnNumericConstant(
+                                require(Tok.Integer)));
+                require(Tok.CloseBracket);
 
-               }
-               type = peek;
-           }
+            }
+            type = peek;
+        }
 
-           return currentType;
-       }
+        return currentType;
+    }
 
-       int peekParseType()
-       {
-           int i;
-           Token type = peek(i);
+    int peekParseType()
+    {
+        int i;
+        Token type = peek(i);
 
-           Id currentType;
+        Id currentType;
 
-           if ( !(type.isBasicType || type.type == Tok.Identifier) )
-               return 0;
+        if ( !(type.isBasicType || type.type == Tok.Identifier) )
+            return 0;
 
-           currentType = Id(type);
-           type = peek(++i);
+        currentType = Id(type);
+        type = peek(++i);
 
-           while(type.type == Tok.Star || type.type == Tok.OpenBracket)
-           {
-               if(type.type == Tok.Star)
-               {
-                   i++;
-               }
-               else
-               {
-                   if(peek(i++).type != Tok.OpenBracket)
-                       return 0;
-                   if(peek(i).type == Tok.Integer)
-                   {
-                       i++;
-                       if(peek(i++).type != Tok.CloseBracket)    
-                           return 0;
-                   }
-                   else
-                       if(peek(i++).type != Tok.CloseBracket)
-                           return 0;
+        while(type.type == Tok.Star || type.type == Tok.OpenBracket)
+        {
+            if(type.type == Tok.Star)
+            {
+                i++;
+            }
+            else
+            {
+                if(peek(i++).type != Tok.OpenBracket)
+                    return 0;
+                if(peek(i).type == Tok.Integer)
+                {
+                    i++;
+                    if(peek(i++).type != Tok.CloseBracket)    
+                        return 0;
+                }
+                else
+                    if(peek(i++).type != Tok.CloseBracket)
+                        return 0;
 
-               }
-               type = peek(i);
-           }
+            }
+            type = peek(i);
+        }
 
-           return i;
-       }
+        return i;
+    }
 
 private:
-       // -- Expression parsing -- //
-       Exp parsePostfixExp(Exp target)
-       {
-           switch(peek.type)
-           {
-               case Tok.Dot:
-                   switch(peek(1).type)
-                   {
-                       case Tok.Identifier:
-                           Token op = next();
-                           Id member = Id(next());
-                           Exp exp = action.actOnMemberReference(target, op.location, member);
-                           return parsePostfixExp(exp);
-                       default:
-                           Token t = peek(1);
-                           messages.report(ExpectedIdAfterDot, t.location);
-                   }
-               case Tok.OpenBracket:
-                   Token open = next();
-                   Exp index = parseExpression();
-                   Token close = require(Tok.CloseBracket);
-                   return action.actOnIndexEpr(target, open, index, close);
-               default:
-                   return target;
-           }
-       }
+    // -- Expression parsing -- //
+    Exp parsePostfixExp(Exp target)
+    {
+        switch(peek.type)
+        {
+            case Tok.Dot:
+                switch(peek(1).type)
+                {
+                    case Tok.Identifier:
+                        Token op = next();
+                        Id member = Id(next());
+                        Exp exp = action.actOnMemberReference(target, op.location, member);
+                        return parsePostfixExp(exp);
+                    default:
+                        Token t = peek(1);
+                        messages.report(ExpectedIdAfterDot, t.location);
+                }
+            case Tok.OpenBracket:
+                Token open = next();
+                Exp index = parseExpression();
+                Token close = require(Tok.CloseBracket);
+                return action.actOnIndexEpr(target, open, index, close);
+            default:
+                return target;
+        }
+    }
 
-       Exp parseExpression(int p = 0)
-       {
-           auto exp = P();
-           Token n = peek();
-           BinOp* op = null;
-           while ((op = binary(n.type)) != null && op.prec >= p)
-           {
-               next();
-               int q = op.leftAssoc? 1 + op.prec : op.prec;
-               auto exp2 = parseExpression(q);
-               exp = action.actOnBinaryOp(n.location, op.operator, exp, exp2);
-               n = peek();
-           }
+    Exp parseExpression(int p = 0)
+    {
+        auto exp = P();
+        Token n = peek();
+        BinOp* op = null;
+        while ((op = binary(n.type)) != null && op.prec >= p)
+        {
+            next();
+            int q = op.leftAssoc? 1 + op.prec : op.prec;
+            auto exp2 = parseExpression(q);
+            exp = action.actOnBinaryOp(n.location, op.operator, exp, exp2);
+            n = peek();
+        }
 
-           return exp;
-       }
+        return exp;
+    }
 
-       Exp P()
-       {
-           Token n = next();
-           if (auto op = unary(n.type))
-               return action.actOnUnaryOp(n, parseExpression(op.prec));
-           else if (n.type == Tok.OpenParentheses)
-           {
-               auto e = parseExpression(0);
-               require(Tok.CloseParentheses);
-               return e;
-           }
-           else if (n.type == Tok.Identifier)
-           {
-               Exp value = action.actOnIdentifierExp(Id(n));
-               Exp iden = parsePostfixExp(value);
-               switch(peek.type)
-               {
-                   case Tok.OpenParentheses:
-                       Token lp = next();
-                       SmallArray!(Exp, 8) args;
-                       while(peek.type != Tok.CloseParentheses)
-                       {
-                           if(peek.type == Tok.Comma)
-                               next();
-                           args ~= parseExpression();
-                       }
+    Exp P()
+    {
+        Token n = next();
+        if (auto op = unary(n.type))
+            return action.actOnUnaryOp(n, parseExpression(op.prec));
+        else if (n.type == Tok.OpenParentheses)
+        {
+            auto e = parseExpression(0);
+            require(Tok.CloseParentheses);
+            return e;
+        }
+        else if (n.type == Tok.Identifier)
+        {
+            Exp value = action.actOnIdentifierExp(Id(n));
+            Exp iden = parsePostfixExp(value);
+            switch(peek.type)
+            {
+                case Tok.OpenParentheses:
+                    Token lp = next();
+                    SmallArray!(Exp, 8) args;
+                    while(peek.type != Tok.CloseParentheses)
+                    {
+                        if(peek.type == Tok.Comma)
+                            next();
+                        args ~= parseExpression();
+                    }
 
-                       Token rp = next();
-                       return action.actOnCallExpr(iden, lp, args.unsafe(), rp);
+                    Token rp = next();
+                    return action.actOnCallExpr(iden, lp, args.unsafe(), rp);
 
-                   default:
-                       return iden;
-               }
-           }
-           else if (n.type == Tok.Cast)
-               return parseCast(n);
-           else if (n.type == Tok.Integer)
-               return action.actOnNumericConstant(n);
-           else if (n.type == Tok.String)
-               return action.actOnStringExp(n);
+                default:
+                    return iden;
+            }
+        }
+        else if (n.type == Tok.Cast)
+            return parseCast(n);
+        else if (n.type == Tok.Integer)
+            return action.actOnNumericConstant(n);
+        else if (n.type == Tok.String)
+            return action.actOnStringExp(n);
 
-           messages.report(ExpectedExp, n.location)
-               .fatal(ExitLevel.Parser);
-           return null;
-       }
+        messages.report(ExpectedExp, n.location)
+            .fatal(ExitLevel.Parser);
+        return null;
+    }
 
-       Exp parseCast(ref Token _cast)
-       {
-           require(Tok.OpenParentheses);
-           auto n = next();
-           if(!n.isBasicType && !n.isIdentifier)
-               messages.report(ExpectedCastType, n.location);
+    Exp parseCast(ref Token _cast)
+    {
+        require(Tok.OpenParentheses);
+        auto n = next();
+        if(!n.isBasicType && !n.isIdentifier)
+            messages.report(ExpectedCastType, n.location);
 
-           require(Tok.CloseParentheses);
-           auto exp = P();
-           return action.actOnCastExpr(_cast, Id(n), exp);
-       }
+        require(Tok.CloseParentheses);
+        auto exp = P();
+        return action.actOnCastExpr(_cast, Id(n), exp);
+    }
 
-       struct UnOp
-       {
-           Tok tokenType;
-           int prec;
-       }
+    struct UnOp
+    {
+        Tok tokenType;
+        int prec;
+    }
 
-       static const UnOp[] _unary =
-           [
-           {Tok.Minus, 4},
-           {Tok.Star, 4}
-       ];
-       UnOp* unary(Tok t)
-       {
-           foreach (ref op; _unary)
-               if (op.tokenType == t)
-                   return &op;
-           return null;
-       }
+    static const UnOp[] _unary =
+        [
+        {Tok.Minus, 4},
+        {Tok.Star, 4}
+    ];
+    UnOp* unary(Tok t)
+    {
+        foreach (ref op; _unary)
+            if (op.tokenType == t)
+                return &op;
+        return null;
+    }
 
-       struct BinOp
-       {
-           Tok tokenType;
-           int prec;
-           bool leftAssoc;
-           Operator operator;
-       }
+    struct BinOp
+    {
+        Tok tokenType;
+        int prec;
+        bool leftAssoc;
+        Operator operator;
+    }
 
-       static const BinOp[] _binary =
-           [
-           {Tok.Assign,        1, false, Operator.Assign},
-           {Tok.PlusAssign,    1, false, Operator.AddAssign},
-           {Tok.MinusAssign,   1, false, Operator.SubAssign},
-           {Tok.StarAssign,    1, false, Operator.MulAssign},
-           {Tok.SlashAssign,   1, false, Operator.DivAssign},
-           {Tok.PercentAssign, 1, false, Operator.ModAssign},
+    static const BinOp[] _binary =
+        [
+        {Tok.Assign,        1, false, Operator.Assign},
+        {Tok.PlusAssign,    1, false, Operator.AddAssign},
+        {Tok.MinusAssign,   1, false, Operator.SubAssign},
+        {Tok.StarAssign,    1, false, Operator.MulAssign},
+        {Tok.SlashAssign,   1, false, Operator.DivAssign},
+        {Tok.PercentAssign, 1, false, Operator.ModAssign},
 
-           // =, += etc. 1
-           // (need special-case for the ternary operator at this level)
-           // ||, 2
-           // &&, 3
-           // |, 4
-           // &, 5
-           // ^, 6
-           // ==, !=, is, !is, 7
-           // <, <= etc, 7
-           // in, 7
-           // <<, >>, >>>, 8
-           // +, -, ~, 9
-           // *, /, %, 10
-           // unary operators here
+        // =, += etc. 1
+        // (need special-case for the ternary operator at this level)
+        // ||, 2
+        // &&, 3
+        // |, 4
+        // &, 5
+        // ^, 6
+        // ==, !=, is, !is, 7
+        // <, <= etc, 7
+        // in, 7
+        // <<, >>, >>>, 8
+        // +, -, ~, 9
+        // *, /, %, 10
+        // unary operators here
 
-           {Tok.Eq,        2, true, Operator.Eq},
-           {Tok.Ne,        2, true, Operator.Ne},
+        {Tok.Eq,        2, true, Operator.Eq},
+        {Tok.Ne,        2, true, Operator.Ne},
 
-           {Tok.Lt,        2, true, Operator.Lt},
-           {Tok.Le,        2, true, Operator.Le},
-           {Tok.Gt,        2, true, Operator.Gt},
-           {Tok.Ge,        2, true, Operator.Ge},
+        {Tok.Lt,        2, true, Operator.Lt},
+        {Tok.Le,        2, true, Operator.Le},
+        {Tok.Gt,        2, true, Operator.Gt},
+        {Tok.Ge,        2, true, Operator.Ge},
 
-           {Tok.Plus,      3, true, Operator.Add},
-           {Tok.Minus,     3, true, Operator.Sub},
+        {Tok.Plus,      3, true, Operator.Add},
+        {Tok.Minus,     3, true, Operator.Sub},
 
-           {Tok.Star,      5, true, Operator.Mul},
-           {Tok.Slash,     5, true, Operator.Div},
-           {Tok.Percent,   5, true, Operator.Mod},
+        {Tok.Star,      5, true, Operator.Mul},
+        {Tok.Slash,     5, true, Operator.Div},
+        {Tok.Percent,   5, true, Operator.Mod},
 
-           {Tok.LeftShift,             8, true, Operator.LeftShift},
-           {Tok.RightShift,            8, true, Operator.RightShift},
-           {Tok.UnsignedRightShift,    8, true, Operator.UnsignedRightShift}
-       ];
-       BinOp* binary(Tok t)
-       {
-           foreach (ref op; _binary)
-               if (op.tokenType == t)
-                   return &op;
-           return null;
-       }
+        {Tok.LeftShift,             8, true, Operator.LeftShift},
+        {Tok.RightShift,            8, true, Operator.RightShift},
+        {Tok.UnsignedRightShift,    8, true, Operator.UnsignedRightShift}
+    ];
+    BinOp* binary(Tok t)
+    {
+        foreach (ref op; _binary)
+            if (op.tokenType == t)
+                return &op;
+        return null;
+    }
 
 private:
 
-       Token require(Tok t)
-       {
-           if (peek().type != t)
-               messages.report(UnexpectedTokSingle, peek.location)
-                   .arg(peek.getType)
-                   .arg(t);
-           return next();
-       }
+    Token require(Tok t)
+    {
+        if (peek().type != t)
+            messages.report(UnexpectedTokSingle, peek.location)
+                .arg(peek.getType)
+                .arg(t);
+        return next();
+    }
 
-       bool skip(Tok t)
-       {
-           if (peek().type != t)
-               return false;
-           next();
-           return true;
-       }
+    bool skip(Tok t)
+    {
+        if (peek().type != t)
+            return false;
+        next();
+        return true;
+    }
 
-       bool isa(Tok t)
-       {
-           return peek.type == t;
-       }
+    bool isa(Tok t)
+    {
+        return peek.type == t;
+    }
 
-       Token next()
-       {
-           return lexer.next;
-       }
+    Token next()
+    {
+        return lexer.next;
+    }
 
-       Token peek(int i = 0)
-       {
-           return lexer.peek(i);
-       }
+    Token peek(int i = 0)
+    {
+        return lexer.peek(i);
+    }
 
-       Lexer lexer;   
-       SourceManager sm;
+    Lexer lexer;   
+    SourceManager sm;
 }