--- a/trunk/src/Declarations.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,526 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module Declarations;
-import SyntaxTree;
-import Expressions;
-import Types;
-import Statements;
-import Token;
-
-abstract class Declaration : Node
-{
-  bool hasBody;
-  this(bool hasBody)
-  {
-    super(NodeCategory.Declaration);
-    this.hasBody = hasBody;
-  }
-}
-
-class Declarations : Declaration
-{
-  this()
-  {
-    super(true);
-    mixin(set_kind);
-  }
-
-  void opCatAssign(Declaration d)
-  {
-    this.children ~= d;
-  }
-
-  void opCatAssign(Declarations ds)
-  {
-    this.children ~= ds.children;
-  }
-}
-
-class EmptyDeclaration : Declaration
-{
-  this()
-  {
-    super(false);
-    mixin(set_kind);
-  }
-}
-
-class IllegalDeclaration : Declaration
-{
-  Token* token;
-  this(Token* token)
-  {
-    super(false);
-    mixin(set_kind);
-    this.token = token;
-  }
-}
-
-alias Token*[] ModuleName; // Identifier(.Identifier)*
-
-class ModuleDeclaration : Declaration
-{
-  ModuleName moduleName; // module name sits at end of array
-  this(ModuleName moduleName)
-  {
-    super(false);
-    mixin(set_kind);
-    this.moduleName = moduleName;
-  }
-}
-
-class ImportDeclaration : Declaration
-{
-  ModuleName[] moduleNames;
-  Token*[] moduleAliases;
-  Token*[] bindNames;
-  Token*[] bindAliases;
-  this(ModuleName[] moduleNames, Token*[] moduleAliases, Token*[] bindNames, Token*[] bindAliases)
-  {
-    super(false);
-    mixin(set_kind);
-    this.moduleNames = moduleNames;
-    this.moduleAliases = moduleAliases;
-    this.bindNames = bindNames;
-    this.bindAliases = bindAliases;
-  }
-}
-
-class AliasDeclaration : Declaration
-{
-  Declaration decl;
-  this(Declaration decl)
-  {
-    super(false);
-    mixin(set_kind);
-    this.children = [decl];
-    this.decl = decl;
-  }
-}
-
-class TypedefDeclaration : Declaration
-{
-  Declaration decl;
-  this(Declaration decl)
-  {
-    super(false);
-    mixin(set_kind);
-    this.children = [decl];
-    this.decl = decl;
-  }
-}
-
-class EnumDeclaration : Declaration
-{
-  Token* name;
-  Type baseType;
-  Token*[] members;
-  Expression[] values;
-  this(Token* name, Type baseType, Token*[] members, Expression[] values, bool hasBody)
-  {
-    super(hasBody);
-    mixin(set_kind);
-    if (baseType)
-      this.children = [baseType];
-    foreach(value; values)
-      if (value)
-        this.children ~= value;
-    this.name = name;
-    this.baseType = baseType;
-    this.members = members;
-    this.values = values;
-  }
-}
-
-class ClassDeclaration : Declaration
-{
-  Token* name;
-  TemplateParameters tparams;
-  BaseClass[] bases;
-  Declarations decls;
-  this(Token* name, TemplateParameters tparams, BaseClass[] bases, Declarations decls, bool hasBody)
-  {
-    super(hasBody);
-    mixin(set_kind);
-    if (tparams)
-      this.children = [tparams];
-    if (bases.length)
-      this.children ~= bases;
-    this.children ~= decls;
-
-    this.name = name;
-    this.tparams = tparams;
-    this.bases = bases;
-    this.decls = decls;
-  }
-}
-
-class InterfaceDeclaration : Declaration
-{
-  Token* name;
-  TemplateParameters tparams;
-  BaseClass[] bases;
-  Declarations decls;
-  this(Token* name, TemplateParameters tparams, BaseClass[] bases, Declarations decls, bool hasBody)
-  {
-    super(hasBody);
-    mixin(set_kind);
-    if (tparams)
-      this.children = [tparams];
-    if (bases.length)
-      this.children ~= bases;
-    this.children ~= decls;
-
-    this.name = name;
-    this.tparams = tparams;
-    this.bases = bases;
-    this.decls = decls;
-  }
-}
-
-class StructDeclaration : Declaration
-{
-  Token* name;
-  TemplateParameters tparams;
-  Declarations decls;
-  this(Token* name, TemplateParameters tparams, Declarations decls, bool hasBody)
-  {
-    super(hasBody);
-    mixin(set_kind);
-    if (tparams)
-      this.children = [tparams];
-    this.children ~= decls;
-
-    this.name = name;
-    this.tparams = tparams;
-    this.decls = decls;
-  }
-}
-
-class UnionDeclaration : Declaration
-{
-  Token* name;
-  TemplateParameters tparams;
-  Declarations decls;
-  this(Token* name, TemplateParameters tparams, Declarations decls, bool hasBody)
-  {
-    super(hasBody);
-    mixin(set_kind);
-    if (tparams)
-      this.children = [tparams];
-    this.children ~= decls;
-
-    this.name = name;
-    this.tparams = tparams;
-    this.decls = decls;
-  }
-}
-
-class ConstructorDeclaration : Declaration
-{
-  Parameters parameters;
-  FunctionBody funcBody;
-  this(Parameters parameters, FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [cast(Node)parameters, funcBody];
-    this.parameters = parameters;
-    this.funcBody = funcBody;
-  }
-}
-
-class StaticConstructorDeclaration : Declaration
-{
-  FunctionBody funcBody;
-  this(FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [funcBody];
-    this.funcBody = funcBody;
-  }
-}
-
-class DestructorDeclaration : Declaration
-{
-  FunctionBody funcBody;
-  this(FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [funcBody];
-    this.funcBody = funcBody;
-  }
-}
-
-class StaticDestructorDeclaration : Declaration
-{
-  FunctionBody funcBody;
-  this(FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [funcBody];
-    this.funcBody = funcBody;
-  }
-}
-
-class FunctionDeclaration : Declaration
-{
-  Type returnType;
-  Token* funcName;
-  TemplateParameters tparams;
-  Parameters params;
-  FunctionBody funcBody;
-  this(Type returnType, Token* funcName, TemplateParameters tparams, Parameters params, FunctionBody funcBody)
-  {
-    assert(returnType !is null);
-    super(funcBody.funcBody !is null);
-    mixin(set_kind);
-    this.children = [returnType];
-    if (tparams)
-      this.children ~= tparams;
-    this.children ~= [cast(Node)params, funcBody];
-    this.returnType = returnType;
-    this.funcName = funcName;
-    this.tparams = tparams;
-    this.params = params;
-    this.funcBody = funcBody;
-  }
-}
-
-class VariableDeclaration : Declaration
-{
-  Type type;
-  Token*[] idents;
-  Expression[] values;
-  this(Type type, Token*[] idents, Expression[] values)
-  {
-    super(false);
-    mixin(set_kind);
-    if (type)
-      this.children = [type];
-    foreach(value; values)
-      if (value)
-        this.children ~= value;
-    this.type = type;
-    this.idents = idents;
-    this.values = values;
-  }
-}
-
-class InvariantDeclaration : Declaration
-{
-  FunctionBody funcBody;
-  this(FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [funcBody];
-    this.funcBody = funcBody;
-  }
-}
-
-class UnittestDeclaration : Declaration
-{
-  FunctionBody funcBody;
-  this(FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [funcBody];
-    this.funcBody = funcBody;
-  }
-}
-
-class DebugDeclaration : Declaration
-{
-  Token* spec;
-  Token* cond;
-  Declaration decls, elseDecls;
-
-  this(Token* spec, Token* cond, Declaration decls, Declaration elseDecls)
-  {
-    super(true /+decls.length != 0+/);
-    mixin(set_kind);
-    if (decls)
-      this.children = [decls];
-    if (elseDecls)
-      this.children ~= elseDecls;
-    this.spec = spec;
-    this.cond = cond;
-    this.decls = decls;
-    this.elseDecls = elseDecls;
-  }
-}
-
-class VersionDeclaration : Declaration
-{
-  Token* spec;
-  Token* cond;
-  Declaration decls, elseDecls;
-
-  this(Token* spec, Token* cond, Declaration decls, Declaration elseDecls)
-  {
-    super(true /+decls.length != 0+/);
-    mixin(set_kind);
-    if (decls)
-      this.children = [decls];
-    if (elseDecls)
-      this.children ~= elseDecls;
-    this.spec = spec;
-    this.cond = cond;
-    this.decls = decls;
-    this.elseDecls = elseDecls;
-  }
-}
-
-class StaticIfDeclaration : Declaration
-{
-  Expression condition;
-  Declaration ifDecls, elseDecls;
-  this(Expression condition, Declaration ifDecls, Declaration elseDecls)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [cast(Node)condition, ifDecls, elseDecls];
-    this.condition = condition;
-    this.ifDecls = ifDecls;
-    this.elseDecls = elseDecls;
-  }
-}
-
-class StaticAssertDeclaration : Declaration
-{
-  Expression condition, message;
-  this(Expression condition, Expression message)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [condition];
-    if (message)
-      this.children ~= message;
-    this.condition = condition;
-    this.message = message;
-  }
-}
-
-class TemplateDeclaration : Declaration
-{
-  Token* name;
-  TemplateParameters tparams;
-  Declarations decls;
-  this(Token* name, TemplateParameters tparams, Declarations decls)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [cast(Node)tparams, decls];
-    this.name = name;
-    this.tparams = tparams;
-    this.decls = decls;
-  }
-}
-
-class NewDeclaration : Declaration
-{
-  Parameters parameters;
-  FunctionBody funcBody;
-  this(Parameters parameters, FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [cast(Node)parameters, funcBody];
-    this.parameters = parameters;
-    this.funcBody = funcBody;
-  }
-}
-
-class DeleteDeclaration : Declaration
-{
-  Parameters parameters;
-  FunctionBody funcBody;
-  this(Parameters parameters, FunctionBody funcBody)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [cast(Node)parameters, funcBody];
-    this.parameters = parameters;
-    this.funcBody = funcBody;
-  }
-}
-
-class AttributeDeclaration : Declaration
-{
-  TOK attribute;
-  Declaration decls;
-  this(TOK attribute, Declaration decls)
-  {
-    super(true);
-    mixin(set_kind);
-    this.children = [decls];
-    this.attribute = attribute;
-    this.decls = decls;
-  }
-}
-
-class ExternDeclaration : AttributeDeclaration
-{
-  Linkage linkage;
-  this(Linkage linkage, Declaration decls)
-  {
-    super(TOK.Extern, decls);
-    mixin(set_kind);
-    this.linkage = linkage;
-  }
-}
-
-class AlignDeclaration : AttributeDeclaration
-{
-  int size;
-  this(int size, Declaration decls)
-  {
-    super(TOK.Align, decls);
-    mixin(set_kind);
-    this.size = size;
-  }
-}
-
-class PragmaDeclaration : AttributeDeclaration
-{
-  Token* ident;
-  Expression[] args;
-  this(Token* ident, Expression[] args, Declaration decls)
-  {
-    super(TOK.Pragma, decls);
-    mixin(set_kind);
-    if (args.length)
-      this.children ~= args;
-    this.ident = ident;
-    this.args = args;
-  }
-}
-
-class MixinDeclaration : Declaration
-{
-  Expression[] templateIdents;
-  Token* mixinIdent;
-  Expression argument; // mixin ( AssignExpression )
-  this(Expression[] templateIdents, Token* mixinIdent)
-  {
-    super(false);
-    mixin(set_kind);
-    this.children = templateIdents;
-    this.templateIdents = templateIdents;
-    this.mixinIdent = mixinIdent;
-  }
-  this(Expression argument)
-  {
-    super(false);
-    mixin(set_kind);
-    this.children = [argument];
-    this.argument = argument;
-  }
-}

