projects/ldc: dmd/expression.c comparison

comparison dmd/expression.c @ 159:5acec6b2eef8 trunk

[svn r175] merged dmd 1.029

author	ChristianK
date	Thu, 01 May 2008 15:15:28 +0200
parents	0ab29b838084
children	a8cd9bc1021a

comparison

equal deleted inserted replaced

-:287540c5f05e
+:5acec6b2eef8
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2007 by Digital Mars
+// Copyright (c) 1999-2008 by Digital Mars
 // All Rights Reserved
 // written by Walter Bright
 // http://www.digitalmars.com
 // License for redistribution is by either the Artistic License
 // in artistic.txt, or the GNU General Public License in gnu.txt.
 enum PREC precedence[TOKMAX];
 void initPrecedence()
 {
+precedence[TOKdotvar] = PREC_primary;
 precedence[TOKimport] = PREC_primary;
 precedence[TOKidentifier] = PREC_primary;
 precedence[TOKthis] = PREC_primary;
 precedence[TOKsuper] = PREC_primary;
 precedence[TOKint64] = PREC_primary;
 precedence[TOKoror] = PREC_oror;
 precedence[TOKquestion] = PREC_cond;
 precedence[TOKassign] = PREC_assign;
+precedence[TOKconstruct] = PREC_assign;
+precedence[TOKblit] = PREC_assign;
 precedence[TOKaddass] = PREC_assign;
 precedence[TOKminass] = PREC_assign;
 precedence[TOKcatass] = PREC_assign;
 precedence[TOKmulass] = PREC_assign;
 precedence[TOKdivass] = PREC_assign;
 	{   Expression *arg = (Expression *)arguments->data[i];
 	    if (i)
 		buf->writeByte(',');
 	    argbuf.reset();
-	    arg->type->toCBuffer2(&argbuf, NULL, hgs);
+	    arg->type->toCBuffer2(&argbuf, hgs, 0);
 	    buf->write(&argbuf);
 	}
 }
 }
 Type *t0 = NULL;
 #if LOGSEMANTIC
 printf("ArrayLiteralExp::semantic('%s')\n", toChars());
 #endif
+if (type)
+	return this;
 // Run semantic() on each element
 for (int i = 0; i < elements->dim; i++)
 {	e = (Expression *)elements->data[i];
 	e = e->semantic(sc);
 return e;
 }
 /************************************
 * Get index of field.
 * Returns -1 if not found.
 */
 int StructLiteralExp::getFieldIndex(Type *type, unsigned offset)
 {
 /* Find which field offset is by looking at the field offsets
 int BinExp::checkSideEffect(int flag)
 {
 if (op == TOKplusplus ||
 	   op == TOKminusminus ||
 	   op == TOKassign ||
+	   op == TOKconstruct ||
+	   op == TOKblit ||
 	   op == TOKaddass ||
 	   op == TOKminass ||
 	   op == TOKcatass ||
 	   op == TOKmulass ||
 	   op == TOKdivass ||
 // Mainly just a placeholder
 DotTemplateExp::DotTemplateExp(Loc loc, Expression *e, TemplateDeclaration *td)
 	: UnaExp(loc, TOKdottd, sizeof(DotTemplateExp), e)
 {
 this->td = td;
 }
 void DotTemplateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 			    s = s->toParent();
 			}
 			if (s && s->isClassDeclaration())
 			    e1->type = s->isClassDeclaration()->type;
+			e1 = e1->semantic(sc);
 			goto L1;
 		    }
 #ifdef DEBUG
 		    printf("2: ");
 #endif
 {
 	DotVarExp *dve;
 	DotTemplateExp *dte;
 	AggregateDeclaration *ad;
 	UnaExp *ue = (UnaExp *)(e1);
 	if (e1->op == TOKdotvar)
 {   // Do overload resolution
 	    dve = (DotVarExp *)(e1);
 	    f = dve->var->isFuncDeclaration();
 	    if (!f)
 	    {	type = Type::terror;
 		return this;
 	    }
 	    ad = td->toParent()->isAggregateDeclaration();
 	}
 	/* Now that we have the right function f, we need to get the
 	 * right 'this' pointer if f is in an outer class, but our
 	 * existing 'this' pointer is in an inner class.
 	 * This code is analogous to that used for variables
 	 * in DotVarExp::semantic().
 	    e1 = new CommaExp(loc, ue->e1, ve);
 	    e1->type = f->type;
 	}
 	else
 	{
 	    if (e1->op == TOKdotvar)
 		dve->var = f;
 	    else
 		e1 = new DotVarExp(loc, dte->e1, f);
 	    e1->type = f->type;
 		StructDeclaration *sd = ts->sym;
 		FuncDeclaration *f = sd->aggDelete;
 		if (f)
 		{
-		    Expression *e;
-		    Expression *ec;
 		    Type *tpv = Type::tvoid->pointerTo();
-		    e = e1;
+		    Expression *e = e1->castTo(sc, tpv);
-		    e->type = tpv;
+		    Expression *ec = new VarExp(loc, f);
-		    ec = new VarExp(loc, f);
 		    e = new CallExp(loc, ec, e);
 		    return e->semantic(sc);
 		}
 	    }
 	    break;
 	{
 	    return e->implicitCastTo(sc, to);
 	}
 	Type *tob = to->toBasetype();
-	if (tob->ty == Tstruct && !tob->equals(e1->type->toBasetype()))
+	if (tob->ty == Tstruct &&
+	    !tob->equals(e1->type->toBasetype()) &&
+	    ((TypeStruct *)to)->sym->search(0, Id::call, 0)
+	   )
 	{
 	    /* Look to replace:
 	     *	cast(S)t
 	     * with:
 	     *	S(t)
 e1 = e1->modifiableLvalue(sc, e1);
 Type *tb1 = e1->type->toBasetype();
 Type *tb2 = e2->type->toBasetype();
+e2->rvalue();
 if ((tb1->ty == Tarray) &&
 	(tb2->ty == Tarray || tb2->ty == Tsarray) &&
 	e2->implicitConvTo(e1->type)
 	//e1->type->next->equals(e2->type->next)
 #endif
 if (type)
 	return this;
 BinExp::semanticp(sc);
+if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull ||
+	e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull)
+{
+	error("do not use null when comparing class types");
+}
 e = op_overload(sc);
 if (e)
 {
 	e = new CmpExp(op, loc, e, new IntegerExp(loc, 0, Type::tint32));
 	e = e->semantic(sc);
 /************************************************************/
 EqualExp::EqualExp(enum TOK op, Loc loc, Expression *e1, Expression *e2)
 	: BinExp(loc, op, sizeof(EqualExp), e1, e2)
 {
+assert(op == TOKequal || op == TOKnotequal);
 }
 Expression *EqualExp::semantic(Scope *sc)
 {   Expression *e;
 Type *t1;
 		// They are the same, result is 'true' for ==, 'false' for !=
 		e = new IntegerExp(loc, (op == TOKequal), Type::tboolean);
 		return e;
 	    }
 	}
+}
+if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull ||
+	e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull)
+{
+	error("use '%s' instead of '%s' when comparing with null",
+		Token::toChars(op == TOKequal ? TOKidentity : TOKnotidentity),
+		Token::toChars(op));
 }
 //if (e2->op != TOKnull)
 {
 	e = op_overload(sc);

Mercurial > projects > ldc

comparison dmd/expression.c @ 159:5acec6b2eef8 trunk