projects/ldc: dmd/expression.c comparison

comparison dmd/expression.c @ 1587:def7a1d494fd

Merge DMD 1.051

author	Christian Kamm <kamm incasoftware de>
date	Fri, 06 Nov 2009 23:58:01 +0100
parents	05c235309d6f
children	2afcaab30a6a

comparison

equal deleted inserted replaced

-:7f728c52e63c
+:def7a1d494fd
 int isnan(double);
 #endif
 #endif
 #include "rmem.h"
+#include "port.h"
-//#include "port.h"
 #include "mtype.h"
 #include "init.h"
 #include "expression.h"
 #include "template.h"
 #include "utf.h"
 	{
 	    e->error("expression has no value");
 	}
 }
+else if (e->op == TOKdottd)
+{
+	e = new CallExp(e->loc, e);
+	e = e->semantic(sc);
+}
 return e;
 }
 /******************************
 * Perform semantic() on an array of Expressions.
 assert(arguments);
 size_t nargs = arguments ? arguments->dim : 0;
 size_t nparams = Argument::dim(tf->parameters);
 if (nargs > nparams && tf->varargs == 0)
-	error(loc, "expected %zu arguments, not %zu", nparams, nargs);
+	error(loc, "expected %zu arguments, not %zu for non-variadic function type %s", nparams, nargs, tf->toChars());
 n = (nargs > nparams) ? nargs : nparams;	// n = max(nargs, nparams)
 int done = 0;
 for (size_t i = 0; i < n; i++)
 	    {
 		if (!p->defaultArg)
 		{
 		    if (tf->varargs == 2 && i + 1 == nparams)
 			goto L2;
-		    error(loc, "expected %zu arguments, not %zu", nparams, nargs);
+		    error(loc, "expected %zu function arguments, not %zu", nparams, nargs);
 		    break;
 		}
 		arg = p->defaultArg;
 #if DMDV2
 		if (arg->op == TOKdefault)
 	    {
 		//printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars());
 		if (arg->implicitConvTo(p->type))
 		{
 		    if (nargs != nparams)
-		        error(loc, "expected %zu arguments, not %zu", nparams, nargs);
+		        error(loc, "expected %zu function arguments, not %zu", nparams, nargs);
 		    goto L1;
 		}
 	     L2:
 		Type *tb = p->type->toBasetype();
 		Type *tret = p->isLazyArray();
 		done = 1;
 	    }
 	L1:
 	    if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
-		arg = arg->implicitCastTo(sc, p->type);
+	    {
+		if (p->type != arg->type)
+		{
+		    //printf("arg->type = %s, p->type = %s\n", arg->type->toChars(), p->type->toChars());
+		    if (arg->op == TOKtype)
+			arg->error("cannot pass type %s as function argument", arg->toChars());
+		    arg = arg->implicitCastTo(sc, p->type);
+		    arg = arg->optimize(WANTvalue);
+		}
+	    }
 	    if (p->storageClass & (STCout | STCref))
 	    {
 		// BUG: should check that argument to ref is type 'invariant'
 		// BUG: assignments to ref should also be type 'invariant'
 		arg = arg->modifiableLvalue(sc, arg);
 #if DMDV2
 	    if (tb->ty == Tstruct)
 	    {
 		arg = callCpCtor(loc, sc, arg);
 	    }
+#endif
 	    // Give error for overloaded function addresses
+#if DMDV2
 	    if (arg->op == TOKsymoff)
 	    {	SymOffExp *se = (SymOffExp *)arg;
-		if (se->hasOverloads && !se->var->isFuncDeclaration()->isUnique())
+		if (
+		    se->hasOverloads &&
+		    !se->var->isFuncDeclaration()->isUnique())
 		    arg->error("function %s is overloaded", arg->toChars());
 	    }
 #endif
 	    arg->rvalue();
 	}
 */
 Expression *Expression::deref()
 {
 //printf("Expression::deref()\n");
-if (type->ty == Treference)
+// type could be null if forward referencing an 'auto' variable
-{	Expression *e;
+if (type && type->ty == Treference)
+{
-	e = new PtrExp(loc, this);
+	Expression *e = new PtrExp(loc, this);
 	e->type = ((TypeReference *)type)->next;
 	return e;
 }
 return this;
 }
 	return e->semantic(sc);
 }
 f = s->isFuncDeclaration();
 if (f)
 {	//printf("'%s' is a function\n", f->toChars());
+	if (!f->type->deco)
+	{
+	    error("forward reference to %s", toChars());
+	}
 	return new VarExp(loc, f);
 }
 cd = s->isClassDeclaration();
 if (cd && thiscd && cd->isBaseOf(thiscd, NULL) && sc->func->needThis())
 {
 	return e;
 }
 TemplateInstance *ti = s->isTemplateInstance();
 if (ti && !global.errors)