--- a/trunk/src/Expressions.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,988 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module Expressions;
-import SyntaxTree;
-import Token;
-import Types;
-import Declarations;
-import Statements;
-
-abstract class Expression : Node
-{
-  this()
-  {
-    super(NodeCategory.Expression);
-  }
-}
-
-class EmptyExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-abstract class BinaryExpression : Expression
-{
-  Expression left, right;
-  Token* tok;
-  this(Expression left, Expression right, Token* tok)
-  {
-    this.children = [left, right];
-    this.left = left;
-    this.right = right;
-    this.tok = tok;
-  }
-}
-
-class CondExpression : BinaryExpression
-{
-  Expression condition;
-  this(Expression condition, Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-    this.children ~= [condition];
-    this.condition = condition;
-  }
-}
-
-class CommaExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class OrOrExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class AndAndExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class OrExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class XorExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class AndExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-abstract class CmpExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-  }
-}
-
-class EqualExpression : CmpExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class IdentityExpression : CmpExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class RelExpression : CmpExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class InExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class LShiftExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class RShiftExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class URShiftExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class PlusExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class MinusExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class CatExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class MulExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class DivExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class ModExpression : BinaryExpression
-{
-  this(Expression left, Expression right, Token* tok)
-  {
-    super(left, right, tok);
-    mixin(set_kind);
-  }
-}
-
-class AssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class LShiftAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class RShiftAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class URShiftAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class OrAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class AndAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class PlusAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class MinusAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class DivAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class MulAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class ModAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class XorAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-class CatAssignExpression : BinaryExpression
-{
-  this(Expression left, Expression right)
-  {
-    super(left, right, null);
-    mixin(set_kind);
-  }
-}
-
-abstract class UnaryExpression : Expression
-{
-  Expression e;
-  this(Expression e)
-  {
-    this.children ~= e;
-    this.e = e;
-  }
-}
-
-class AddressExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class PreIncrExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class PreDecrExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class PostIncrExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class PostDecrExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class DerefExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class SignExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class NotExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class CompExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-/+
-class DotIdExpression : UnaryExpression
-{
-  string ident;
-  this(Expression e, string ident)
-  {
-    super(e);
-    this.ident = ident;
-  }
-}
-+/
-/+
-class DotTemplateInstanceExpression : UnaryExpression
-{
-  string ident;
-  TemplateArguments targs;
-  this(Expression e, string ident, TemplateArguments targs)
-  {
-    super(e);
-    this.ident = ident;
-    this.targs = targs;
-  }
-}
-+/
-class PostDotListExpression : UnaryExpression
-{
-  DotListExpression dotList;
-  this(Expression e, DotListExpression dotList)
-  {
-    super(e);
-    mixin(set_kind);
-    this.children ~= [dotList];
-    this.dotList = dotList;
-  }
-}
-
-class CallExpression : UnaryExpression
-{
-  Expression[] args;
-  this(Expression e, Expression[] args)
-  {
-    super(e);
-    mixin(set_kind);
-    this.children ~= args;
-    this.args = args;
-  }
-}
-
-class NewExpression : /*Unary*/Expression
-{
-  Expression[] newArgs;
-  Type type;
-  Expression[] ctorArgs;
-  this(/*Expression e, */Expression[] newArgs, Type type, Expression[] ctorArgs)
-  {
-    /*super(e);*/
-    mixin(set_kind);
-    if (newArgs.length)
-      this.children ~= newArgs;
-    this.children ~= type;
-    if (ctorArgs.length)
-      this.children ~= ctorArgs;
-    this.newArgs = newArgs;
-    this.type = type;
-    this.ctorArgs = ctorArgs;
-  }
-}
-
-class NewAnonClassExpression : /*Unary*/Expression
-{
-  Expression[] newArgs;
-  BaseClass[] bases;
-  Expression[] ctorArgs;
-  Declarations decls;
-  this(/*Expression e, */Expression[] newArgs, BaseClass[] bases, Expression[] ctorArgs, Declarations decls)
-  {
-    /*super(e);*/
-    mixin(set_kind);
-    if (newArgs.length)
-      this.children ~= newArgs;
-    if (bases.length)
-      this.children ~= bases;
-    if (ctorArgs.length)
-      this.children ~= ctorArgs;
-    this.children ~= decls;
-
-    this.newArgs = newArgs;
-    this.bases = bases;
-    this.ctorArgs = ctorArgs;
-    this.decls = decls;
-  }
-}
-
-class DeleteExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class CastExpression : UnaryExpression
-{
-  Type type;
-  this(Expression e, Type type)
-  {
-    this.children = [type];
-    super(e);
-    mixin(set_kind);
-    this.type = type;
-  }
-}
-
-class IndexExpression : UnaryExpression
-{
-  Expression[] args;
-  this(Expression e, Expression[] args)
-  {
-    super(e);
-    mixin(set_kind);
-    this.children ~= args;
-    this.args = args;
-  }
-}
-
-class SliceExpression : UnaryExpression
-{
-  Expression left, right;
-  this(Expression e, Expression left, Expression right)
-  {
-    super(e);
-    mixin(set_kind);
-    this.children ~= [left, right];
-    this.left = left;
-    this.right = right;
-  }
-}
-
-/*
-class PrimaryExpression
-{
-
-}
-*/
-
-class IdentifierExpression : Expression
-{
-  Token* identifier;
-  this(Token* identifier)
-  {
-    mixin(set_kind);
-    this.identifier = identifier;
-  }
-}
-
-class SpecialTokenExpression : Expression
-{
-  Token* special;
-  this(Token* special)
-  {
-    mixin(set_kind);
-    this.special = special;
-  }
-}
-
-/*
-class IdentifierListExpression : Expression
-{
-  Expression[] identList;
-  this(Expression[] identList)
-  {
-    this.identList = identList;
-  }
-}
-*/
-class DotListExpression : Expression
-{
-  Expression[] items;
-  this(Expression[] items)
-  {
-    mixin(set_kind);
-    this.children = items;
-    this.items = items;
-  }
-}
-
-class TemplateInstanceExpression : Expression
-{
-  Token* ident;
-  TemplateArguments targs;
-  this(Token* ident, TemplateArguments targs)
-  {
-    mixin(set_kind);
-    this.children = [targs];
-    this.ident = ident;
-    this.targs = targs;
-  }
-}
-
-class ThisExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class SuperExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class NullExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class DollarExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class BoolExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class IntNumberExpression : Expression
-{
-  TOK type;
-  ulong number;
-  this(TOK type, ulong number)
-  {
-    mixin(set_kind);
-    this.number = number;
-    this.type = type;
-  }
-}
-
-class RealNumberExpression : Expression
-{
-  TOK type;
-  real number;
-  this(TOK type, real number)
-  {
-    mixin(set_kind);
-    this.number = number;
-    this.type = type;
-  }
-}
-
-class CharLiteralExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class StringLiteralsExpression : Expression
-{
-  Token*[] strings;
-  this(Token*[] strings)
-  {
-    mixin(set_kind);
-    this.strings = strings;
-  }
-
-  string getString()
-  {
-    char[] buffer;
-    foreach (strTok; strings)
-    {
-      buffer ~= strTok.str[0..$-1];
-    }
-    return buffer;
-  }
-}
-
-class ArrayLiteralExpression : Expression
-{
-  Expression[] values;
-  this(Expression[] values)
-  {
-    mixin(set_kind);
-    this.children = values;
-    this.values = values;
-  }
-}
-
-class AssocArrayLiteralExpression : Expression
-{
-  Expression[] keys, values;
-  this(Expression[] keys, Expression[] values)
-  {
-    assert(keys.length == values.length);
-    mixin(set_kind);
-    foreach (i, key; keys)
-      this.children ~= [key, values[i]];
-    this.keys = keys;
-    this.values = values;
-  }
-}
-
-class AssertExpression : Expression
-{
-  Expression expr, msg;
-  this(Expression expr, Expression msg)
-  {
-    mixin(set_kind);
-    this.children = [expr];
-    if (msg)
-      this.children ~= msg;
-    this.expr = expr;
-    this.msg = msg;
-  }
-}
-
-class MixinExpression : Expression
-{
-  Expression expr;
-  this(Expression expr)
-  {
-    mixin(set_kind);
-    this.children = [expr];
-    this.expr = expr;
-  }
-}
-
-class ImportExpression : Expression
-{
-  Expression expr;
-  this(Expression expr)
-  {
-    mixin(set_kind);
-    this.children = [expr];
-    this.expr = expr;
-  }
-}
-
-class TypeofExpression : Expression
-{
-  Type type;
-  this(Type type)
-  {
-    mixin(set_kind);
-    this.children = [type];
-    this.type = type;
-  }
-}
-
-class TypeDotIdExpression : Expression
-{
-  Type type;
-  Token* ident;
-  this(Type type, Token* ident)
-  {
-    mixin(set_kind);
-    this.children = [type];
-    this.type = type;
-    this.ident = ident;
-  }
-}
-
-class TypeidExpression : Expression
-{
-  Type type;
-  this(Type type)
-  {
-    mixin(set_kind);
-    this.children = [type];
-    this.type = type;
-  }
-}
-
-class IsExpression : Expression
-{
-  Type type;
-  Token* ident;
-  Token* opTok, specTok;
-  Type specType;
-  this(Type type, Token* ident, Token* opTok, Token* specTok, Type specType)
-  {
-    mixin(set_kind);
-    this.children = [type];
-    if (specType)
-      this.children ~= specType;
-    this.type = type;
-    this.ident = ident;
-    this.opTok = opTok;
-    this.specTok = specTok;
-    this.specType = specType;
-  }
-}
-
-class FunctionLiteralExpression : Expression
-{
-  Type returnType;
-  Parameters parameters;
-  FunctionBody funcBody;
-
-  this()
-  {
-    mixin(set_kind);
-    if (returnType)
-      this.children ~= returnType;
-    if (parameters)
-      this.children ~= parameters;
-    this.children ~= funcBody;
-  }
-
-  this(Type returnType, Parameters parameters, FunctionBody funcBody)
-  {
-    this.returnType = returnType;
-    this.parameters = parameters;
-    this.funcBody = funcBody;
-    this();
-  }
-
-  this(FunctionBody funcBody)
-  {
-    this.funcBody = funcBody;
-    this();
-  }
-}
-
-version(D2)
-{
-class TraitsExpression : Expression
-{
-  Token* ident;
-  TemplateArguments targs;
-  this(typeof(ident) ident, typeof(targs) targs)
-  {
-    mixin(set_kind);
-    this.children = [targs];
-    this.ident = ident;
-    this.targs = targs;
-  }
-}
-}
-
-class VoidInitializer : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class ArrayInitializer : Expression
-{
-  Expression[] keys;
-  Expression[] values;
-  this(Expression[] keys, Expression[] values)
-  {
-    assert(keys.length == values.length);
-    mixin(set_kind);
-    foreach (i, key; keys)
-    {
-      if (key)
-        this.children ~= key;
-      if (values[i])
-        this.children ~= values[i];
-    }
-    this.keys = keys;
-    this.values = values;
-  }
-}
-
-class StructInitializer : Expression
-{
-  Token*[] idents;
-  Expression[] values;
-  this(Token*[] idents, Expression[] values)
-  {
-    mixin(set_kind);
-    this.children = values;
-    this.idents = idents;
-    this.values = values;
-  }
-}
-
-class AsmTypeExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class AsmOffsetExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class AsmSegExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class AsmPostBracketExpression : UnaryExpression
-{
-  this(Expression e)
-  {
-    super(e);
-    mixin(set_kind);
-  }
-}
-
-class AsmBracketExpression : Expression
-{
-  Expression e;
-  this(Expression e)
-  {
-    mixin(set_kind);
-    this.children = [e];
-    this.e = e;
-  }
-}
-
-class AsmLocalSizeExpression : Expression
-{
-  this()
-  {
-    mixin(set_kind);
-  }
-}
-
-class AsmRegisterExpression : Expression
-{
-  Token* register;
-  Token* number; // ST(0) - ST(7)
-  this(Token* register, Token* number = null)
-  {
-    mixin(set_kind);
-    this.register = register;
-    this.number = number;
-  }
-}

