projects/ldc: dmd/expression.c comparison

comparison dmd/expression.c @ 1618:a87f1d6ff48e

Merge DMD r303: harmonize --- dmd/expression.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++----- dmd/expression.h | 8 +++++ dmd/template.c | 27 ++++++++++++------- 3 files changed, 95 insertions(+), 18 deletions(-)

author	Leandro Lucarella <llucax@gmail.com>
date	Wed, 06 Jan 2010 15:18:21 -0300
parents	c94049033c20
children	c61782a76dff

comparison

equal deleted inserted replaced

-:6820110de311
+:a87f1d6ff48e
 void Expression::checkEscape()
 {
 }
+void Expression::checkEscapeRef()
+{
+}
 void Expression::checkScalar()
 {
 if (!type->isscalar())
 	error("'%s' is not a scalar, it is a %s", toChars(), type->toChars());
 }
 Expression *Expression::checkIntegral()
 {
 if (!type->isintegral())
 {	error("'%s' is not of integral type, it is a %s", toChars(), type->toChars());
-	return new IntegerExp(0);
+	return new ErrorExp();
 }
 return this;
 }
 Expression *Expression::checkArithmetic()
 {
 if (!type->isintegral() && !type->isfloating())
 {	error("'%s' is not of arithmetic type, it is a %s", toChars(), type->toChars());
-	return new IntegerExp(0);
+	return new ErrorExp();
 }
 return this;
 }
 void Expression::checkDeprecated(Scope *sc, Dsymbol *s)
 void SymOffExp::checkEscape()
 {
 VarDeclaration *v = var->isVarDeclaration();
 if (v)
 {
-	if (!v->isDataseg())
+	if (!v->isDataseg() && !(v->storage_class & (STCref | STCout)))
-	    error("escaping reference to local variable %s", v->toChars());
+	{   /* BUG: This should be allowed:
+	     *   void foo()
+	     *   { int a;
+	     *     int* bar() { return &a; }
+	     *   }
+	     */
+	    error("escaping reference to local %s", v->toChars());
+	}
 }
 }
 void SymOffExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 	    type = new TypeDelegate(tf);
 	    type = type->semantic(loc, sc);
 	}
 #endif
 }
 /* Fix for 1161 doesn't work because it causes protection
 * problems when instantiating imported templates passing private
 * variables as alias template parameters.
 */
 //accessCheck(loc, sc, NULL, var);
 	e = new FuncExp(loc, fd);
 	e->type = type;
 	return e;
 }
 #endif
 return this;
 }
 char *VarExp::toChars()
 {
 	    if (v->isScope() && !v->noscope)
 		error("escaping reference to scope local %s", v->toChars());
 	    else if (v->storage_class & STCvariadic)
 		error("escaping reference to variadic parameter %s", v->toChars());
 	}
+}
+}
+void VarExp::checkEscapeRef()
+{
+VarDeclaration *v = var->isVarDeclaration();
+if (v)
+{
+	if (!v->isDataseg() && !(v->storage_class & (STCref | STCout)))
+	    error("escaping reference to local variable %s", v->toChars());
 }
 }
 #if DMDV2
 int VarExp::isLvalue()
 		break;
 	    case TOKinvariant:
 	    case TOKimmutable:
 		if (!targ->isInvariant())
+		    goto Lno;
+		tded = targ;
+		break;
+	    case TOKshared:
+		if (!targ->isShared())
 		    goto Lno;
 		tded = targ;
 		break;
 #endif
 	dedtypes.data[0] = NULL;
 	m = targ->deduceType(NULL, tspec, &parameters, &dedtypes);
 	if (m == MATCHnomatch ||
 	    (m != MATCHexact && tok == TOKequal))
+	{
 	    goto Lno;
+	}
 	else
 	{
 	    assert(dedtypes.dim == 1);
 	    tded = (Type *)dedtypes.data[0];
 	    if (!tded)
 	goto Lyes;
 }
 else if (tspec)
 {
 	/* Evaluate to TRUE if targ matches tspec
+	 * is(targ == tspec)
+	 * is(targ : tspec)
 	 */
 	tspec = tspec->semantic(loc, sc);
 	//printf("targ  = %s\n", targ->toChars());
 	//printf("tspec = %s\n", tspec->toChars());
 	if (tok == TOKcolon)
 * as:
 *   .ident(e1)
 */
 	unsigned errors = global.errors;
 	global.gag++;
+	Type *t1 = e1->type;
 	e = e1->type->dotExp(sc, e1, ident);
 	global.gag--;
 	if (errors != global.errors)	// if failed to find the property
 	{
 	    global.errors = errors;
+	    e1->type = t1;		// kludge to restore type
 	    e = new DotIdExp(loc, new IdentifierExp(loc, Id::empty), ident);
 	    e = new CallExp(loc, e, e1);
 	}
 	e = e->semantic(sc);
 	return e;
 	    (t1->ty == Tpointer && !t1->nextOf()->isMutable()) ||
 	    !var->type->isMutable() ||
 	    !var->type->isAssignable() ||
 	    var->storage_class & STCmanifest
 	   )
-	    error("cannot modify const/invariant %s", toChars());
+	    error("cannot modify const/immutable expression %s", toChars());
 }
 #endif
 return this;
 }
 	return optimize(WANTvalue);
 }
 return this;
 }
+void AddrExp::checkEscape()
+{
+e1->checkEscapeRef();
+}
 /************************************************************/
 PtrExp::PtrExp(Loc loc, Expression *e)
 	: UnaExp(loc, TOKstar, sizeof(PtrExp), e)
 {
 int PtrExp::isLvalue()
 {
 return 1;
 }
 #endif
+void PtrExp::checkEscapeRef()
+{
+e1->checkEscape();
+}
 Expression *PtrExp::toLvalue(Scope *sc, Expression *e)
 {
 #if 0
 tym = tybasic(e1->ET->Tty);
 	}
 	return e;
 }
 if (t->ty == Tarray)
+{
 	type = e1->type;
+}
 else
 	type = t->nextOf()->arrayOf();
 return e;
 Lerror:
 if (t->ty == Tvoid)
 	s = e1->toChars();
 else
 	s = t->toChars();
 error("%s cannot be sliced with []", s);
-e = new IntegerExp(0);
+e = new ErrorExp();
 return e;
 }
 void SliceExp::checkEscape()
 {
 e1->checkEscape();
+}
+void SliceExp::checkEscapeRef()
+{
+e1->checkEscapeRef();
 }
 #if DMDV2
 int SliceExp::isLvalue()
 {
 	: UnaExp(loc, TOKarraylength, sizeof(ArrayLengthExp), e1)
 {
 }
 Expression *ArrayLengthExp::semantic(Scope *sc)
-{   Expression *e;
+{
 #if LOGSEMANTIC
 printf("ArrayLengthExp::semantic('%s')\n", toChars());
 #endif
 if (!type)
 {
 }
 void CommaExp::checkEscape()
 {
 e2->checkEscape();
+}
+void CommaExp::checkEscapeRef()
+{
+e2->checkEscapeRef();
 }
 #if DMDV2
 int CommaExp::isLvalue()
 {
 {
 e1->checkEscape();
 e2->checkEscape();
 }
+void CondExp::checkEscapeRef()
+{
+e1->checkEscapeRef();
+e2->checkEscapeRef();
+}
 Expression *CondExp::checkToBoolean()
 {
 e1 = e1->checkToBoolean();
 e2 = e2->checkToBoolean();

Mercurial > projects > ldc

comparison dmd/expression.c @ 1618:a87f1d6ff48e