-{   if (!ti->semanticdone)
+{   if (!ti->semanticRun)
 	    ti->semantic(sc);
 	s = ti->inst->toAlias();
 	if (!s->isTemplateInstance())
 	    goto Lagain;
 	e = new ScopeExp(loc, ti);
 	else
 	{
 	    if (v->init)
 	    {   e = v->init->toExpression();
 		if (!e)
-		    error("cannot make expression out of initializer for %s", v->toChars());
+		{   error("cannot make expression out of initializer for %s", v->toChars());
+		    e = new ErrorExp();
+		}
+		else if (v->scope)
+		{   // Do deferred semantic anaylsis
+		    Initializer *i2 = v->init->syntaxCopy();
+		    i2 = i2->semantic(v->scope, v->type);
+		    e = i2->toExpression();
+		    v->scope = NULL;
+		}
 	    }
 	    else
 	    {	e = v->type->defaultInit();
 		e->loc = loc;
 	    }
 	//printf("\ti = %d\n", i);
 	assert(i < elements->dim);
 	e = (Expression *)elements->data[i];
 	if (e)
 	{
-	    e = e->copy();
+	    //printf("e = %s, e->type = %s\n", e->toChars(), e->type->toChars());
-	    e->type = type;
+	    /* If type is a static array, and e is an initializer for that array,
+	     * then the field initializer should be an array literal of e.
+	     */
+	    if (e->type != type && type->ty == Tsarray)
+	    {   TypeSArray *tsa = (TypeSArray *)type;
+		uinteger_t length = tsa->dim->toInteger();
+		Expressions *z = new Expressions;
+		z->setDim(length);
+		for (int q = 0; q < length; ++q)
+		    z->data[q] = e->copy();
+		e = new ArrayLiteralExp(loc, z);
+		e->type = type;
+	    }
+	    else
+	    {
+		e = e->copy();
+		e->type = type;
+	    }
 	}
 }
 return e;
 }
 int StructLiteralExp::getFieldIndex(Type *type, unsigned offset)
 {
 /* Find which field offset is by looking at the field offsets
 */
-for (size_t i = 0; i < sd->fields.dim; i++)
+if (elements->dim)
 {
-	Dsymbol *s = (Dsymbol *)sd->fields.data[i];
+	for (size_t i = 0; i < sd->fields.dim; i++)
-	VarDeclaration *v = s->isVarDeclaration();
+	{
-	assert(v);
+	    Dsymbol *s = (Dsymbol *)sd->fields.data[i];
+	    VarDeclaration *v = s->isVarDeclaration();
-	if (offset == v->offset &&
+	    assert(v);
-	    type->size() == v->type->size())
-	{   Expression *e = (Expression *)elements->data[i];
+	    if (offset == v->offset &&
-	    if (e)
+		type->size() == v->type->size())
-	    {
+	    {   Expression *e = (Expression *)elements->data[i];
-		return i;
+		if (e)
-	    }
+		{
-	    break;
+		    return i;
+		}
+		break;
+	    }
 	}
 }
 return -1;
 }
 #endif
 Lagain:
 ti = sds->isTemplateInstance();
 if (ti && !global.errors)
 {	Dsymbol *s;
-	if (!ti->semanticdone)
+	if (!ti->semanticRun)
 	    ti->semantic(sc);
 	s = ti->inst->toAlias();
 	sds2 = s->isScopeDsymbol();
 	if (!sds2)
 	{   Expression *e;
 #endif
 	    }
 	    else if (thisexp)
 		error("e.new is only for allocating nested classes");
 	    else if (fdn)
 	    {
 		// make sure the parent context fdn of cd is reachable from sc
 		for (Dsymbol *sp = sc->parent; 1; sp = sp->parent)
 		{
 		    if (fdn == sp)
 			break;
 	FuncDeclaration *f = cd->ctor;
 	if (f)
 	{
 	    assert(f);
-	    f = f->overloadResolve(loc, arguments, sc->module);
+	    f = f->overloadResolve(loc, NULL, arguments, sc->module);
 	    checkDeprecated(sc, f);
 	    member = f->isCtorDeclaration();
 	    assert(member);
 	    cd->accessCheck(loc, sc, member);
 	    Expression *e = new IntegerExp(loc, cd->size(loc), Type::tsize_t);
 	    if (!newargs)
 		newargs = new Expressions();
 	    newargs->shift(e);
-	    f = cd->aggNew->overloadResolve(loc, newargs, sc->module);
+	    f = cd->aggNew->overloadResolve(loc, NULL, newargs, sc->module);
 	    allocator = f->isNewDeclaration();
 	    assert(allocator);
 	    tf = (TypeFunction *)f->type;
 	    functionArguments(loc, sc, tf, newargs);
 	    e = new IntegerExp(loc, sd->size(loc), Type::tuns32);
 	    if (!newargs)
 		newargs = new Expressions();
 	    newargs->shift(e);
-	    f = f->overloadResolve(loc, newargs, sc->module);
+	    f = f->overloadResolve(loc, NULL, newargs, sc->module);
 	    allocator = f->isNewDeclaration();
 	    assert(allocator);
 	    tf = (TypeFunction *)f->type;
 	    functionArguments(loc, sc, tf, newargs);
 if (0 && exps->dim == 1)
 {
 	return (Expression *)exps->data[0];
 }
 type = new TypeTuple(exps);
+type = type->semantic(loc, sc);
 //printf("-TupleExp::semantic(%s)\n", toChars());
 return this;
 }
 void TupleExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 	fd->semantic(sc);
 	fd->parent = sc->parent;
 	if (global.errors)
 	{
-	    if (!fd->type->next)
-		fd->type->next = Type::terror;
 	}
 	else
 	{
 	    fd->semantic2(sc);
-	    if (!global.errors)
+	    if (!global.errors ||
+		// need to infer return type
+		(fd->type && fd->type->ty == Tfunction && !fd->type->nextOf()))
 	    {
 		fd->semantic3(sc);
 		if (!global.errors && global.params.useInline)
 		    fd->inlineScan();
 	    }
 	}
+	// need to infer return type
+	if (global.errors && fd->type && fd->type->ty == Tfunction && !fd->type->nextOf())
+	    ((TypeFunction *)fd->type)->next = Type::terror;
 	// Type is a "delegate to" or "pointer to" the function literal
 	if (fd->isNested())
 	{
 	    type = new TypeDelegate(fd->type);
 	    }
 	}
 }
 if (!s->isVarDeclaration())
 {
-	declaration->semantic(sc);
+	Scope *sc2 = sc;
+	if (sc2->stc & (STCpure | STCnothrow))
+	    sc2 = sc->push();
+	sc2->stc &= ~(STCpure | STCnothrow);
+	declaration->semantic(sc2);
+	if (sc2 != sc)
+	    sc2->pop();
 	s->parent = sc->parent;
 }
 if (!global.errors)
 {
 	declaration->semantic2(sc);
 	e1->checkArithmetic();
 	e2->checkArithmetic();
 	if (op == TOKmodass && e2->type->iscomplex())
 	{   error("cannot perform modulo complex arithmetic");
-	    return new IntegerExp(0);
+	    return new ErrorExp();
 	}
 }
 return this;
 }
 	   op == TOKremove)
 	return 1;
 return Expression::checkSideEffect(flag);
 }