--- a/trunk/src/HtmlEntities.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,277 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module HtmlEntities;
-
-private const dchar[char[]] entities_table;
-
-static this()
-{
-  entities_table = [
-    "Aacute"[] : '\u00C1',
-    "aacute" : '\u00E1',
-    "Acirc" : '\u00C2',
-    "acirc" : '\u00E2',
-    "acute" : '\u00B4',
-    "AElig" : '\u00C6',
-    "aelig" : '\u00E6',
-    "Agrave" : '\u00C0',
-    "agrave" : '\u00E0',
-    "alefsym" : '\u2135',
-    "Alpha" : '\u0391',
-    "alpha" : '\u03B1',
-    "amp" : '\u0026',
-    "and" : '\u2227',
-    "ang" : '\u2220',
-    "Aring" : '\u00C5',
-    "aring" : '\u00E5',
-    "asymp" : '\u2248',
-    "Atilde" : '\u00C3',
-    "atilde" : '\u00E3',
-    "Auml" : '\u00C4',
-    "auml" : '\u00E4',
-    "bdquo" : '\u201E',
-    "Beta" : '\u0392',
-    "beta" : '\u03B2',
-    "brvbar" : '\u00A6',
-    "bull" : '\u2022',
-    "cap" : '\u2229',
-    "Ccedil" : '\u00C7',
-    "ccedil" : '\u00E7',
-    "cedil" : '\u00B8',
-    "cent" : '\u00A2',
-    "Chi" : '\u03A7',
-    "chi" : '\u03C7',
-    "circ" : '\u02C6',
-    "clubs" : '\u2663',
-    "cong" : '\u2245',
-    "copy" : '\u00A9',
-    "crarr" : '\u21B5',
-    "cup" : '\u222A',
-    "curren" : '\u00A4',
-    "Dagger" : '\u2021',
-    "dagger" : '\u2020',
-    "dArr" : '\u21D3',
-    "darr" : '\u2193',
-    "deg" : '\u00B0',
-    "Delta" : '\u0394',
-    "delta" : '\u03B4',
-    "diams" : '\u2666',
-    "divide" : '\u00F7',
-    "Eacute" : '\u00C9',
-    "eacute" : '\u00E9',
-    "Ecirc" : '\u00CA',
-    "ecirc" : '\u00EA',
-    "Egrave" : '\u00C8',
-    "egrave" : '\u00E8',
-    "empty" : '\u2205',
-    "emsp" : '\u2003',
-    "ensp" : '\u2002',
-    "Epsilon" : '\u0395',
-    "epsilon" : '\u03B5',
-    "equiv" : '\u2261',
-    "Eta" : '\u0397',
-    "eta" : '\u03B7',
-    "ETH" : '\u00D0',
-    "eth" : '\u00F0',
-    "Euml" : '\u00CB',
-    "euml" : '\u00EB',
-    "euro" : '\u20AC',
-    "exist" : '\u2203',
-    "fnof" : '\u0192',
-    "forall" : '\u2200',
-    "frac12" : '\u00BD',
-    "frac14" : '\u00BC',
-    "frac34" : '\u00BE',
-    "frasl" : '\u2044',
-    "Gamma" : '\u0393',
-    "gamma" : '\u03B3',
-    "ge" : '\u2265',
-    "gt" : '\u003E',
-    "hArr" : '\u21D4',
-    "harr" : '\u2194',
-    "hearts" : '\u2665',
-    "hellip" : '\u2026',
-    "Iacute" : '\u00CD',
-    "iacute" : '\u00ED',
-    "Icirc" : '\u00CE',
-    "icirc" : '\u00EE',
-    "iexcl" : '\u00A1',
-    "Igrave" : '\u00CC',
-    "igrave" : '\u00EC',
-    "image" : '\u2111',
-    "infin" : '\u221E',
-    "int" : '\u222B',
-    "Iota" : '\u0399',
-    "iota" : '\u03B9',
-    "iquest" : '\u00BF',
-    "isin" : '\u2208',
-    "Iuml" : '\u00CF',
-    "iuml" : '\u00EF',
-    "Kappa" : '\u039A',
-    "kappa" : '\u03BA',
-    "Lambda" : '\u039B',
-    "lambda" : '\u03BB',
-    "lang" : '\u2329',
-    "laquo" : '\u00AB',
-    "lArr" : '\u21D0',
-    "larr" : '\u2190',
-    "lceil" : '\u2308',
-    "ldquo" : '\u201C',
-    "le" : '\u2264',
-    "lfloor" : '\u230A',
-    "lowast" : '\u2217',
-    "loz" : '\u25CA',
-    "lrm" : '\u200E',
-    "lsaquo" : '\u2039',
-    "lsquo" : '\u2018',
-    "lt" : '\u003C',
-    "macr" : '\u00AF',
-    "mdash" : '\u2014',
-    "micro" : '\u00B5',
-    "middot" : '\u00B7',
-    "minus" : '\u2212',
-    "Mu" : '\u039C',
-    "mu" : '\u03BC',
-    "nabla" : '\u2207',
-    "nbsp" : '\u00A0',
-    "ndash" : '\u2013',
-    "ne" : '\u2260',
-    "ni" : '\u220B',
-    "not" : '\u00AC',
-    "notin" : '\u2209',
-    "nsub" : '\u2284',
-    "Ntilde" : '\u00D1',
-    "ntilde" : '\u00F1',
-    "Nu" : '\u039D',
-    "nu" : '\u03BD',
-    "Oacute" : '\u00D3',
-    "oacute" : '\u00F3',
-    "Ocirc" : '\u00D4',
-    "ocirc" : '\u00F4',
-    "OElig" : '\u0152',
-    "oelig" : '\u0153',
-    "Ograve" : '\u00D2',
-    "ograve" : '\u00F2',
-    "oline" : '\u203E',
-    "Omega" : '\u03A9',
-    "omega" : '\u03C9',
-    "Omicron" : '\u039F',
-    "omicron" : '\u03BF',
-    "oplus" : '\u2295',
-    "or" : '\u2228',
-    "ordf" : '\u00AA',
-    "ordm" : '\u00BA',
-    "Oslash" : '\u00D8',
-    "oslash" : '\u00F8',
-    "Otilde" : '\u00D5',
-    "otilde" : '\u00F5',
-    "otimes" : '\u2297',
-    "Ouml" : '\u00D6',
-    "ouml" : '\u00F6',
-    "para" : '\u00B6',
-    "part" : '\u2202',
-    "permil" : '\u2030',
-    "perp" : '\u22A5',
-    "Phi" : '\u03A6',
-    "phi" : '\u03C6',
-    "Pi" : '\u03A0',
-    "pi" : '\u03C0',
-    "piv" : '\u03D6',
-    "plusmn" : '\u00B1',
-    "pound" : '\u00A3',
-    "Prime" : '\u2033',
-    "prime" : '\u2032',
-    "prod" : '\u220F',
-    "prop" : '\u221D',
-    "Psi" : '\u03A8',
-    "psi" : '\u03C8',
-    "quot" : '\u0022',
-    "radic" : '\u221A',
-    "rang" : '\u232A',
-    "raquo" : '\u00BB',
-    "rArr" : '\u21D2',
-    "rarr" : '\u2192',
-    "rceil" : '\u2309',
-    "rdquo" : '\u201D',
-    "real" : '\u211C',
-    "reg" : '\u00AE',
-    "rfloor" : '\u230B',
-    "Rho" : '\u03A1',
-    "rho" : '\u03C1',
-    "rlm" : '\u200F',
-    "rsaquo" : '\u203A',
-    "rsquo" : '\u2019',
-    "sbquo" : '\u201A',
-    "Scaron" : '\u0160',
-    "scaron" : '\u0161',
-    "sdot" : '\u22C5',
-    "sect" : '\u00A7',
-    "shy" : '\u00AD',
-    "Sigma" : '\u03A3',
-    "sigma" : '\u03C3',
-    "sigmaf" : '\u03C2',
-    "sim" : '\u223C',
-    "spades" : '\u2660',
-    "sub" : '\u2282',
-    "sube" : '\u2286',
-    "sum" : '\u2211',
-    "sup" : '\u2283',
-    "sup1" : '\u00B9',
-    "sup2" : '\u00B2',
-    "sup3" : '\u00B3',
-    "supe" : '\u2287',
-    "szlig" : '\u00DF',
-    "Tau" : '\u03A4',
-    "tau" : '\u03C4',
-    "there4" : '\u2234',
-    "Theta" : '\u0398',
-    "theta" : '\u03B8',
-    "thetasym" : '\u03D1',
-    "thinsp" : '\u2009',
-    "THORN" : '\u00DE',
-    "thorn" : '\u00FE',
-    "tilde" : '\u02DC',
-    "times" : '\u00D7',
-    "trade" : '\u2122',
-    "Uacute" : '\u00DA',
-    "uacute" : '\u00FA',
-    "uArr" : '\u21D1',
-    "uarr" : '\u2191',
-    "Ucirc" : '\u00DB',
-    "ucirc" : '\u00FB',
-    "Ugrave" : '\u00D9',
-    "ugrave" : '\u00F9',
-    "uml" : '\u00A8',
-    "upsih" : '\u03D2',
-    "Upsilon" : '\u03A5',
-    "upsilon" : '\u03C5',
-    "Uuml" : '\u00DC',
-    "uuml" : '\u00FC',
-    "weierp" : '\u2118',
-    "Xi" : '\u039E',
-    "xi" : '\u03BE',
-    "Yacute" : '\u00DD',
-    "yacute" : '\u00FD',
-    "yen" : '\u00A5',
-    "Yuml" : '\u0178',
-    "yuml" : '\u00FF',
-    "Zeta" : '\u0396',
-    "zeta" : '\u03B6',
-    "zwj" : '\u200D',
-    "zwnj" : '\u200C'
-  ];
-}
-
-/++
-  Converts a named HTML entity into its equivalent Unicode codepoint.
-  Returns 0xFFFF if entity doesn't exist.
-+/
-dchar entity2Unicode(char[] entity)
-{
-  auto d = entity in entities_table;
-  if (d)
-    return *d;
-  return 0xFFFF;
-}
\ No newline at end of file

