projects/ldc: dmd/expression.c comparison

comparison dmd/expression.c @ 336:aaade6ded589 trunk

[svn r357] Merged DMD 1.033

author	lindquist
date	Sat, 12 Jul 2008 19:38:31 +0200
parents	7086a84ab3d6
children	62715be72a06

comparison

equal deleted inserted replaced

-:17b844102023
+:aaade6ded589
 precedence[TOKtypeid] = PREC_primary;
 precedence[TOKis] = PREC_primary;
 precedence[TOKassert] = PREC_primary;
 precedence[TOKfunction] = PREC_primary;
 precedence[TOKvar] = PREC_primary;
+#if DMDV2
+precedence[TOKdefault] = PREC_primary;
+#endif
 // post
 precedence[TOKdotti] = PREC_primary;
 precedence[TOKdot] = PREC_primary;
 //  precedence[TOKarrow] = PREC_primary;
 precedence[TOKxorass] = PREC_assign;
 precedence[TOKcomma] = PREC_expr;
 }
+/*************************************************************
+* Given var, we need to get the
+* right 'this' pointer if var is in an outer class, but our
+* existing 'this' pointer is in an inner class.
+* Input:
+*	e1	existing 'this'
+*	ad	struct or class we need the correct 'this' for
+*	var	the specific member of ad we're accessing
+*/
+Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad,
+	Expression *e1, Declaration *var)
+{
+//printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars());
+L1:
+Type *t = e1->type->toBasetype();
+//printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars());
+/* If e1 is not the 'this' pointer for ad
+*/
+if (ad &&
+	!(t->ty == Tpointer && t->nextOf()->ty == Tstruct &&
+	  ((TypeStruct *)t->nextOf())->sym == ad)
+	&&
+	!(t->ty == Tstruct &&
+	  ((TypeStruct *)t)->sym == ad)
+)
+{
+	ClassDeclaration *cd = ad->isClassDeclaration();
+	ClassDeclaration *tcd = t->isClassHandle();
+	/* e1 is the right this if ad is a base class of e1
+	 */
+	if (!cd || !tcd ||
+	    !(tcd == cd || cd->isBaseOf(tcd, NULL))
+	   )
+	{
+	    /* Only classes can be inner classes with an 'outer'
+	     * member pointing to the enclosing class instance
+	     */
+	    if (tcd && tcd->isNested())
+	    {   /* e1 is the 'this' pointer for an inner class: tcd.
+		 * Rewrite it as the 'this' pointer for the outer class.
+		 */
+		e1 = new DotVarExp(loc, e1, tcd->vthis);
+		e1->type = tcd->vthis->type;
+		// Do not call checkNestedRef()
+		//e1 = e1->semantic(sc);
+		// Skip up over nested functions, and get the enclosing
+		// class type.
+		int n = 0;
+		Dsymbol *s;
+		for (s = tcd->toParent();
+		     s && s->isFuncDeclaration();
+		     s = s->toParent())
+		{   FuncDeclaration *f = s->isFuncDeclaration();
+		    if (f->vthis)
+		    {
+			//printf("rewriting e1 to %s's this\n", f->toChars());
+			n++;
+			e1 = new VarExp(loc, f->vthis);
+		    }
+		}
+		if (s && s->isClassDeclaration())
+		{   e1->type = s->isClassDeclaration()->type;
+		    if (n > 1)
+			e1 = e1->semantic(sc);
+		}
+		else
+		    e1 = e1->semantic(sc);
+		goto L1;
+	    }
+	    /* Can't find a path from e1 to ad
+	     */
+	    e1->error("this for %s needs to be type %s not type %s",
+		var->toChars(), ad->toChars(), t->toChars());
+	}
+}
+return e1;
+}
 /*****************************************
 * Determine if 'this' is available.
 * If it is, return the FuncDeclaration that has it.
 */
 #endif
 	}
 }
 }