+// generate an error if this is a nonsensical *=,/=, or %=, eg real *= imaginary
+void BinExp::checkComplexMulAssign()
+{
+// Any multiplication by an imaginary or complex number yields a complex result.
+// r *= c, i*=c, r*=i, i*=i are all forbidden operations.
+const char *opstr = Token::toChars(op);
+if ( e1->type->isreal() && e2->type->iscomplex())
+{
+error("%s %s %s is undefined. Did you mean %s %s %s.re ?",
+e1->type->toChars(), opstr, e2->type->toChars(),
+e1->type->toChars(), opstr, e2->type->toChars());
+}
+else if (e1->type->isimaginary() && e2->type->iscomplex())
+{
+error("%s %s %s is undefined. Did you mean %s %s %s.im ?",
+e1->type->toChars(), opstr, e2->type->toChars(),
+e1->type->toChars(), opstr, e2->type->toChars());
+}
+else if ((e1->type->isreal() || e1->type->isimaginary()) &&
+	e2->type->isimaginary())
+{
+error("%s %s %s is an undefined operation", e1->type->toChars(),
+		opstr, e2->type->toChars());
+}
+}
+// generate an error if this is a nonsensical += or -=, eg real += imaginary
+void BinExp::checkComplexAddAssign()
+{
+// Addition or subtraction of a real and an imaginary is a complex result.
+// Thus, r+=i, r+=c, i+=r, i+=c are all forbidden operations.
+if ( (e1->type->isreal() && (e2->type->isimaginary() || e2->type->iscomplex())) ||
+(e1->type->isimaginary() && (e2->type->isreal() || e2->type->iscomplex()))
+)
+{
+error("%s %s %s is undefined (result is complex)",
+	    e1->type->toChars(), Token::toChars(op), e2->type->toChars());
+}
+}
 void BinExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 expToCBuffer(buf, hgs, e1, precedence[op]);
 buf->writeByte(' ');
 buf->writestring(Token::toChars(op));
 {	error("file %s cannot be found, check -Jpath", se->toChars());
 	goto Lerror;
 }
 if (global.params.verbose)
