projects/dang: ast/Exp.d comparison

comparison ast/Exp.d @ 195:4e1a7265d620

Made a BuildTypes pass, to give all exp's a type.

author	Anders Johnsen <skabet@gmail.com>
date	Tue, 29 Jul 2008 15:50:24 +0200
parents	08f68d684047
children

comparison

equal deleted inserted replaced

-:08f68d684047
+:4e1a7265d620
 Identifiers and member references can have a sensible value.
 **/
 Symbol getSymbol() { return null; }
 /// Get the type of the expression
-abstract DType type();
+DType type;
 /// Indicates which type the expression is - to avoid a lot of casts
 ExpType expType;
 /// The environment of the expression
 Scope env;
-Symbol symbol;
 int stmtIndex;
 /**
 The "main" location of the expression.
 super(ExpType.CallExp, exp.loc);
 this.exp = exp;
 this.args = args;
 }
-override DType type()
-{
-DFunction f = exp.type.asCallable();
-assert(f !is null, "Can only call functions");
-return f.returnType;
-}
 DType callerType()
 {
 DFunction f = new DFunction(new Identifier("function"));
 f.returnType = type;
 foreach (a ; args)
 override SourceRange sourceRange()
 {
 return identifier.sourceRange + exp.sourceRange;
 }
-override DType type() { return identifier.type(); }
 Exp identifier;
 Exp exp;
 }
 class BinaryExp : Exp
 this.op = op;
 this.left = left;
 this.right = right;
 }
-override DType type()
-{
-if (myType)
-return myType;
-if (op == Operator.Eq ||
-op == Operator.Ne ||
-op == Operator.Lt ||
-op == Operator.Le ||
-op == Operator.Gt ||
-op == Operator.Ge)
-{
-myType = DType.Bool;
-return myType;
-}
-DType l = left.type;
-DType r = right.type;
-if (l is r)
-myType = l;
-else if (l.hasImplicitConversionTo(r))
-myType = r;
-else if (r.hasImplicitConversionTo(l))
-myType = l;
-else
-return null;
-return myType;
-}
 override SLoc startLoc() { return left.startLoc(); }
 override SourceRange sourceRange()
 {
 return left.sourceRange + right.sourceRange;
 return this;
 }
 Operator op;
 Exp left, right;
-private DType myType;
 }
 class NegateExp : Exp
 {
 this(SLoc op, Exp exp)
 {
 exp = exp.simplify();
 return this;
 }
-override DType type() { return exp.type(); }
 override SourceRange sourceRange()
 {
 return SourceRange(loc) + exp.sourceRange;
 }
 {
 exp = exp.simplify();
 return this;
 }
-override DType type()
-{
-if (_type)
-return _type;
-return exp.type().asPointer().pointerOf;
-}
 override SourceRange sourceRange()
 {
 return SourceRange(loc) + exp.sourceRange;
 }
-DType _type;
 public Exp exp;
 }
 class AddressOfExp : Exp
 {
 override AddressOfExp simplify()
 {
 exp = exp.simplify();
 return this;
-}
-override DType type()
-{
-return exp.type().getPointerTo;
 }
 override SourceRange sourceRange()
 {
 return SourceRange(loc) + exp.sourceRange;
 }
 override IntegerLit simplify()
 {
 return this;
-}
-override DType type()
-{
-switch(number.type)
-{
-case NumberType.Int:
-return DType.Int;
-case NumberType.Long:
-return DType.Long;
-case NumberType.ULong:
-return DType.ULong;
-case NumberType.Double:
-return DType.Double;
-case NumberType.Real:
-return DType.Real;
-}
 }
 override SourceRange sourceRange()
 {
 return range;
 {
 target = target.simplify();
 return this;
 }
-override DType type()
-{
-if (myType)
-return myType;
-if ( target.type.isStruct )
-{
-Symbol st = target.getSymbol;
-if (auto t = st.findMembers(child.name))
-myType = t[0].type;
-//            else assert(0, "Referencing non-existant member");
-}
-else if ( target.type.isClass )
-{
-Symbol cl = target.getSymbol;
-if (auto t = cl.findMembers(child.name))
-myType = t[0].type;
-//            else assert(0, "Referencing non-existant member");
-}
-else
-assert(0, "Only structs and classes have members");
-// no error reporting here
-return myType;
-}
 override SLoc startLoc() { return target.startLoc(); }
 override SourceRange sourceRange()
 {
 return target.sourceRange + child.sourceRange;
 }
 Identifier child;
 Exp target;
-private DType myType;
 }
 class IndexExp : Exp
 {
 this(Exp target, SLoc left_bracket, Exp index, SLoc right_bracket)
 this.left_bracket = left_bracket;
 this.index = index;
 this.right_bracket = right_bracket;
 }
-override DType type()
-{
-DType type = target.type();
-if (type.isStaticArray())
-return type.asStaticArray().arrayOf;
-else if (type.isPointer())
-return type.asPointer().pointerOf;
-else assert(0, "Can only index pointers and arrays");
-}
 override SourceRange sourceRange()
 {
 return target.sourceRange + SourceRange(right_bracket);
 }
 super(ExpType.CastExp, loc);
 this.castType = castType;
 this.exp = exp;
 }
-override DType type()
-{
-return env.findType(this.castType.get);
-}
 override CastExp simplify()
 {
 castType = castType.simplify();
 exp = exp.simplify();
 return this;
 {
 this(SLoc loc, char[] str)
 {
 super(ExpType.StringExp, loc);
 this.str = str;
-}
-override DType type()
-{
-switch (data.type)
-{
-case StringType.Char:
-return DType.Char.getAsStaticArray(data.data.length);
-case StringType.WChar:
-return DType.WChar.getAsStaticArray(data.data.length/2);
-case StringType.DChar:
-return DType.DChar.getAsStaticArray(data.data.length/4);
-}
 }
 char[] str;
 String data;
 }
 this.newType = newType;
 this.a_args = a_args;
 this.c_args = c_args;
 }
-override DType type()
-{
-return env.findType(this.newType.get);
-}
 Exp[] a_args, c_args;
 Identifier newType;
 Symbol callSym;
 }
 {
 this(SLoc loc)
 {
 super(ExpType.NullExp, loc);
 }
-override DType type()
-{
-return new DPointer(DType.Int);
-}
 }
 class Identifier : Exp
 {
 this(SLoc loc, char[] name)
 return Integer.toString(name.length) ~ name;
 }
 override Symbol getSymbol()
 {
+if (!env)
+return null;
 if (auto decl = env.find(this.get))
 if(decl.length)
 return decl[$-1].sym;
 return null;
 }
-override DType type()
-{
-if (myType !is null)
-return myType;
-else if (auto sym = getSymbol)
-myType = sym.type;
-else
-myType = DType.Int;
-return myType;
-}
 this(char[] name)
 {
 super(ExpType.Identifier, SLoc.Invalid);
 this.name = name;
 }
 override Identifier simplify()
 {
 return this;
 }
-void setType(DType myType)
-{
-this.myType = myType;
-}
 override SourceRange sourceRange()
 {
 return SourceRange(loc, loc + name.length);
 }
 char[] name;
-private DType myType;
 }
 class IdentifierTypeExp : Identifier
 {
 this(SLoc loc, char[] name)
 this(IdentifierTypeExp pointerOf)
 {
 super(ExpType.PointerTypeExp, pointerOf.loc);
 this.pointerOf = pointerOf;
 this.name = pointerOf.name;
-}
-override DType type()
-{
-return pointerOf.type.getPointerTo();
 }
 Identifier pointerOf;
 }
 this.arrayOf = arrayOf;
 this.size = Integer.parse(size.get);
 this.name = arrayOf.name;
 }
-override DType type()
-{
-return arrayOf.type.getAsStaticArray(size);
-}
 Identifier arrayOf;
 int size;
-private DType myType;
 }
 class ArrayTypeExp : IdentifierTypeExp
 {
 this(IdentifierTypeExp arrayOf)
 super(ExpType.ArrayTypeExp, arrayOf.loc);
 this.arrayOf = arrayOf;
 this.name = arrayOf.name;
 }
-override DType type()
-{
-return arrayOf.type.getAsArray();
-}
 Identifier arrayOf;
-private DType myType;
 }
 class FunctionTypeExp : IdentifierTypeExp
 {
 this(IdentifierTypeExp returnType, VarDecl[] decls)
 super(ExpType.FunctionTypeExp, returnType.loc);
 this.returnType = returnType;
 this.decls = decls;
 }
-override DType type()
-{
-if (myType)
-return myType;
-auto t  = new DFunction(returnType);
-t.returnType = returnType.type;
-foreach (decl ; decls)
-t.params ~= decl.identifier.type;
-myType = t.getPointerTo;
-return myType;
-}
 VarDecl[] decls;
 IdentifierTypeExp returnType;
-private DType myType;
 }
 class ArrayLiteralExp : Exp
 {
 this(Exp[] exps, SLoc begin, SLoc end)
 this.exps = exps;
 this.begin = begin;
 this.end = end;
 }
-override DType type()
-{
-return exps[0].type.getAsStaticArray(exps.length);
-}
 Exp[] exps;
 SLoc begin, end;
 }

Mercurial > projects > dang

comparison ast/Exp.d @ 195:4e1a7265d620