+/*********************************************
+* Call copy constructor for struct value argument.
+*/
+#if DMDV2
+Expression *callCpCtor(Loc loc, Scope *sc, Expression *e)
+{
+Type *tb = e->type->toBasetype();
+assert(tb->ty == Tstruct);
+StructDeclaration *sd = ((TypeStruct *)tb)->sym;
+if (sd->cpctor)
+{
+	/* Create a variable tmp, and replace the argument e with:
+	 *	(tmp = e),tmp
+	 * and let AssignExp() handle the construction.
+	 * This is not the most efficent, ideally tmp would be constructed
+	 * directly onto the stack.
+	 */
+	Identifier *idtmp = Lexer::uniqueId("__tmp");
+	VarDeclaration *tmp = new VarDeclaration(loc, tb, idtmp, new ExpInitializer(0, e));
+	Expression *ae = new DeclarationExp(loc, tmp);
+	e = new CommaExp(loc, ae, new VarExp(loc, tmp));
+	e = e->semantic(sc);
+}
+return e;
+}
+#endif
 /****************************************
 * Now that we know the exact type of the function we're calling,
 * the arguments[] need to be adjusted:
 *	1) implicitly convert argument to the corresponding parameter type
 		    if (tf->varargs == 2 && i + 1 == nparams)
 			goto L2;
 error(loc, "expected %"PRIuSIZE" arguments, not %"PRIuSIZE, nparams, nargs);
 		    break;
 		}
-		arg = p->defaultArg->copy();
+		arg = p->defaultArg;
+#if DMDV2
+		if (arg->op == TOKdefault)
+		{   DefaultInitExp *de = (DefaultInitExp *)arg;
+		    arg = de->resolve(loc, sc);
+		}
+		else
+#endif
+		    arg = arg->copy();
 		arguments->push(arg);
 		nargs++;
 	    }
 	    if (tf->varargs == 2 && i + 1 == nparams)
 	    // Convert static arrays to dynamic arrays
 	    tb = arg->type->toBasetype();
 	    if (tb->ty == Tsarray)
 	    {	TypeSArray *ts = (TypeSArray *)tb;
-		Type *ta = tb->next->arrayOf();
+		Type *ta = ts->next->arrayOf();
 		if (ts->size(arg->loc) == 0)
 		{   arg = new NullExp(arg->loc);
 		    arg->type = ta;
 		}
 		else
 		    arg = arg->castTo(sc, ta);
 	    }
+#if DMDV2
+	    if (tb->ty == Tstruct)
+	    {
+		arg = callCpCtor(loc, sc, arg);
+	    }
+	    // Give error for overloaded function addresses
+	    if (arg->op == TOKsymoff)
+	    {	SymOffExp *se = (SymOffExp *)arg;
+		if (se->hasOverloads && !se->var->isFuncDeclaration()->isUnique())
+		    arg->error("function %s is overloaded", arg->toChars());
+	    }
+#endif
 	    arg->rvalue();
 	}
 	arg = arg->optimize(WANTvalue);
 	arguments->data[i] = (void *) arg;
 	if (done)
 * in ( ) if its precedence is less than pr.
 */
 void expToCBuffer(OutBuffer *buf, HdrGenState *hgs, Expression *e, enum PREC pr)
 {
+//if (precedence[e->op] == 0) e->dump(0);
 if (precedence[e->op] < pr)
 {
 	buf->writeByte('(');
 	e->toCBuffer(buf, hgs);
 	buf->writeByte(')');
 */
 Expression *Expression::semantic(Scope *sc)
 {
 #if LOGSEMANTIC
-printf("Expression::semantic()\n");
+printf("Expression::semantic() %s\n", toChars());
 #endif
 if (type)
 	type = type->semantic(loc, sc);
 else
 	type = Type::tvoid;
 {	error("expression %s is void and has no value", toChars());
 #if 0
 	dump(0);
 	halt();
 #endif
+	type = Type::tint32;
 }
 }
 Expression *Expression::combine(Expression *e1, Expression *e2)
 {
 {	TypeSArray *ts = (TypeSArray *)tb;
 	if (ts->size(loc) == 0)
 	    e = new NullExp(loc);
 	else
 	    e = new AddrExp(loc, this);
-	e->type = tb->next->pointerTo();
+	e->type = ts->next->pointerTo();
 }
 return e;
 }
 /******************************
 //printf("Expression::deref()\n");
 if (type->ty == Treference)
 {	Expression *e;
 	e = new PtrExp(loc, this);
-	e->type = type->next;
+	e->type = ((TypeReference *)type)->next;
 	return e;
 }
 return this;
 }
 int Expression::isBit()
 {
 return FALSE;
 }
+/********************************
+* Can this expression throw an exception?
+* Valid only after semantic() pass.
+*/
+int Expression::canThrow()
+{
+return TRUE;
+}
 Expressions *Expression::arraySyntaxCopy(Expressions *exps)
 {   Expressions *a = NULL;
 if (exps)
 	: Expression(loc, TOKint64, sizeof(IntegerExp))
 {
 //printf("IntegerExp(value = %lld, type = '%s')\n", value, type ? type->toChars() : "");
 if (type && !type->isscalar())
 {
+	//printf("%s, loc = %d\n", toChars(), loc.linnum);
 	error("integral constant must be scalar type, not %s", type->toChars());
 	type = Type::terror;
 }
 this->type = type;
 this->value = value;
 		t = tt->sym->basetype;
 		continue;
 	    }
 	    default:
-		print();
+		/* This can happen if errors, such as
-		type->print();
+		 * the type is painted on like in fromConstInitializer().
-		assert(0);
+		 */
+		if (!global.errors)
+		{   type->print();
+		    assert(0);
+		}
 		break;
 	}
 	break;
 }
 return value;
 		buf->writestring(t->toChars());
 		buf->writeByte(')');
 		goto L3;
 	    default:
+		/* This can happen if errors, such as
+		 * the type is painted on like in fromConstInitializer().
+		 */
+		if (!global.errors)
+		{
 #ifdef DEBUG
-		t->print();
+		    t->print();
 #endif
-		assert(0);
+		    assert(0);
+		}
+		break;
 	}
 }
 else if (v & 0x8000000000000000LL)
 	buf->printf("0x%llx", v);
 else
 	fdthis->getLevel(loc, fd);
 	fd->vthis->nestedref = 1;
 	fd->nestedFrameRef = 1;
 }
 #endif