-	printf("file      %s\t(%s)\n", (char*)se->string, name);
+	printf("file      %s\t(%s)\n", (char *)se->string, name);
 {	File f(name);
 	if (f.read())
 	{   error("cannot read file %s", f.toChars());
 	    goto Lerror;
 }
 #if DMDV2
 int AssertExp::canThrow()
 {
-return (global.params.useAssert != 0);
+/* assert()s are non-recoverable errors, so functions that
+* use them can be considered "nothrow"
+*/
+return 0; //(global.params.useAssert != 0);
 }
 #endif
 void AssertExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 }
 else if (e1->type->ty == Tpointer &&
 	     ident != Id::init && ident != Id::__sizeof &&
 	     ident != Id::alignof && ident != Id::offsetof &&
 	     ident != Id::mangleof && ident != Id::stringof)
-{
+{	/* Rewrite:
+*   p.ident
+* as:
+*   (*p).ident
+*/
 	e = new PtrExp(loc, e1);
 	e->type = ((TypePointer *)e1->type)->next;
 	return e->type->dotExp(sc, e, ident);
 }
 #if DMDV2
 	e1 = e1->semantic(sc);
 	type = var->type;
 	if (!type && global.errors)
 	{   // var is goofed up, just return 0
-	    return new IntegerExp(0);
+	    return new ErrorExp();
 	}
 	assert(type);
 	if (!var->isFuncDeclaration())	// for functions, do checks after overload resolution
 	{
 CallExp::CallExp(Loc loc, Expression *e, Expression *earg1)
 	: UnaExp(loc, TOKcall, sizeof(CallExp), e)
 {
 Expressions *arguments = new Expressions();
-arguments->setDim(1);
+if (earg1)
-arguments->data[0] = (void *)earg1;
+{	arguments->setDim(1);
+	arguments->data[0] = (void *)earg1;
+}
 this->arguments = arguments;
 }
 CallExp::CallExp(Loc loc, Expression *e, Expression *earg1, Expression *earg2)
 	: UnaExp(loc, TOKcall, sizeof(CallExp), e)
 *	foo!(tiargs)(funcargs)
 */
 if (e1->op == TOKimport && !e1->type)
 {	ScopeExp *se = (ScopeExp *)e1;
 	TemplateInstance *ti = se->sds->isTemplateInstance();
-	if (ti && !ti->semanticdone)
+	if (ti && !ti->semanticRun)
 	{
 	    /* Attempt to instantiate ti. If that works, go with it.
 	     * If not, go with partial explicit specialization.
 	     */
 	    ti->semanticTiargs(sc);
 *	expr.foo!(tiargs)(funcargs)
 */
 if (e1->op == TOKdotti && !e1->type)
 {	DotTemplateInstanceExp *se = (DotTemplateInstanceExp *)e1;
 	TemplateInstance *ti = se->ti;
-	if (!ti->semanticdone)
+	if (!ti->semanticRun)
 	{
 	    /* Attempt to instantiate ti. If that works, go with it.
 	     * If not, go with partial explicit specialization.
 	     */
 	    ti->semanticTiargs(sc);
 {	AggregateDeclaration *ad;
 	if (t1->ty == Tstruct)
 	{
 	    ad = ((TypeStruct *)t1)->sym;
+#if DMDV2
+	    // First look for constructor
+	    if (ad->ctor && arguments && arguments->dim)
+	    {
+		// Create variable that will get constructed
+		Identifier *idtmp = Lexer::uniqueId("__ctmp");
+		VarDeclaration *tmp = new VarDeclaration(loc, t1, idtmp, NULL);
+		Expression *av = new DeclarationExp(loc, tmp);
+		av = new CommaExp(loc, av, new VarExp(loc, tmp));
+		Expression *e;
+		CtorDeclaration *cf = ad->ctor->isCtorDeclaration();
+		if (cf)
+		    e = new DotVarExp(loc, av, cf, 1);
+		else
+		{   TemplateDeclaration *td = ad->ctor->isTemplateDeclaration();
+		    assert(td);
+		    e = new DotTemplateExp(loc, av, td);
+		}
+		e = new CallExp(loc, e, arguments);
+#if !STRUCTTHISREF
+		/* Constructors return a pointer to the instance
+		 */
+		e = new PtrExp(loc, e);
+#endif
+		e = e->semantic(sc);
+		return e;
+	    }
+#endif
+	    // No constructor, look for overload of opCall
 	    if (search_function(ad, Id::call))
 		goto L1;	// overload of opCall, therefore it's a call
 	    if (e1->op != TOKtype)
 		error("%s %s does not overload ()", ad->kind(), ad->toChars());
 {   // Do overload resolution
 	    dve = (DotVarExp *)(e1);
 	    f = dve->var->isFuncDeclaration();
 	    assert(f);
-	    f = f->overloadResolve(loc, arguments, sc->module);
+	    f = f->overloadResolve(loc, NULL, arguments, sc->module);
 	    ad = f->toParent()->isAggregateDeclaration();
 	}
 else
 {   dte = (DotTemplateExp *)(e1);
 		    if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor))
 			error("multiple constructor calls");
 		    sc->callSuper |= CSXany_ctor | CSXsuper_ctor;
 		}
-		f = f->overloadResolve(loc, arguments, sc->module);
+		f = f->overloadResolve(loc, NULL, arguments, sc->module);
 		checkDeprecated(sc, f);
 #if DMDV2
 		checkPurity(sc, f);
 #endif
 		e1 = new DotVarExp(e1->loc, e1, f);
 		    error("multiple constructor calls");
 		sc->callSuper |= CSXany_ctor | CSXthis_ctor;
 	    }
 	    f = cd->ctor;
-	    f = f->overloadResolve(loc, arguments, sc->module);
+	    f = f->overloadResolve(loc, NULL, arguments, sc->module);
 	    checkDeprecated(sc, f);
 #if DMDV2
 	    checkPurity(sc, f);
 #endif
 	    e1 = new DotVarExp(e1->loc, e1, f);
 		istemp = 1;
 		goto Lagain;
 	    }
 	}
-	f = f->overloadResolve(loc, arguments, sc->module);
+	f = f->overloadResolve(loc, NULL, arguments, sc->module);
 	checkDeprecated(sc, f);
 #if DMDV2
 	checkPurity(sc, f);
 #endif
 }
 #if DMDV2
 int CallExp::canThrow()
 {
+//printf("CallExp::canThrow() %s\n", toChars());
 if (e1->canThrow())
 	return 1;
 /* If any of the arguments can throw, then this expression can throw
 */
 for (size_t i = 0; i < arguments->dim; i++)
 {   Expression *e = (Expression *)arguments->data[i];
-	if (e->canThrow())
+	if (e && e->canThrow())
 	    return 1;
 }
+if (global.errors && !e1->type)
+	return 0;			// error recovery
 /* If calling a function or delegate that is typed as nothrow,
 * then this expression cannot throw.
 * Note that pure functions can throw.
 */
 #endif
 #if DMDV2
 int CallExp::isLvalue()
 {
-if (type->toBasetype()->ty == Tstruct)
+//    if (type->toBasetype()->ty == Tstruct)
-	return 1;
+//	return 1;
 Type *tb = e1->type->toBasetype();
 if (tb->ty == Tfunction && ((TypeFunction *)tb)->isref)
 	return 1;		// function returns a reference
 return 0;
 }
 #endif
 Expression *CallExp::toLvalue(Scope *sc, Expression *e)
 {
+#if 1
 if (type->toBasetype()->ty == Tstruct)
 	return this;
 else
+#endif
 	return Expression::toLvalue(sc, e);
+}
+Expression *CallExp::modifiableLvalue(Scope *sc, Expression *e)
+{
+#if 1
+return Expression::modifiableLvalue(sc, e);
+#else
+/* Although function return values being usable as "ref" parameters is
+* unsound, disabling it breaks existing code.
+* Bugzilla 3167
+*/
+error("cannot assign to function call");
+return toLvalue(sc, e);
+#endif
 }
 void CallExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {   int i;
 	UnaExp::semantic(sc);
 	e1 = e1->toLvalue(sc, NULL);
 	if (!e1->type)
 	{
 	    error("cannot take address of %s", e1->toChars());
-	    type = Type::tint32;
+	    return new ErrorExp();
-	    return this;
+	}
+	if (!e1->type->deco)
+	{
+	    /* No deco means semantic() was not run on the type.
+	     * We have to run semantic() on the symbol to get the right type:
+	     *	auto x = &bar;
+	     *	pure: int bar() { return 1;}
+	     * otherwise the 'pure' is missing from the type assigned to x.
+	     */
+	    error("forward reference to %s", e1->toChars());
+	    return new ErrorExp();
 	}
 	type = e1->type->pointerTo();
 	// See if this should really be a delegate
 	if (e1->op == TOKdotvar)
 /************************************************************/
 PtrExp::PtrExp(Loc loc, Expression *e)
 	: UnaExp(loc, TOKstar, sizeof(PtrExp), e)
 {
-if (e->type)
+//    if (e->type)
-	type = ((TypePointer *)e->type)->next;
+//	type = ((TypePointer *)e->type)->next;
 }
 PtrExp::PtrExp(Loc loc, Expression *e, Type *t)
 	: UnaExp(loc, TOKstar, sizeof(PtrExp), e)
 {
 type = t;
 }
 Expression *PtrExp::semantic(Scope *sc)
-{   Type *tb;
+{
 #if LOGSEMANTIC
 printf("PtrExp::semantic('%s')\n", toChars());
 #endif
-UnaExp::semantic(sc);
+if (!type)
-e1 = resolveProperties(sc, e1);
+{
-if (type)
+	UnaExp::semantic(sc);
-	return this;
+	e1 = resolveProperties(sc, e1);
-if (!e1->type)
+	if (!e1->type)
-	printf("PtrExp::semantic('%s')\n", toChars());
+	    printf("PtrExp::semantic('%s')\n", toChars());
-tb = e1->type->toBasetype();
+	Type *tb = e1->type->toBasetype();
-switch (tb->ty)
+	switch (tb->ty)
-{
+	{
-	case Tpointer:
+	    case Tpointer:
-	    type = tb->next;
+		type = tb->next;
-	    if (type->isbit())
+		break;
-	    {	Expression *e;
+	    case Tsarray:
-		// Rewrite *p as p[0]
+	    case Tarray:
-		e = new IndexExp(loc, e1, new IntegerExp(0));
+		type = tb->next;
-		return e->semantic(sc);
+		e1 = e1->castTo(sc, type->pointerTo());
-	    }
+		break;
-	    break;
+	    default:
-	case Tsarray:
+		error("can only * a pointer, not a '%s'", e1->type->toChars());
-	case Tarray:
+		return new ErrorExp();
-	    type = tb->next;
+	}
-	    e1 = e1->castTo(sc, type->pointerTo());
+	rvalue();
-	    break;
+}
-	default:
-	    error("can only * a pointer, not a '%s'", e1->type->toChars());
-	    type = Type::tint32;
-	    break;
-}
-rvalue();
 return this;
 }
 #if DMDV2
 int PtrExp::isLvalue()
 	e = op_overload(sc);
 	if (e)
 	    return e;
 	e1->checkNoBool();
-	if (e1->op != TOKslice)
+	if (!e1->isArrayOperand())
 	    e1->checkArithmetic();
 	type = e1->type;
 }
 return this;
 }
 	e = op_overload(sc);
 	if (e)
 	    return e;
 	e1->checkNoBool();
-	if (e1->op != TOKslice)
+	if (!e1->isArrayOperand())
 	    e1 = e1->checkIntegral();
 	type = e1->type;
 }
 return this;
 }
 	if (e)
 	{
 	    return e->implicitCastTo(sc, to);
 	}
+	if (e1->op == TOKtemplate)
+	{
+	    error("cannot cast template %s to type %s", e1->toChars(), to->toChars());
+	    return new ErrorExp();
+	}
+	Type *t1b = e1->type->toBasetype();
 	Type *tob = to->toBasetype();
 	if (tob->ty == Tstruct &&
-	    !tob->equals(e1->type->toBasetype()) &&
+	    !tob->equals(t1b) &&
 	    ((TypeStruct *)to)->sym->search(0, Id::call, 0)
 	   )
 	{
 	    /* Look to replace:
 	     *	cast(S)t
 	    e = new TypeExp(loc, to);
 	    e = new DotIdExp(loc, e, Id::call);
 	    e = new CallExp(loc, e, e1);
 	    e = e->semantic(sc);
 	    return e;
+	}
+	// Struct casts are possible only when the sizes match
+	if (tob->ty == Tstruct || t1b->ty == Tstruct)
+	{
+	    size_t fromsize = t1b->size(loc);
+	    size_t tosize = tob->size(loc);
+	    if (fromsize != tosize)
+	    {
+		error("cannot cast from %s to %s", e1->type->toChars(), to->toChars());
+		return new ErrorExp();
+	    }
 	}
 }
 e = e1->castTo(sc, to);
 return e;
 }
 buf->writestring((op == TOKplusplus) ? (char *)"++" : (char *)"--");
 }
 /************************************************************/
-/* Can be TOKconstruct too */
+/* op can be TOKassign, TOKconstruct, or TOKblit */
 AssignExp::AssignExp(Loc loc, Expression *e1, Expression *e2)
 	: BinExp(loc, TOKassign, sizeof(AssignExp), e1, e2)
 {
 ismemset = 0;
 }
 Expression *AssignExp::semantic(Scope *sc)
-{   Type *t1;
+{
 Expression *e1old = e1;
 #if LOGSEMANTIC
 printf("AssignExp::semantic('%s')\n", toChars());
 #endif
 //printf("e1->op = %d, '%s'\n", e1->op, Token::toChars(e1->op));
+//printf("e2->op = %d, '%s'\n", e2->op, Token::toChars(e2->op));
+if (type)
+	return this;
+if (e2->op == TOKcomma)
+{	/* Rewrite to get rid of the comma from rvalue
+	 */
+	AssignExp *ea = new AssignExp(loc, e1, ((CommaExp *)e2)->e2);
+	ea->op = op;
+	Expression *e = new CommaExp(loc, ((CommaExp *)e2)->e1, ea);
+	return e->semantic(sc);
+}
 /* Look for operator overloading of a[i]=value.
 * Do it before semantic() otherwise the a[i] will have been
 * converted to a.opIndex() already.
 */
 if (e1->op == TOKarray)
-{	Type *t1;
+{
 	ArrayExp *ae = (ArrayExp *)e1;
 	AggregateDeclaration *ad;
 	Identifier *id = Id::index;
 	ae->e1 = ae->e1->semantic(sc);
-	t1 = ae->e1->type->toBasetype();
+	Type *t1 = ae->e1->type->toBasetype();
 	if (t1->ty == Tstruct)
 	{
 	    ad = ((TypeStruct *)t1)->sym;
 	    goto L1;
 	}
 	    e = e->semantic(sc);
 	    return e;
 	}
 }
-t1 = e1->type->toBasetype();
+// Determine if this is an initialization of a reference
+int refinit = 0;
+if (op == TOKconstruct && e1->op == TOKvar)
+{	VarExp *ve = (VarExp *)e1;
+	VarDeclaration *v = ve->var->isVarDeclaration();
+	if (v->storage_class & (STCout | STCref))
+	    refinit = 1;
+}
+Type *t1 = e1->type->toBasetype();
 if (t1->ty == Tfunction)
 {	// Rewrite f=value to f(value)
-	Expression *e;
+	Expression *e = new CallExp(loc, e1, e2);
-	e = new CallExp(loc, e1, e2);
 	e = e->semantic(sc);
 	return e;
 }
 /* If it is an assignment from a 'foreign' type,
 else if (e1->op == TOKslice)
 	;
 else
 {	// Try to do a decent error message with the expression
 	// before it got constant folded
-	e1 = e1->modifiableLvalue(sc, e1old);
+	if (op != TOKconstruct)
+	    e1 = e1->modifiableLvalue(sc, e1old);
 }
 if (e1->op == TOKslice &&
 	t1->nextOf() &&
 	e2->implicitConvTo(t1->nextOf())
 )
 {	// memset
 	ismemset = 1;	// make it easy for back end to tell what this is
 	e2 = e2->implicitCastTo(sc, t1->next);
 }
-else if (t1->ty == Tsarray)
+else if (t1->ty == Tsarray && !refinit)
 {
 	error("cannot assign to static array %s", e1->toChars());
 }
 else
 {
 	{
 	    type = e1->type;
 	    typeCombine(sc);
 	    e1->checkArithmetic();
 	    e2->checkArithmetic();
+	    checkComplexAddAssign();
 	    if (type->isreal() || type->isimaginary())
 	    {
 		assert(global.errors || e2->type->isfloating());
 		e2 = e2->castTo(sc, e1->type);
 	    }
 	e = scaleFactor(sc);
 else
 {
 	e1 = e1->checkArithmetic();
 	e2 = e2->checkArithmetic();
+	checkComplexAddAssign();
 	type = e1->type;
 	typeCombine(sc);
 	if (type->isreal() || type->isimaginary())
 	{
 	    assert(e2->type->isfloating());
 e1->checkNoBool();
 type = e1->type;
 typeCombine(sc);
 e1->checkArithmetic();
 e2->checkArithmetic();
+checkComplexMulAssign();
 if (e2->type->isfloating())
 {	Type *t1;
 	Type *t2;
 	t1 = e1->type;
 e1->checkNoBool();
 type = e1->type;
 typeCombine(sc);
 e1->checkArithmetic();
 e2->checkArithmetic();
+checkComplexMulAssign();
 if (e2->type->isimaginary())
 {	Type *t1;
 	Type *t2;
 	t1 = e1->type;
 {
 }
 Expression *ModAssignExp::semantic(Scope *sc)
 {
+BinExp::semantic(sc);
+checkComplexMulAssign();
 return commonSemanticAssign(sc);
 }
 /************************************************************/
 e = op_overload(sc);
 if (e)
 	return e;
 typeCombine(sc);
-if (e1->op != TOKslice && e2->op != TOKslice)
+if (!e1->isArrayOperand())
-{	e1->checkArithmetic();
+	e1->checkArithmetic();
+if (!e2->isArrayOperand())
 	e2->checkArithmetic();
-}
 if (type->isfloating())
 {	Type *t1 = e1->type;
 	Type *t2 = e2->type;
 	if (t1->isreal())
 e = op_overload(sc);
 if (e)
 	return e;
 typeCombine(sc);
-if (e1->op != TOKslice && e2->op != TOKslice)
+if (!e1->isArrayOperand())
-{	e1->checkArithmetic();
+	e1->checkArithmetic();
+if (!e2->isArrayOperand())
 	e2->checkArithmetic();
-}
 if (type->isfloating())
 {	Type *t1 = e1->type;
 	Type *t2 = e2->type;
 	if (t1->isreal())
 e = op_overload(sc);
 if (e)
 	return e;
 typeCombine(sc);
-if (e1->op != TOKslice && e2->op != TOKslice)
+if (!e1->isArrayOperand())
-{	e1->checkArithmetic();
+	e1->checkArithmetic();
+if (!e2->isArrayOperand())
 	e2->checkArithmetic();
-}
 if (type->isfloating())
 {	type = e1->type;
 	if (e2->type->iscomplex())
 	{   error("cannot perform modulo complex arithmetic");
 	    return new IntegerExp(0);
 	    e = this;
 	}
 	else
 	{
 	    typeCombine(sc);
-	    if (e1->op != TOKslice && e2->op != TOKslice)
+	    if (!e1->isArrayOperand())
-	    {   e1->checkIntegral();
+		e1->checkIntegral();
+	    if (!e2->isArrayOperand())
 		e2->checkIntegral();
-	    }
 	}
 }
 return this;
 }
 	    e = this;
 	}
 	else
 	{
 	    typeCombine(sc);
-	    if (e1->op != TOKslice && e2->op != TOKslice)
+	    if (!e1->isArrayOperand())
-	    {   e1->checkIntegral();
+		e1->checkIntegral();
+	    if (!e2->isArrayOperand())
 		e2->checkIntegral();
-	    }
 	}
 }
 return this;
 }
 	    e = this;
 	}
 	else
 	{
 	    typeCombine(sc);
-	    if (e1->op != TOKslice && e2->op != TOKslice)
+	    if (!e1->isArrayOperand())
-	    {   e1->checkIntegral();
+		e1->checkIntegral();
+	    if (!e2->isArrayOperand())
 		e2->checkIntegral();
-	    }
 	}
 }
 return this;
 }
 {
 }
 Expression *CmpExp::semantic(Scope *sc)
 {   Expression *e;
-Type *t1;
-Type *t2;
 #if LOGSEMANTIC
 printf("CmpExp::semantic('%s')\n", toChars());
 #endif
 if (type)
 	return this;
 BinExp::semanticp(sc);
-if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull ||
+Type *t1 = e1->type->toBasetype();
-	e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull)
+Type *t2 = e2->type->toBasetype();
+if (t1->ty == Tclass && e2->op == TOKnull ||
+	t2->ty == Tclass && e1->op == TOKnull)
 {
 	error("do not use null when comparing class types");
 }
 e = op_overload(sc);
 	else
 	{   e = new CmpExp(op, loc, e, new IntegerExp(loc, 0, Type::tint32));
 	    e = e->semantic(sc);
 	}
 	return e;