--- a/trunk/src/Identifier.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module Identifier;
-import Token;
-
-struct Identifier
-{
-  TOK type;
-  string str;
-
-  static Identifier opCall(TOK type, string str)
-  {
-    Identifier i;
-    i.type = type;
-    i.str = str;
-    return i;
-  }
-
-  uint toHash()
-  {
-    uint hash;
-    foreach(c; str) {
-      hash *= 9;
-      hash += c;
-    }
-    return hash;
-  }
-}

--- a/trunk/src/Information.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module Information;
-import Messages;
-import std.stdarg;
-
-enum InfoType
-{
-  Lexer,
-  Parser,
-  Semantic
-}
-
-class Information
-{
-  MID id;
-  InfoType type;
-  uint loc;
-  string[] arguments;
-
-  this(InfoType type, MID id, uint loc, string[] arguments)
-  {
-    this.id = id;
-    this.type = type;
-    this.loc = loc;
-    this.arguments = arguments;
-  }
-
-  string getMsg()
-  {
-    return format_args(GetMsg(id), arguments);
-  }
-}

--- a/trunk/src/Keywords.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,117 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module Keywords;
-import Token;
-import Identifier;
-
-static const Identifier[] keywords = [
-  {TOK.Abstract, "abstract"},
-  {TOK.Alias, "alias"},
-  {TOK.Align, "align"},
-  {TOK.Asm, "asm"},
-  {TOK.Assert, "assert"},
-  {TOK.Auto, "auto"},
-  {TOK.Body, "body"},
-  {TOK.Bool, "bool"},
-  {TOK.Break, "break"},
-  {TOK.Byte, "byte"},
-  {TOK.Case, "case"},
-  {TOK.Cast, "cast"},
-  {TOK.Catch, "catch"},
-  {TOK.Cdouble, "cdouble"},
-  {TOK.Cent, "cent"},
-  {TOK.Cfloat, "cfloat"},
-  {TOK.Char, "char"},
-  {TOK.Class, "class"},
-  {TOK.Const, "const"},
-  {TOK.Continue, "continue"},
-  {TOK.Creal, "creal"},
-  {TOK.Dchar, "dchar"},
-  {TOK.Debug, "debug"},
-  {TOK.Default, "default"},
-  {TOK.Delegate, "delegate"},
-  {TOK.Delete, "delete"},
-  {TOK.Deprecated, "deprecated"},
-  {TOK.Do, "do"},
-  {TOK.Double, "double"},
-  {TOK.Else, "else"},
-  {TOK.Enum, "enum"},
-  {TOK.Export, "export"},
-  {TOK.Extern, "extern"},
-  {TOK.False, "false"},
-  {TOK.Final, "final"},
-  {TOK.Finally, "finally"},
-  {TOK.Float, "float"},
-  {TOK.For, "for"},
-  {TOK.Foreach, "foreach"},
-  {TOK.Foreach_reverse, "foreach_reverse"},
-  {TOK.Function, "function"},
-  {TOK.Goto, "goto"},
-  {TOK.Idouble, "idouble"},
-  {TOK.If, "if"},
-  {TOK.Ifloat, "ifloat"},
-  {TOK.Import, "import"},
-  {TOK.In, "in"},
-  {TOK.Inout, "inout"},
-  {TOK.Int, "int"},
-  {TOK.Interface, "interface"},
-  {TOK.Invariant, "invariant"},
-  {TOK.Ireal, "ireal"},
-  {TOK.Is, "is"},
-  {TOK.Lazy, "lazy"},
-  {TOK.Long, "long"},
-  {TOK.Macro, "macro"}, // D2.0
-  {TOK.Mixin, "mixin"},
-  {TOK.Module, "module"},
-  {TOK.New, "new"},
-  {TOK.Null, "null"},
-  {TOK.Out, "out"},
-  {TOK.Override, "override"},
-  {TOK.Package, "package"},
-  {TOK.Pragma, "pragma"},
-  {TOK.Private, "private"},
-  {TOK.Protected, "protected"},
-  {TOK.Public, "public"},
-  {TOK.Real, "real"},
-  {TOK.Ref, "ref"},
-  {TOK.Return, "return"},
-  {TOK.Scope, "scope"},
-  {TOK.Short, "short"},
-  {TOK.Static, "static"},
-  {TOK.Struct, "struct"},
-  {TOK.Super, "super"},
-  {TOK.Switch, "switch"},
-  {TOK.Synchronized, "synchronized"},
-  {TOK.Template, "template"},
-  {TOK.This, "this"},
-  {TOK.Throw, "throw"},
-  {TOK.Traits, "__traits"}, // D2.0
-  {TOK.True, "true"},
-  {TOK.Try, "try"},
-  {TOK.Typedef, "typedef"},
-  {TOK.Typeid, "typeid"},
-  {TOK.Typeof, "typeof"},
-  {TOK.Ubyte, "ubyte"},
-  {TOK.Ucent, "ucent"},
-  {TOK.Uint, "uint"},
-  {TOK.Ulong, "ulong"},
-  {TOK.Union, "union"},
-  {TOK.Unittest, "unittest"},
-  {TOK.Ushort, "ushort"},
-  {TOK.Version, "version"},
-  {TOK.Void, "void"},
-  {TOK.Volatile, "volatile"},
-  {TOK.Wchar, "wchar"},
-  {TOK.While, "while"},
-  {TOK.With, "with"},
-  // Special tokens:
-  {TOK.Special, "__FILE__"},
-  {TOK.Special, "__LINE__"},
-  {TOK.Special, "__DATE__"},
-  {TOK.Special, "__TIME__"},
-  {TOK.Special, "__TIMESTAMP__"},
-  {TOK.Special, "__VENDOR__"},
-  {TOK.Special, "__VERSION__"},
-];