-sc->callSuper |= CSXthis;
+if (!sc->intypeof)
+	sc->callSuper |= CSXthis;
 return this;
 Lerr:
 error("'this' is only allowed in non-static member functions, not %s", sc->parent->toChars());
 type = Type::tint32;
 	fd->vthis->nestedref = 1;
 	fd->nestedFrameRef = 1;
 }
 #endif
-sc->callSuper |= CSXsuper;
+if (!sc->intypeof)
+	sc->callSuper |= CSXsuper;
 return this;
 Lerr:
 error("'super' is only allowed in non-static class member functions");
 Expression *NewAnonClassExp::semantic(Scope *sc)
 {
 #if LOGSEMANTIC
 printf("NewAnonClassExp::semantic() %s\n", toChars());
+//printf("thisexp = %p\n", thisexp);
 //printf("type: %s\n", type->toChars());
 #endif
 Expression *d = new DeclarationExp(loc, cd);
 d = d->semantic(sc);
 #if LOGSEMANTIC
 printf("TypeidExp::semantic()\n");
 #endif
 typeidType = typeidType->semantic(loc, sc);
 e = typeidType->getTypeInfo(sc);
+if (e->loc.linnum == 0)
+	e->loc = loc;		// so there's at least some line number info
 return e;
 }
 void TypeidExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 	    buf->writestring(" : ");
 	else
 	    buf->writestring(" == ");
 	tspec->toCBuffer(buf, NULL, hgs);
 }