+}
+/* Disallow comparing T[]==T and T==T[]
+*/
+if (e1->op == TOKslice && t1->ty == Tarray && e2->implicitConvTo(t1->nextOf()) ||
+	e2->op == TOKslice && t2->ty == Tarray && e1->implicitConvTo(t2->nextOf()))
+{
+	incompatibleTypes();
+	return new ErrorExp();
 }
 typeCombine(sc);
 type = Type::tboolean;
 assert(op == TOKequal || op == TOKnotequal);
 }
 Expression *EqualExp::semantic(Scope *sc)
 {   Expression *e;
-Type *t1;
-Type *t2;
 //printf("EqualExp::semantic('%s')\n", toChars());
 if (type)
 	return this;
 		return e;
 	    }
 	}
 }
-if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull ||
+Type *t1 = e1->type->toBasetype();
-	e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull)
+Type *t2 = e2->type->toBasetype();
+if (t1->ty == Tclass && e2->op == TOKnull ||
+	t2->ty == Tclass && e1->op == TOKnull)
 {
 	error("use '%s' instead of '%s' when comparing with null",
 		Token::toChars(op == TOKequal ? TOKidentity : TOKnotidentity),
 		Token::toChars(op));
 }
 		e = new NotExp(e->loc, e);
 		e = e->semantic(sc);
 	    }
 	    return e;
 	}
+}
+/* Disallow comparing T[]==T and T==T[]
+*/
+if (e1->op == TOKslice && t1->ty == Tarray && e2->implicitConvTo(t1->nextOf()) ||
+	e2->op == TOKslice && t2->ty == Tarray && e1->implicitConvTo(t2->nextOf()))
+{
+	incompatibleTypes();
+	return new ErrorExp();
 }
 e = typeCombine(sc);
 type = Type::tboolean;

Mercurial > projects > ldc

comparison dmd/expression.c @ 1587:def7a1d494fd