--- a/trunk/src/Lexer.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1773 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module Lexer;
-import Token;
-import Information;
-import Keywords;
-import Identifier;
-import Messages;
-import HtmlEntities;
-import std.stdio;
-import std.utf;
-import std.uni;
-import std.c.stdlib;
-import std.string;
-
-const char[3] LS = \u2028;
-const char[3] PS = \u2029;
-
-const dchar LSd = 0x2028;
-const dchar PSd = 0x2029;
-
-const uint _Z_ = 26; /// Control+Z
-
-class Lexer
-{
-  Token* head; /// The head of the doubly linked token list.
-  Token* token; /// Points to the current token in the token list.
-  string text;
-  char* p; /// Points to the current character in the source text.
-  char* end; /// Points one character past the end of the source text.
-
-  uint loc = 1; /// line of code
-
-  char[] fileName;
-
-  Information[] errors;
-
-//   bool reportErrors;
-
-  Identifier[string] idtable;
-
-  this(string text, string fileName)
-  {
-    this.fileName = fileName;
-
-    this.text = text;
-    if (text[$-1] != 0)
-    {
-      this.text.length = this.text.length + 1;
-      this.text[$-1] = 0;
-    }
-
-    this.p = this.text.ptr;
-    this.end = this.p + this.text.length;
-//     this.reportErrors = true;
-    loadKeywords();
-
-    this.head = new Token;
-    this.head.type = TOK.HEAD;
-    this.token = this.head;
-    scanShebang();
-  }
-
-  void scanShebang()
-  {
-    if (*p == '#' && p[1] == '!')
-    {
-      Token* t = new Token;
-      t.start = p;
-      t.type = TOK.Shebang;
-      ++p;
-      while (1)
-      {
-        switch (*++p)
-        {
-        case '\r':
-          if (p[1] == '\n')
-            ++p;
-        case '\n':
-          ++loc;
-          if (p[-1] == '\r')
-            t.end = p-1;
-          else
-            t.end = p;
-          break;
-        case LS[0]:
-          t.end = p;
-          if (p[1] == LS[1] && (p[2] == LS[2] || p[2] == PS[2]))
-          {
-            ++p; ++p;
-            ++loc;
-          }
-          break;
-        case 0, _Z_:
-          t.end = p;
-          break;
-        default:
-          continue;
-        }
-        break; // Exit loop.
-      }
-      this.head.next = t;
-      t.prev = this.head;
-    }
-  }
-
-  public void scan(out Token t)
-  in
-  {
-    assert(text.ptr <= p && p < end);
-  }
-  out
-  {
-    assert(text.ptr <= t.start && t.start < end);
-    assert(text.ptr < t.end && t.end <= end, std.string.format(t.type));
-  }
-  body
-  {
-    uint c = *p;
-
-    while (1)
-    {
-      t.start = p;
-
-      if (c == 0 || c == _Z_)
-      {
-        assert(*p == 0 || *p == _Z_);
-        t.type = TOK.EOF;
-        t.end = p;
-        assert(t.start == t.end);
-        return;
-      }
-
-      if (c == '\n')
-      {
-        c = *++p;
-        ++loc;
-        continue;
-      }
-      else if (c == '\r')
-      {
-        c = *++p;
-        if (c != '\n')
-          ++loc;
-        continue;
-      }
-      else if (c == LS[0] && p[1] == LS[1] && (p[2] == LS[2] || p[2] == PS[2]))
-      {
-        p += 3;
-        c = *p;
-        continue;
-      }
-
-      if (isidbeg(c))
-      {
-        if (c == 'r' && p[1] == '"' && ++p)
-          return scanRawStringLiteral(t);
-        if (c == 'x' && p[1] == '"')
-          return scanHexStringLiteral(t);
-      Lidentifier:
-        do
-        { c = *++p; }
-        while (isident(c) || c & 128 && isUniAlpha(decodeUTF8()))
-
-        t.end = p;
-
-        string str = t.srcText;
-        Identifier* id = str in idtable;
-
-        if (!id)
-        {
-          idtable[str] = Identifier.Identifier(TOK.Identifier, str);
-          id = str in idtable;
-        }
-        assert(id);
-        t.type = id.type;
-        return;
-      }
-
-      if (isdigit(c))
-        return scanNumber(t);
-
-      if (c == '/')
-      {
-        c = *++p;
-        switch(c)
-        {
-        case '=':
-          ++p;
-          t.type = TOK.DivAssign;
-          t.end = p;
-          return;
-        case '+':
-          uint level = 1;
-          while (1)
-          {
-            c = *++p;
-          LswitchNC: // only jumped to from default case of next switch(c)
-            switch (c)
-            {
-            case '\r':
-              if (p[1] == '\n')
-                ++p;
-            case '\n':
-              ++loc;
-              continue;
-            case 0, _Z_:
-              error(MID.UnterminatedNestedComment);
-              goto LreturnNC;
-            default:
-            }
-
-            c <<= 8;
-            c |= *++p;
-            switch (c)
-            {
-            case 0x2F2B: // /+
-              ++level;
-              continue;
-            case 0x2B2F: // +/
-              if (--level == 0)
-              {
-                ++p;
-              LreturnNC:
-                t.type = TOK.Comment;
-                t.end = p;
-                return;
-              }
-              continue;
-            case 0xE280: // LS[0..1] || PS[0..1]
-              if (p[1] == LS[2] || p[1] == PS[2])
-              {
-                ++loc;
-                ++p;
-              }
-              continue;
-            default:
-              c &= char.max;
-              goto LswitchNC;
-            }
-          }
-        case '*':
-          while (1)
-          {
-            c = *++p;
-          LswitchBC: // only jumped to from default case of next switch(c)
-            switch (c)
-            {
-            case '\r':
-              if (p[1] == '\n')
-                ++p;
-            case '\n':
-              ++loc;
-              continue;
-            case 0, _Z_:
-              error(MID.UnterminatedBlockComment);
-              goto LreturnBC;
-            default:
-            }
-
-            c <<= 8;
-            c |= *++p;
-            switch (c)
-            {
-            case 0x2A2F: // */
-              ++p;
-            LreturnBC:
-              t.type = TOK.Comment;
-              t.end = p;
-              return;
-            case 0xE280: // LS[0..1] || PS[0..1]
-              if (p[1] == LS[2] || p[1] == PS[2])
-              {
-                ++loc;
-                ++p;
-              }
-              continue;
-            default:
-              c &= char.max;
-              goto LswitchBC;
-            }
-          }
-          assert(0);
-        case '/':
-          while (1)
-          {
-            c = *++p;
-            switch (c)
-            {
-            case '\r':
-              if (p[1] == '\n')
-                ++p;
-            case '\n':
-            case 0, _Z_:
-              break;
-            case LS[0]:
-              if (p[1] == LS[1] && (p[2] == LS[2] || p[2] == PS[2]))
-                break;
-              continue;
-            default:
-              continue;
-            }
-            t.type = TOK.Comment;
-            t.end = p;
-            return;
-          }
-        default:
-          t.type = TOK.Div;
-          t.end = p;
-          return;
-        }
-      }
-
-      switch (c)
-      {
-      case '\'':
-        return scanCharacterLiteral(t);
-      case '`':
-        return scanRawStringLiteral(t);
-      case '"':
-        return scanNormalStringLiteral(t);
-      case '\\':
-        char[] buffer;
-        do
-        {
-          ++p;
-          c = scanEscapeSequence();
-          if (c < 128)
-            buffer ~= c;
-          else
-            encodeUTF8(buffer, c);
-        } while (*p == '\\')
-        buffer ~= 0;
-        t.type = TOK.String;
-        t.str = buffer;
-        t.end = p;
-        return;
-      case '>': /* >  >=  >>  >>=  >>>  >>>= */
-        c = *++p;
-        switch (c)
-        {
-        case '=':
-          t.type = TOK.GreaterEqual;
-          goto Lcommon;
-        case '>':
-          if (p[1] == '>')
-          {
-            ++p;
-            if (p[1] == '=')
-            { ++p;
-              t.type = TOK.URShiftAssign;
-            }
-            else
-              t.type = TOK.URShift;
-          }
-          else if (p[1] == '=')
-          {
-            ++p;
-            t.type = TOK.RShiftAssign;
-          }
-          else
-            t.type = TOK.RShift;
-          goto Lcommon;
-        default:
-          t.type = TOK.Greater;
-          goto Lcommon2;
-        }
-        assert(0);
-      case '<': /* <  <=  <>  <>=  <<  <<= */
-        c = *++p;
-        switch (c)
-        {
-        case '=':
-          t.type = TOK.LessEqual;
-          goto Lcommon;
-        case '<':
-          if (p[1] == '=') {
-            ++p;
-            t.type = TOK.LShiftAssign;
-          }
-          else
-            t.type = TOK.LShift;
-          goto Lcommon;
-        case '>':
-          if (p[1] == '=') {
-            ++p;
-            t.type = TOK.LorEorG;
-          }
-          else
-            t.type = TOK.LorG;
-          goto Lcommon;
-        default:
-          t.type = TOK.Less;
-          goto Lcommon2;
-        }
-        assert(0);
-      case '!': /* !  !<  !>  !<=  !>=  !<>  !<>= */
-        c = *++p;
-        switch (c)
-        {
-        case '<':
-          c = *++p;
-          if (c == '>')
-          {
-            if (p[1] == '=') {
-              ++p;
-              t.type = TOK.Unordered;
-            }
-            else
-              t.type = TOK.UorE;
-          }
-          else if (c == '=')
-          {
-            t.type = TOK.UorG;
-          }
-          else {
-            t.type = TOK.UorGorE;
-            goto Lcommon2;
-          }
-          goto Lcommon;
-        case '>':
-          if (p[1] == '=')
-          {
-            ++p;
-            t.type = TOK.UorL;
-          }
-          else
-            t.type = TOK.UorLorE;
-          goto Lcommon;
-        case '=':
-          t.type = TOK.NotEqual;
-          goto Lcommon;
-        default:
-          t.type = TOK.Not;
-          goto Lcommon2;
-        }
-        assert(0);
-      case '.': /* .  .[0-9]  ..  ... */
-        if (p[1] == '.')
-        {
-          ++p;
-          if (p[1] == '.') {
-            ++p;
-            t.type = TOK.Ellipses;
-          }
-          else
-            t.type = TOK.Slice;
-        }
-        else if (isdigit(p[1]))
-        {
-          return scanReal(t);
-        }
-        else
-          t.type = TOK.Dot;
-        goto Lcommon;
-      case '|': /* |  ||  |= */
-        c = *++p;
-        if (c == '=')
-          t.type = TOK.OrAssign;
-        else if (c == '|')
-          t.type = TOK.OrLogical;
-        else {
-          t.type = TOK.OrBinary;
-          goto Lcommon2;
-        }
-        goto Lcommon;
-      case '&': /* &  &&  &= */
-        c = *++p;
-        if (c == '=')
-          t.type = TOK.AndAssign;
-        else if (c == '&')
-          t.type = TOK.AndLogical;
-        else {
-          t.type = TOK.AndBinary;
-          goto Lcommon2;
-        }
-        goto Lcommon;
-      case '+': /* +  ++  += */
-        c = *++p;
-        if (c == '=')
-          t.type = TOK.PlusAssign;
-        else if (c == '+')
-          t.type = TOK.PlusPlus;
-        else {
-          t.type = TOK.Plus;
-          goto Lcommon2;
-        }
-        goto Lcommon;
-      case '-': /* -  --  -= */
-        c = *++p;
-        if (c == '=')
-          t.type = TOK.MinusAssign;
-        else if (c == '-')
-          t.type = TOK.MinusMinus;
-        else {
-          t.type = TOK.Minus;
-          goto Lcommon2;
-        }
-        goto Lcommon;
-      case '=': /* =  == */
-        if (p[1] == '=') {
-          ++p;
-          t.type = TOK.Equal;
-        }
-        else
-          t.type = TOK.Assign;
-        goto Lcommon;
-      case '~': /* ~  ~= */
-         if (p[1] == '=') {
-           ++p;
-           t.type = TOK.CatAssign;
-         }
-         else
-           t.type = TOK.Tilde;
-         goto Lcommon;
-      case '*': /* *  *= */
-         if (p[1] == '=') {
-           ++p;
-           t.type = TOK.MulAssign;
-         }
-         else
-           t.type = TOK.Mul;
-         goto Lcommon;
-      case '^': /* ^  ^= */
-         if (p[1] == '=') {
-           ++p;
-           t.type = TOK.XorAssign;
-         }
-         else
-           t.type = TOK.Xor;
-         goto Lcommon;
-      case '%': /* %  %= */
-         if (p[1] == '=') {
-           ++p;
-           t.type = TOK.ModAssign;
-         }
-         else
-           t.type = TOK.Mod;
-         goto Lcommon;
-      // Single character tokens:
-      case '(':
-        t.type = TOK.LParen;
-        goto Lcommon;
-      case ')':
-        t.type = TOK.RParen;
-        goto Lcommon;
-      case '[':
-        t.type = TOK.LBracket;
-        goto Lcommon;
-      case ']':
-        t.type = TOK.RBracket;
-        goto Lcommon;
-      case '{':
-        t.type = TOK.LBrace;
-        goto Lcommon;
-      case '}':
-        t.type = TOK.RBrace;
-        goto Lcommon;
-      case ':':
-        t.type = TOK.Colon;
-        goto Lcommon;
-      case ';':
-        t.type = TOK.Semicolon;
-        goto Lcommon;
-      case '?':
-        t.type = TOK.Question;
-        goto Lcommon;
-      case ',':
-        t.type = TOK.Comma;
-        goto Lcommon;
-      case '$':
-        t.type = TOK.Dollar;
-      Lcommon:
-        ++p;
-      Lcommon2:
-        t.end = p;
-        return;
-      case '#':
-        return scanSpecialToken(t);
-      default:
-      }
-
-      if (c & 128 && isUniAlpha(decodeUTF8()))
-        goto Lidentifier;
-      c = *++p;
-    }
-  }
-
-  void scanNormalStringLiteral(ref Token t)
-  {
-    assert(*p == '"');
-    ++p;
-    char[] buffer;
-    t.type = TOK.String;
-    while (1)
-    {
-      switch (*p)
-      {
-      case '"':
-        ++p;
-      Lreturn:
-        buffer ~= 0;
-        t.str = buffer;
-        t.pf = scanPostfix();
-        t.end = p;
-        return;
-      case '\\':
-        ++p;
-        dchar d = scanEscapeSequence();
-        if (d < 128)
-          buffer ~= d;
-        else
-          encodeUTF8(buffer, d);
-        continue;
-      case '\r':
-        if (p[1] == '\n')
-          ++p;
-      case '\n':
-        ++p;
-        ++loc;
-        buffer ~= '\n'; // Convert EndOfLine to \n.
-        continue;
-      case 0, _Z_:
-        error(MID.UnterminatedString);
-        goto Lreturn;
-      default:
-        if (*p & 128)
-        {
-//           char* begin = p;
-          dchar d = decodeUTF8();
-          if (d == LSd || d == PSd)
-            goto case '\n';
-
-          // We don't copy per pointer because we might include
-          // invalid, skipped utf-8 sequences. See decodeUTF8().
-//           ++p;
-//           buffer ~= begin[0 .. p - begin];
-          ++p;
-          encodeUTF8(buffer, d);
-          continue;
-        }
-        // Copy ASCII character.
-        buffer ~= *p++;
-      }
-    }
-    assert(0);
-  }
-
-  void scanCharacterLiteral(ref Token t)
-  {
-    assert(*p == '\'');
-    MID id = MID.UnterminatedCharacterLiteral;
-    ++p;
-    TOK type = TOK.CharLiteral;
-    switch (*p)
-    {
-    case '\\':
-      ++p;
-      switch (*p)
-      {
-      case 'u':
-        type = TOK.WCharLiteral; break;
-      case 'U':
-        type = TOK.DCharLiteral; break;
-      default:
-      }
-      t.dchar_ = scanEscapeSequence();
-      break;
-    case '\'':
-      ++p;
-      id = MID.EmptyCharacterLiteral;
-    case '\n', '\r', 0, _Z_:
-      goto Lerr;
-    default:
-      uint c = *p;
-      if (c & 128)
-      {
-        c = decodeUTF8();
-        if (c == LSd || c == PSd)
-          goto Lerr;
-        if (c <= 0xFFFF)
-          type = TOK.WCharLiteral;
-        else
-          type = TOK.DCharLiteral;
-      }
-      t.dchar_ = c;
-      ++p;
-    }
-
-    if (*p == '\'')
-      ++p;
-    else
-    Lerr:
-      error(id);
-    t.type = type;
-    t.end = p;
-  }
-
-  char scanPostfix()
-  {
-    switch (*p)
-    {
-    case 'c':
-    case 'w':
-    case 'd':
-      return *p++;
-    default:
-      return 0;
-    }
-    assert(0);
-  }
-
-  void scanRawStringLiteral(ref Token t)
-  {
-    uint delim = *p;
-    assert(delim == '`' || delim == '"' && p[-1] == 'r');
-    t.type = TOK.String;
-    char[] buffer;
-    uint c;
-    while (1)
-    {
-      c = *++p;
-      switch (c)
-      {
-      case '\r':
-        if (p[1] == '\n')
-          ++p;
-        c = '\n'; // Convert '\r' and '\r\n' to '\n'
-      case '\n':
-        ++loc;
-        break;
-      case '`':
-      case '"':
-        if (c == delim)
-        {
-          ++p;
-          t.pf = scanPostfix();
-        Lreturn:
-          t.str = buffer ~ '\0';
-          t.end = p;
-          return;
-        }
-        break;
-      case LS[0]:
-        if (p[1] == LS[1] && (p[2] == LS[2] || p[2] == PS[2]))
-        {
-          c = '\n';
-          ++p; ++p;
-          ++loc;
-        }
-        break;
-      case 0, _Z_:
-        if (delim == 'r')
-          error(MID.UnterminatedRawString);
-        else
-          error(MID.UnterminatedBackQuoteString);
-        goto Lreturn;
-      default:
-      }
-      buffer ~= c; // copy character to buffer
-    }
-    assert(0);
-  }
-
-  void scanHexStringLiteral(ref Token t)
-  {
-    assert(p[0] == 'x' && p[1] == '"');
-    t.type = TOK.String;
-
-    uint c;
-    ubyte[] buffer;
-    ubyte h; // hex number
-    uint n; // number of hex digits
-
-    ++p;
-    while (1)
-    {
-      c = *++p;
-      switch (c)
-      {
-      case '"':
-        ++p;
-        if (n & 1)
-          error(MID.OddNumberOfDigitsInHexString);
-        t.pf = scanPostfix();
-      Lreturn:
-        buffer ~= 0;
-        t.str = cast(string) buffer;
-        t.end = p;
-        return;
-      case '\r':
-        if (p[1] == '\n')
-          ++p;
-      case '\n':
-        ++loc;
-        continue;
-      default:
-        if (ishexad(c))
-        {
-          if (c <= '9')
-            c -= '0';
-          else if (c <= 'F')
-            c -= 'A' - 10;
-          else
-            c -= 'a' - 10;
-
-          if (n & 1)
-          {
-            h <<= 4;
-            h |= c;
-            buffer ~= h;
-          }
-          else
-            h = cast(ubyte)c;
-          ++n;
-          continue;
-        }
-        else if (isspace(c))
-          continue;
-
-        if (c >= 128)
-        {
-          c = decodeUTF8();
-          if (c == LSd || c == PSd)
-          {
-            ++p; ++p;
-            ++loc;
-            continue;
-          }
-        }
-        else if (c == 0 || c == _Z_)
-        {
-          error(MID.UnterminatedHexString);
-          t.pf = 0;
-          goto Lreturn;
-        }
-        error(MID.NonHexCharInHexString, cast(dchar)c);
-      }
-    }
-    assert(0);
-  }
-
-  dchar scanEscapeSequence()
-  {
-    uint c = char2ev(*p);
-    if (c)
-    {
-      ++p;
-      return c;
-    }
-    uint digits = 2;
-
-    switch (*p)
-    {
-    case 'x':
-      c = 0;
-      while (1)
-      {
-        ++p;
-        if (ishexad(*p))
-        {
-          c *= 16;
-          if (*p <= '9')
-            c += *p - '0';
-          else if (*p <= 'F')
-            c += *p - 'A' + 10;
-          else
-            c += *p - 'a' + 10;
-
-          if (!--digits)
-          {
-            ++p;
-            break;
-          }
-        }
-        else
-        {
-          error(MID.InsufficientHexDigits);
-          break;
-        }
-      }
-      if (!isValidDchar(c))
-        error(MID.InvalidUnicodeCharacter);
-      break;
-    case 'u':
-      digits = 4;
-      goto case 'x';
-    case 'U':
-      digits = 8;
-      goto case 'x';
-    default:
-      if (isoctal(*p))
-      {
-        c = 0;
-        c += *p - '0';
-        ++p;
-        if (!isoctal(*p))
-          return c;
-        c *= 8;
-        c += *p - '0';
-        ++p;
-        if (!isoctal(*p))
-          return c;
-        c *= 8;
-        c += *p - '0';
-        ++p;
-      }
-      else if(*p == '&')
-      {
-        if (isalpha(*++p))
-        {
-          auto begin = p;
-          while (isalnum(*++p))
-          {}
-
-          if (*p == ';')
-          {
-            c = entity2Unicode(begin[0..p - begin]);
-            ++p;
-            if (c == 0xFFFF)
-              error(MID.UndefinedHTMLEntity, (begin-1)[0..p-(begin-1)]);
-          }
-          else
-            error(MID.UnterminatedHTMLEntity);
-        }
-        else
-          error(MID.InvalidBeginHTMLEntity);
-      }
-      else
-        error(MID.UndefinedEscapeSequence);
-    }
-
-    return c;
-  }
-
-  /*
-    IntegerLiteral:= (Dec|Hex|Bin|Oct)Suffix?
-    Dec:= (0|[1-9][0-9_]*)
-    Hex:= 0[xX] HexDigits
-    Bin:= 0[bB][01_]+
-    Oct:= 0[0-7_]+
-    Suffix:= (L[uU]?|[uU]L?)
-    HexDigits:= [0-9a-zA-Z_]+
-
-    Invalid: "0b_", "0x_", "._"
-  */
-  void scanNumber(ref Token t)
-  {
-    ulong ulong_;
-    bool overflow;
-    bool isDecimal;
-    size_t digits;
-
-    if (*p != '0')
-      goto LscanInteger;
-    ++p; // skip zero
-    // check for xX bB ...
-    switch (*p)
-    {
-    case 'x','X':
-      goto LscanHex;
-    case 'b','B':
-      goto LscanBin;
-    case 'L':
-      if (p[1] == 'i')
-        goto LscanReal;
-    case '.':
-      if (p[1] == '.')
-        break;
-    case 'i','f','F', 'e', 'E': // Imaginary and float literal suffix
-      goto LscanReal;
-    default:
-      if (*p == '_' || isoctal(*p))
-        goto LscanOct;
-    }
-
-    // Number 0
-    assert(p[-1] == '0');
-    assert(ulong_ == 0);
-    isDecimal = true;
-    goto Lfinalize;
-
-  LscanInteger:
-    assert(*p != 0 && isdigit(*p));
-    isDecimal = true;
-    goto Lenter_loop_int;
-    while (1)
-    {
-      if (*++p == '_')
-        continue;
-      if (!isdigit(*p))
-        break;
-    Lenter_loop_int:
-      if (ulong_ < ulong.max/10 || (ulong_ == ulong.max/10 && *p <= '5'))
-      {
-        ulong_ *= 10;
-        ulong_ += *p - '0';
-        continue;
-      }
-      // Overflow: skip following digits.
-      overflow = true;
-      while (isdigit(*++p)) {}
-      break;
-    }
-
-    // The number could be a float, so check overflow below.
-    switch (*p)
-    {
-    case '.':
-      if (p[1] != '.')
-        goto LscanReal;
-      break;
-    case 'L':
-      if (p[1] != 'i')
-        break;
-    case 'i', 'f', 'F', 'e', 'E':
-      goto LscanReal;
-    default:
-    }
-
-    if (overflow)
-      error(MID.OverflowDecimalNumber);
-
-    assert((isdigit(p[-1]) || p[-1] == '_') && !isdigit(*p) && *p != '_');
-    goto Lfinalize;
-
-  LscanHex:
-    assert(digits == 0);
-    assert(*p == 'x');
-    while (1)
-    {
-      if (*++p == '_')
-        continue;
-      if (!ishexad(*p))
-        break;
-      ++digits;
-      ulong_ *= 16;
-      if (*p <= '9')
-        ulong_ += *p - '0';
-      else if (*p <= 'F')
-        ulong_ += *p - 'A' + 10;
-      else
-        ulong_ += *p - 'a' + 10;
-    }
-
-    switch (*p)
-    {
-    case '.':
-      if (p[1] != '.')
-        goto LscanHexReal;
-      break;
-    case 'L':
-      if (p[1] != 'i')
-        break;
-    case 'i', 'p', 'P':
-      goto LscanHexReal;
-    default:
-    }
-    if (digits == 0)
-      error(MID.NoDigitsInHexNumber);
-    else if (digits > 16)
-    {
-      // Overflow: skip following digits.
-      error(MID.OverflowHexNumber);
-      while (ishexad(*++p)) {}
-    }
-    goto Lfinalize;
-  LscanHexReal:
-    return scanHexReal(t);
-
-  LscanBin:
-    assert(digits == 0);
-    assert(*p == 'b');
-    while (1)
-    {
-      if (*++p == '0')
-      {
-        ++digits;
-        ulong_ *= 2;
-      }
-      if (*p == '1')
-      {
-        ++digits;
-        ulong_ *= 2;
-        ulong_ += *p - '0';
-      }
-      if (*p == '_')
-        continue;
-      break;
-    }
-
-    if (digits == 0)
-      error(MID.NoDigitsInBinNumber);
-
-    if (digits > 64)
-      error(MID.OverflowBinaryNumber);
-    assert((p[-1] == '0' || p[-1] == '1' || p[-1] == '_') && !(*p == '0' || *p == '1' || *p == '_'));
-    goto Lfinalize;
-
-  LscanOct:
-    assert(*p == '_' || isoctal(*p));
-    if (*p != '_')
-      goto Lenter_loop_oct;
-    while (1)
-    {
-      if (*++p == '_')
-        continue;
-      if (!isoctal(*p))
-        break;
-    Lenter_loop_oct:
-      if (ulong_ < ulong.max/2 || (ulong_ == ulong.max/2 && *p <= '1'))
-      {
-        ulong_ *= 8;
-        ulong_ += *p - '0';
-        ++p;
-        continue;
-      }
-      // Overflow: skip following digits.
-      overflow = true;
-      while (isdigit(*++p)) {}
-      break;
-    }
-
-    bool hasDecimalDigits;
-    if (isdigit(*p))
-    {
-      hasDecimalDigits = true;
-      while (isdigit(*++p)) {}
-    }
-
-    // The number could be a float, so check errors below.
-    switch (*p)
-    {
-    case '.':
-      if (p[1] != '.')
-        goto LscanReal;
-      break;
-    case 'L':
-      if (p[1] != 'i')
-        break;
-    case 'i', 'f', 'F', 'e', 'E':
-      goto LscanReal;
-    default:
-    }
-
-    if (hasDecimalDigits)
-      error(MID.OctalNumberHasDecimals);
-    if (overflow)
-      error(MID.OverflowOctalNumber);
-//     goto Lfinalize;
-
-  Lfinalize:
-    enum Suffix
-    {
-      None     = 0,
-      Unsigned = 1,
-      Long     = 2
-    }
-
-    Suffix suffix;
-    while (1)
-    {
-      switch (*p)
-      {
-      case 'L':
-        if (suffix & Suffix.Long)
-          break;
-        suffix |= Suffix.Long;
-        ++p;
-        continue;
-      case 'u', 'U':
-        if (suffix & Suffix.Unsigned)
-          break;
-        suffix |= Suffix.Unsigned;
-        ++p;
-        continue;
-      default:
-        break;
-      }
-      break;
-    }
-
-    switch (suffix)
-    {
-    case Suffix.None:
-      if (ulong_ & 0x8000000000000000)
-      {
-        if (isDecimal)
-          error(MID.OverflowDecimalSign);
-        t.type = TOK.Uint64;
-      }
-      else if (ulong_ & 0xFFFFFFFF00000000)
-        t.type = TOK.Int64;
-      else if (ulong_ & 0x80000000)
-        t.type = isDecimal ? TOK.Int64 : TOK.Uint32;
-      else
-        t.type = TOK.Int32;
-      break;
-    case Suffix.Unsigned:
-      if (ulong_ & 0xFFFFFFFF00000000)
-        t.type = TOK.Uint64;
-      else
-        t.type = TOK.Uint32;
-      break;
-    case Suffix.Long:
-      if (ulong_ & 0x8000000000000000)
-      {
-        if (isDecimal)
-          error(MID.OverflowDecimalSign);
-        t.type = TOK.Uint64;
-      }
-      else
-        t.type = TOK.Int64;
-      break;
-    case Suffix.Unsigned | Suffix.Long:
-      t.type = TOK.Uint64;
-      break;
-    default:
-      assert(0);
-    }
-    t.ulong_ = ulong_;
-    t.end = p;
-    return;
-  LscanReal:
-    scanReal(t);
-    return;
-  }
-
-  /*
-    FloatLiteral:= Float[fFL]?i?
-    Float:= DecFloat | HexFloat
-    DecFloat:= ([0-9][0-9_]*[.][0-9_]*DecExponent?) | [.][0-9][0-9_]*DecExponent? | [0-9][0-9_]*DecExponent
-    DecExponent:= [eE][+-]?[0-9][0-9_]*
-    HexFloat:= 0[xX](HexDigits[.]HexDigits | [.][0-9a-zA-Z]HexDigits? | HexDigits)HexExponent
-    HexExponent:= [pP][+-]?[0-9][0-9_]*
-  */
-  void scanReal(ref Token t)
-  {
-    if (*p == '.')
-      // This function was called by scan() or scanNumber().
-      while (isdigit(*++p) || *p == '_') {}
-    else
-    {
-      // This function was called by scanNumber().
-      debug switch (*p)
-      {
-      case 'L':
-        if (p[1] != 'i')
-          assert(0);
-      case 'i', 'f', 'F', 'e', 'E': break;
-      default: assert(0);
-      }
-    }
-
-    // Scan exponent.
-    if (*p == 'e' || *p == 'E')
-    {
-      ++p;
-      if (*p == '-' || *p == '+')
-        ++p;
-      if (!isdigit(*p))
-        error(MID.FloatExponentDigitExpected);
-      else
-        while (isdigit(*++p) || *p == '_') {}
-    }
-
-    // Copy string to buffer ignoring underscores.
-    char[] buffer;
-    char* end = p;
-    p = t.start;
-    do
-    {
-      if (*p == '_')
-      {
-        ++p;
-        continue;
-      }
-      buffer ~= *p;
-      ++p;
-    } while (p != end)
-    buffer ~= 0;
-    finalizeFloat(t, buffer);
-  }
-
-  void scanHexReal(ref Token t)
-  {
-    assert(*p == '.' || *p == 'i' || *p == 'p' || *p == 'P' || (*p == 'L' && p[1] == 'i'));
-    MID mid;
-    if (*p == '.')
-      while (ishexad(*++p) || *p == '_') {}
-    if (*p != 'p' && *p != 'P')
-    {
-      mid = MID.HexFloatExponentRequired;
-      goto Lerr;
-    }
-    // Copy mantissa to a buffer ignoring underscores.
-    char* end = p;
-    p = t.start;
-    char[] buffer;
-    do
-    {
-      if (*p == '_')
-      {
-        ++p;
-        continue;
-      }
-      buffer ~= *p;
-      ++p;
-    } while (p != end)
-
-    assert(p == end && (*p == 'p' || *p == 'P'));
-    // Scan and copy the exponent.
-    buffer ~= 'p';
-    size_t bufflen = buffer.length;
-    while (1)
-    {
-      if (*++p == '_')
-        continue;
-      if (isdigit(*p))
-        buffer ~= *p;
-      else
-        break;
-    }
-    // When the buffer length hasn't changed, no digits were copied.
-    if (bufflen == buffer.length) {
-      mid = MID.HexFloatMissingExpDigits;
-      goto Lerr;
-    }
-    buffer ~= 0; // Terminate for C functions.
-    finalizeFloat(t, buffer);
-    return;
-  Lerr:
-    t.type = TOK.Float32;
-    t.end = p;
-    error(mid);
-  }
-
-  void finalizeFloat(ref Token t, string buffer)
-  {
-    // Float number is well-formed. Check suffixes and do conversion.
-    switch (*p)
-    {
-    case 'f', 'F':
-      t.type = TOK.Float32;
-      t.float_ = strtof(buffer.ptr, null);
-      ++p;
-      break;
-    case 'L':
-      t.type = TOK.Float80;
-      t.real_ = strtold(buffer.ptr, null);
-      ++p;
-      break;
-    default:
-      t.type = TOK.Float64;
-      t.double_ = strtod(buffer.ptr, null);
-      break;
-    }
-    if (*p == 'i')
-    {
-      ++p;
-      t.type += 3; // Switch to imaginary counterpart.
-    }
-    if (getErrno == ERANGE)
-      error(MID.OverflowFloatNumber);
-    t.end = p;
-  }
-
-  /// Scan special token: #line Integer [Filespec] EndOfLine
-  void scanSpecialToken(ref Token t)
-  {
-    assert(*p == '#');
-
-    t.type = TOK.HashLine;
-
-    MID mid;
-
-    ++p;
-    if (p[0] != 'l' || p[1] != 'i' || p[2] != 'n' || p[3] != 'e')
-    {
-      mid = MID.ExpectedNumberAfterSTLine;
-      goto Lerr;
-    }
-    p += 3;
-
-    enum State
-    { Number, Filespec, End }
-
-    State state;
-
-  Loop:
-    while (1)
-    {
-      switch (*++p)
-      {
-      case '\r':
-        if (p[1] == '\n')
-          ++p;
-      case '\n', 0, _Z_:
-        break Loop;
-      case LS[0]:
-        if (p[1] == LS[1] && (p[2] == LS[2] || p[2] == PS[2]))
-        {
-          ++p; ++p;
-          break Loop;
-        }
-        goto default;
-      default:
-        if (isspace(*p))
-          continue;
-        if (state == State.Number)
-        {
-          if (!isdigit(*p))
-          {
-            mid = MID.ExpectedNumberAfterSTLine;
-            goto Lerr;
-          }
-          t.line_num = new Token;
-          scan(*t.line_num);
-          --p;
-          state = State.Filespec;
-        }
-        else if (state == State.Filespec)
-        {
-          if (*p != '"')
-          {
-            mid = MID.ExpectedFilespec;
-            goto Lerr;
-          }
-          t.line_filespec = new Token;
-          t.line_filespec.start = p;
-          t.line_filespec.type = TOK.Filespec;
-          while (1)
-          {
-            switch (*++p)
-            {
-            case '"':
-              break;
-            case LS[0]:
-              if (!(p[1] == LS[1] && (p[2] == LS[2] || p[2] == PS[2])))
-                goto default;
-            case '\r', '\n', 0, _Z_:
-              mid = MID.UnterminatedFilespec;
-              t.line_filespec.end = p;
-              goto Lerr;
-            default:
-              if (*p & 128)
-                decodeUTF8();
-              continue;
-            }
-            break; // Exit loop.
-          }
-          auto start = t.line_filespec.start +1; // +1 skips '"'
-          t.line_filespec.str = start[0 .. p - start];
-          t.line_filespec.end = p + 1;
-          state = State.End;
-        }
-        else/+ if (state == State.End)+/
-        {
-          mid = MID.UnterminatedSpecialToken;
-          goto Lerr;
-        }
-      }
-    }
-
-    if (state == State.Number)
-    {
-      mid = MID.ExpectedNumberAfterSTLine;
-      goto Lerr;
-    }
-
-    this.loc = t.line_num.uint_ - 1;
-    if (t.line_filespec)
-      this.fileName = t.line_filespec.str;
-    t.end = p;
-
-    return;
-  Lerr:
-    t.end = p;
-    error(mid);
-  }
-
-  dchar decodeUTF8()
-  {
-    assert(*p & 128, "check for ASCII char before calling decodeUTF8().");
-    size_t idx;
-    dchar d;
-    try
-    {
-      d = std.utf.decode(p[0 .. end-p], idx);
-      p += idx -1;
-    }
-    catch (UtfException e)
-    {
-      error(MID.InvalidUTF8Sequence);
-      // Skip to next valid utf-8 sequence
-      while (UTF8stride[*++p] != 0xFF) {}
-      --p;
-    }
-    return d;
-  }
-
-  void loadKeywords()
-  {
-    foreach(k; keywords)
-      idtable[k.str] = k;
-  }
-/+
-  struct State
-  {
-    Lexer lexer;
-    Token token;
-    char* scanPointer;
-    int loc;
-    string fileName;
-    size_t errorLen;
-    static State opCall(Lexer lx)
-    {
-      State s;
-      s.lexer = lx;
-      s.token = lx.token;
-      s.scanPointer = lx.p;
-      s.loc = lx.loc;
-      s.fileName = lx.fileName;
-      s.errorLen = lx.errors.length;
-      return s;
-    }
-    void restore()
-    {
-      lexer.p = scanPointer;
-      lexer.token = token;
-      lexer.loc = loc;
-      lexer.fileName = fileName;
-      lexer.errors = lexer.errors[0..errorLen];
-    }
-  }
-
-  State getState()
-  {
-    return State(this);
-  }
-+/
-
-  private void scanNext(ref Token* t)
-  {
-    assert(t !is null);
-    if (t.next)
-      t = t.next;
-    else if (t.type != TOK.EOF)
-    {
-      Token* new_t = new Token;
-      scan(*new_t);
-      new_t.prev = t;
-      t.next = new_t;
-      t = new_t;
-    }
-  }
-
-  void peek(ref Token* t)
-  {
-    scanNext(t);
-  }
-
-  TOK nextToken()
-  {
-    scanNext(this.token);
-    return this.token.type;
-  }
-
-  void error(MID id, ...)
-  {
-//     if (reportErrors)
-    errors ~= new Information(InfoType.Lexer, id, loc, arguments(_arguments, _argptr));
-  }
-
-  unittest
-  {
-    string sourceText = "unittest { }";
-    auto lx = new Lexer(sourceText, null);
-
-    Token next;
-    lx.peek(next);
-    assert(next == TOK.Unittest);
-    lx.peek(next);
-    assert(next == TOK.LBrace);
-    lx.peek(next);
-    assert(next == TOK.RBrace);
-    lx.peek(next);
-    assert(next == TOK.EOF);
-    writefln("end of peek() unittest");
-  }
-
-  Token* getTokens()
-  {
-    while (nextToken() != TOK.EOF)
-    {}
-    return head;
-  }
-
-  private void encodeUTF8(inout char[] str, dchar d)
-  {
-    char[6] b;
-    assert(d > 0x7F, "check for ASCII char before calling encodeUTF8().");
-    if (d < 0x800)
-    {
-      b[0] = 0xC0 | (d >> 6);
-      b[1] = 0x80 | (d & 0x3F);
-      str ~= b[0..2];
-    }
-    else if (d < 0x10000)
-    {
-      b[0] = 0xE0 | (d >> 12);
-      b[1] = 0x80 | ((d >> 6) & 0x3F);
-      b[2] = 0x80 | (d & 0x3F);
-      str ~= b[0..3];
-    }
-    else if (d < 0x200000)
-    {
-      b[0] = 0xF0 | (d >> 18);
-      b[1] = 0x80 | ((d >> 12) & 0x3F);
-      b[2] = 0x80 | ((d >> 6) & 0x3F);
-      b[3] = 0x80 | (d & 0x3F);
-      str ~= b[0..4];
-    }
-    else if (d < 0x4000000)
-    {
-      b[0] = 0xF8 | (d >> 24);
-      b[1] = 0x80 | ((d >> 18) & 0x3F);
-      b[2] = 0x80 | ((d >> 12) & 0x3F);
-      b[3] = 0x80 | ((d >> 6) & 0x3F);
-      b[4] = 0x80 | (d & 0x3F);
-      str ~= b[0..5];
-    }
-    else if (d < 0x80000000)
-    {
-      b[0] = 0xFC | (d >> 30);
-      b[1] = 0x80 | ((d >> 24) & 0x3F);
-      b[2] = 0x80 | ((d >> 18) & 0x3F);
-      b[3] = 0x80 | ((d >> 12) & 0x3F);
-      b[4] = 0x80 | ((d >> 6) & 0x3F);
-      b[5] = 0x80 | (d & 0x3F);
-      str ~= b[0..6];
-    }
-    else
-      error(MID.InvalidUnicodeCharacter);
-  }
-}
-
-unittest
-{
-  string[] toks = [
-    ">",    ">=", ">>",  ">>=", ">>>", ">>>=", "<",   "<=",  "<>",
-    "<>=",  "<<", "<<=", "!",   "!<",  "!>",   "!<=", "!>=", "!<>",
-    "!<>=", ".",  "..",  "...", "&",   "&&",   "&=",  "+",   "++",
-    "+=",   "-",  "--",  "-=",  "=",   "==",   "~",   "~=",  "*",
-    "*=",   "/",  "/=",  "^",   "^=",  "%",    "%=",  "(",   ")",
-    "[",    "]",  "{",   "}",   ":",   ";",    "?",   ",",   "$"
-  ];
-
-  char[] src;
-
-  foreach (op; toks)
-    src ~= op ~ " ";
-
-  auto lx = new Lexer(src, "");
-  auto tokens = lx.getTokens();
-
-  tokens = tokens[0..$-1]; // exclude TOK.EOF
-
-  assert(tokens.length == toks.length );
-
-  foreach (i, t; tokens)
-    assert(t.srcText == toks[i], std.string.format("Lexed '%s' but expected '%s'", t.srcText, toks[i]));
-}
-
-unittest
-{
-  // Numbers unittest
-  // 0L 0ULi 0_L 0_UL 0x0U 0x0p2 0_Fi 0_e2 0_F 0_i
-  // 0u 0U 0uL 0UL 0L 0LU 0Lu
-  // 0Li 0f 0F 0fi 0Fi 0i
-  // 0b_1_LU 0b1000u
-  // 0x232Lu
-}
-
-/// ASCII character properties table.
-static const int ptable[256] = [
- 0, 0, 0, 0, 0, 0, 0, 0, 0,32, 0,32,32, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-32, 0, 0x2200, 0, 0, 0, 0, 0x2700, 0, 0, 0, 0, 0, 0, 0, 0,
- 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 0, 0, 0, 0, 0, 0x3f00,
- 0,12,12,12,12,12,12, 8, 8, 8, 8, 8, 8, 8, 8, 8,
- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0x5c00, 0, 0,16,
- 0, 0x70c, 0x80c,12,12,12, 0xc0c, 8, 8, 8, 8, 8, 8, 8, 0xa08, 8,
- 8, 8, 0xd08, 8, 0x908, 8, 0xb08, 8, 8, 8, 8, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-];
-
-enum CProperty
-{
-       Octal = 1,
-       Digit = 1<<1,
-         Hex = 1<<2,
-       Alpha = 1<<3,
-  Underscore = 1<<4,
-  Whitespace = 1<<5
-}
-
-const uint EVMask = 0xFF00; // Bit mask for escape value
-
-private alias CProperty CP;
-int isoctal(char c) { return ptable[c] & CP.Octal; }
-int isdigit(char c) { return ptable[c] & CP.Digit; }
-int ishexad(char c) { return ptable[c] & CP.Hex; }
-int isalpha(char c) { return ptable[c] & CP.Alpha; }
-int isalnum(char c) { return ptable[c] & (CP.Alpha | CP.Digit); }
-int isidbeg(char c) { return ptable[c] & (CP.Alpha | CP.Underscore); }
-int isident(char c) { return ptable[c] & (CP.Alpha | CP.Underscore | CP.Digit); }
-int isspace(char c) { return ptable[c] & CP.Whitespace; }
-int char2ev(char c) { return ptable[c] >> 8; /*(ptable[c] & EVMask) >> 8;*/ }
-
-version(gen_ptable)
-static this()
-{
-  alias ptable p;
-  // Initialize character properties table.
-  for (int i; i < p.length; ++i)
-  {
-    p[i] = 0;
-    if ('0' <= i && i <= '7')
-      p[i] |= CP.Octal;
-    if ('0' <= i && i <= '9')
-      p[i] |= CP.Digit;
-    if (isdigit(i) || 'a' <= i && i <= 'f' || 'A' <= i && i <= 'F')
-      p[i] |= CP.Hex;
-    if ('a' <= i && i <= 'z' || 'A' <= i && i <= 'Z')
-      p[i] |= CP.Alpha;
-    if (i == '_')
-      p[i] |= CP.Underscore;
-    if (i == ' ' || i == '\t' || i == '\v' || i == '\f')
-      p[i] |= CP.Whitespace;
-  }
-  // Store escape sequence values in second byte.
-  assert(CProperty.max <= ubyte.max, "character property flags and escape value byte overlap.");
-  p['\''] |= 39 << 8;
-  p['"'] |= 34 << 8;
-  p['?'] |= 63 << 8;
-  p['\\'] |= 92 << 8;
-  p['a'] |= 7 << 8;
-  p['b'] |= 8 << 8;
-  p['f'] |= 12 << 8;
-  p['n'] |= 10 << 8;
-  p['r'] |= 13 << 8;
-  p['t'] |= 9 << 8;
-  p['v'] |= 11 << 8;
-  // Print a formatted array literal.
-  char[] array = "[\n";
-  for (int i; i < p.length; ++i)
-  {
-    int c = p[i];
-    array ~= std.string.format(c>255?" 0x%x,":"%2d,", c, ((i+1) % 16) ? "":"\n");
-  }
-  array[$-2..$] = "\n]";
-  writefln(array);
-}