-#if V2
+#if DMDV2
 if (parameters)
 {	// First parameter is already output, so start with second
 	for (int i = 1; i < parameters->dim; i++)
 	{
 	    buf->writeByte(',');
 	    if (t)
 	    {
 		return new TypeExp(loc, t);
 	    }
+	    TupleDeclaration *tup = s->isTupleDeclaration();
+	    if (tup)
+	    {
+		if (eleft)
+		    error("cannot have e.tuple");
+		e = new TupleExp(loc, tup);
+		e = e->semantic(sc);
+		return e;
+	    }
 	    ScopeDsymbol *sds = s->isScopeDsymbol();
 	    if (sds)
 	    {
 		//printf("it's a ScopeDsymbol\n");
 		e = new ScopeExp(loc, sds);
 	assert(type);
 	if (!var->isFuncDeclaration())	// for functions, do checks after overload resolution
 	{
 	    AggregateDeclaration *ad = var->toParent()->isAggregateDeclaration();
-	L1:
+	    e1 = getRightThis(loc, sc, ad, e1, var);
-	    Type *t = e1->type->toBasetype();
+	    if (!sc->noaccesscheck)
+		accessCheck(loc, sc, e1, var);
-	    if (ad &&
-		!(t->ty == Tpointer && t->next->ty == Tstruct &&
+	    VarDeclaration *v = var->isVarDeclaration();
-		  ((TypeStruct *)t->next)->sym == ad)
+	    if (v && v->isConst())
-		&&
+	    {	ExpInitializer *ei = v->getExpInitializer();
-		!(t->ty == Tstruct &&
+		if (ei)
-		  ((TypeStruct *)t)->sym == ad)
+		{   Expression *e = ei->exp->copy();
-	       )
+		    e = e->semantic(sc);
-	    {
+		    return e;
-		ClassDeclaration *cd = ad->isClassDeclaration();
-		ClassDeclaration *tcd = t->isClassHandle();
-		if (!cd || !tcd ||
-		    !(tcd == cd || cd->isBaseOf(tcd, NULL))
-		   )
-		{
-		    if (tcd && tcd->isNested())
-		    {	// Try again with outer scope
-			e1 = new DotVarExp(loc, e1, tcd->vthis);
-			e1 = e1->semantic(sc);
-			// Skip over nested functions, and get the enclosing
-			// class type.
-			Dsymbol *s = tcd->toParent();
-			while (s && s->isFuncDeclaration())
-			{   FuncDeclaration *f = s->isFuncDeclaration();
-			    if (f->vthis)
-			    {
-				e1 = new VarExp(loc, f->vthis);
-			    }
-			    s = s->toParent();
-			}
-			if (s && s->isClassDeclaration())
-			    e1->type = s->isClassDeclaration()->type;
-			e1 = e1->semantic(sc);
-			goto L1;
-		    }
-#ifdef DEBUG
-		    printf("2: ");
-#endif
-		    error("this for %s needs to be type %s not type %s",
-			var->toChars(), ad->toChars(), t->toChars());
 		}
 	    }
-	    accessCheck(loc, sc, e1, var);
 	}
 }
 //printf("-DotVarExp::semantic('%s')\n", toChars());
 return this;
 }
 }
 e = e->semantic(sc);
 return e;
 Lerr:
-return new IntegerExp(0);
+return new IntegerExp(loc, 0, Type::tint32);
 }
 void DotTemplateInstanceExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 expToCBuffer(buf, hgs, e1, PREC_primary);
 if (!type)
 {
 	e1 = e1->semantic(sc);
 	type = new TypeDelegate(func->type);
 	type = type->semantic(loc, sc);
-//-----------------
-	/* For func, we need to get the
-	 * right 'this' pointer if func 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().
-	 */
 	AggregateDeclaration *ad = func->toParent()->isAggregateDeclaration();
-L10:
+	if (func->needThis())
-	Type *t = e1->type;
+	    e1 = getRightThis(loc, sc, ad, e1, func);
-	if (func->needThis() && ad &&
-	    !(t->ty == Tpointer && t->next->ty == Tstruct &&
-	      ((TypeStruct *)t->next)->sym == ad) &&
-	    !(t->ty == Tstruct && ((TypeStruct *)t)->sym == ad)
-	   )
-	{
-	    ClassDeclaration *cd = ad->isClassDeclaration();
-	    ClassDeclaration *tcd = t->isClassHandle();
-	    if (!cd || !tcd ||
-		!(tcd == cd || cd->isBaseOf(tcd, NULL))
-	       )
-	    {
-		if (tcd && tcd->isNested())
-		{   // Try again with outer scope
-		    e1 = new DotVarExp(loc, e1, tcd->vthis);
-		    e1 = e1->semantic(sc);
-		    goto L10;
-		}
-#ifdef DEBUG
-		printf("3: ");
-#endif
-		error("this for %s needs to be type %s not type %s",
-		    func->toChars(), ad->toChars(), t->toChars());
-	    }
-	}
-//-----------------
 }
 return this;
 }
 void DelegateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 	DotVarExp *dve;
 	DotTemplateExp *dte;
 	AggregateDeclaration *ad;
 	UnaExp *ue = (UnaExp *)(e1);
 	if (e1->op == TOKdotvar)
 {   // Do overload resolution
 	    dve = (DotVarExp *)(e1);
 	    f = dve->var->isFuncDeclaration();
 	    {	type = Type::terror;
 		return this;
 	    }
 	    ad = td->toParent()->isAggregateDeclaration();
 	}