--- a/trunk/src/Messages.d	Tue Aug 21 16:18:02 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-/++
-  Author: Aziz Köksal
-  License: GPL3
-+/
-module Messages;
-import Settings;
-import std.stdarg;
-
-/// Index into table of compiler messages.
-enum MID
-{
-  // Lexer messages:
-  InvalidUnicodeCharacter,
-  InvalidUTF8Sequence,
-  // ''
-  UnterminatedCharacterLiteral,
-  EmptyCharacterLiteral,
-  // #line
-  ExpectedIdentifierSTLine,
-  ExpectedNumberAfterSTLine,
-  ExpectedFilespec,
-  UnterminatedFilespec,
-  UnterminatedSpecialToken,
-  // ""
-  UnterminatedString,
-  // x""
-  NonHexCharInHexString,
-  OddNumberOfDigitsInHexString,
-  UnterminatedHexString,
-  // /* */ /+ +/
-  UnterminatedBlockComment,
-  UnterminatedNestedComment,
-  // `` r""
-  UnterminatedRawString,
-  UnterminatedBackQuoteString,
-  // \x \u \U
-  UndefinedEscapeSequence,
-  InsufficientHexDigits,
-  // \&[a-zA-Z][a-zA-Z0-9]+;
-  UndefinedHTMLEntity,
-  UnterminatedHTMLEntity,
-  InvalidBeginHTMLEntity,
-  // integer overflows
-  OverflowDecimalSign,
-  OverflowDecimalNumber,
-  OverflowHexNumber,
-  OverflowBinaryNumber,
-  OverflowOctalNumber,
-  OverflowFloatNumber,
-  OctalNumberHasDecimals,
-  NoDigitsInHexNumber,
-  NoDigitsInBinNumber,
-  HexFloatExponentRequired,
-  HexFloatMissingExpDigits,
-  FloatExponentDigitExpected,
-
-  // Parser messages:
-  ExpectedButFound,
-  RedundantStorageClass,
-
-  // Help messages:
-  HelpMain,
-}
-
-string GetMsg(MID mid)
-{
-  assert(mid < GlobalSettings.messages.length);
-  return GlobalSettings.messages[mid];
-}
-
-char[] format(MID mid, ...)
-{
-  auto args = arguments(_arguments, _argptr);
-  return format_args(GetMsg(mid), args);
-}
-
-char[] format(char[] format_str, ...)
-{
-  auto args = arguments(_arguments, _argptr);
-  return format_args(format_str, args);
-}
-
-char[] format_args(char[] format_str, char[][] args)
-{
-  char[] result = format_str;
-
-  foreach (i, arg; args)
-    result = std.string.replace(result, std.string.format("{%s}", i+1), arg);
-
-  return result;
-}
-
-char[][] arguments(TypeInfo[] tinfos, void* argptr)
-{
-  char[][] args;
-  foreach (ti; tinfos)
-  {
-    if (ti == typeid(char[]))
-      args ~= va_arg!(char[])(argptr);
-    else if (ti == typeid(int))
-      args ~= std.string.format(va_arg!(int)(argptr));
-    else if (ti == typeid(dchar))
-      args ~= std.string.format(va_arg!(dchar)(argptr));
-    else
-      assert(0, "argument type not supported yet.");
-  }
-  return args;
-}