-	/* Now that we have the right function f, we need to get the
+	if (f->needThis())
-	 * right 'this' pointer if f is in an outer class, but our
+	{
-	 * existing 'this' pointer is in an inner class.
+	    ue->e1 = getRightThis(loc, sc, ad, ue->e1, f);
-	 * This code is analogous to that used for variables
+	}
-	 * in DotVarExp::semantic().
+	/* Cannot call public functions from inside invariant
+	 * (because then the invariant would have infinite recursion)
 	 */
-L10:
+	if (sc->func && sc->func->isInvariantDeclaration() &&
-	Type *t = ue->e1->type->toBasetype();
+	    ue->e1->op == TOKthis &&
-	if (f->needThis() && ad &&
+	    f->addPostInvariant()
-	    !(t->ty == Tpointer && t->next->ty == Tstruct &&
-	      ((TypeStruct *)t->next)->sym == ad) &&
-	    !(t->ty == Tstruct && ((TypeStruct *)t)->sym == ad)
 	   )
 	{
-	    ClassDeclaration *cd = ad->isClassDeclaration();
+	    error("cannot call public/export function %s from invariant", f->toChars());
-	    ClassDeclaration *tcd = t->isClassHandle();
-	    if (!cd || !tcd ||
-		!(tcd == cd || cd->isBaseOf(tcd, NULL))
-	       )
-	    {
-		if (tcd && tcd->isNested())
-		{   // Try again with outer scope
-		    ue->e1 = new DotVarExp(loc, ue->e1, tcd->vthis);
-		    ue->e1 = ue->e1->semantic(sc);
-		    goto L10;
-		}
-#ifdef DEBUG
-		printf("1: ");
-#endif
-		error("this for %s needs to be type %s not type %s",
-		    f->toChars(), ad->toChars(), t->toChars());
-	    }
 	}
 	checkDeprecated(sc, f);
 	accessCheck(loc, sc, ue->e1, f);
 	if (!f->needThis())
 		type = Type::terror;
 		return this;
 	    }
 	    else
 	    {
+		if (!sc->intypeof)
+		{
 #if 0
-		if (sc->callSuper & (CSXthis | CSXsuper))
+		    if (sc->callSuper & (CSXthis | CSXsuper))
-		    error("reference to this before super()");
+			error("reference to this before super()");
 #endif
-		if (sc->noctor || sc->callSuper & CSXlabel)
+		    if (sc->noctor || sc->callSuper & CSXlabel)
-		    error("constructor calls not allowed in loops or after labels");
+			error("constructor calls not allowed in loops or after labels");
-		if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor))
+		    if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor))
-		    error("multiple constructor calls");
+			error("multiple constructor calls");
-		sc->callSuper |= CSXany_ctor | CSXsuper_ctor;
+		    sc->callSuper |= CSXany_ctor | CSXsuper_ctor;
+		}
 		f = f->overloadResolve(loc, arguments);
 		checkDeprecated(sc, f);
 		e1 = new DotVarExp(e1->loc, e1, f);
 		e1 = e1->semantic(sc);
 	    type = Type::terror;
 	    return this;
 	}
 	else
 	{
+	    if (!sc->intypeof)
+	    {
 #if 0
-	    if (sc->callSuper & (CSXthis | CSXsuper))
+		if (sc->callSuper & (CSXthis | CSXsuper))
-		error("reference to this before super()");
+		    error("reference to this before super()");
 #endif
-	    if (sc->noctor || sc->callSuper & CSXlabel)
+		if (sc->noctor || sc->callSuper & CSXlabel)
-		error("constructor calls not allowed in loops or after labels");
+		    error("constructor calls not allowed in loops or after labels");
-	    if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor))
+		if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor))
-		error("multiple constructor calls");
+		    error("multiple constructor calls");
-	    sc->callSuper |= CSXany_ctor | CSXthis_ctor;
+		sc->callSuper |= CSXany_ctor | CSXthis_ctor;
+	    }
 	    f = cd->ctor;
 	    f = f->overloadResolve(loc, arguments);
 	    checkDeprecated(sc, f);
 	    e1 = new DotVarExp(e1->loc, e1, f);

Mercurial > projects > ldc

comparison dmd/expression.c @ 336:aaade6ded589 trunk