projects/ldc: dmd/func.c comparison

comparison dmd/func.c @ 1630:44b145be2ef5

Merge dmd 1.056.

author	Robert Clipsham <robert@octarineparrot.com>
date	Sat, 06 Feb 2010 15:53:52 +0000
parents	6820110de311
children	9bf06e02070b

comparison

equal deleted inserted replaced

-:b07d683ba4d0
+:44b145be2ef5
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2009 by Digital Mars
+// Copyright (c) 1999-2010 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.
 naked = 0;
 inlineStatus = ILSuninitialized;
 inlineNest = 0;
 inlineAsm = 0;
 cantInterpret = 0;
-semanticRun = 0;
+semanticRun = PASSinit;
 #if DMDV1
 nestedFrameRef = 0;
 #endif
 fes = NULL;
 introducing = 0;
 f->frequire = frequire ? frequire->syntaxCopy() : NULL;
 f->fensure  = fensure  ? fensure->syntaxCopy()  : NULL;
 f->fbody    = fbody    ? fbody->syntaxCopy()    : NULL;
 assert(!fthrows); // deprecated
-// LDC
+#if IN_LLVM
 f->intrinsicName = intrinsicName;
+#endif
 return f;
 }
 	printf("\tFuncLiteralDeclaration()\n");
 printf("sc->parent = %s, parent = %s\n", sc->parent->toChars(), parent ? parent->toChars() : "");
 printf("type: %p, %s\n", type, type->toChars());
 #endif
-if (semanticRun && isFuncLiteralDeclaration())
+if (semanticRun != PASSinit && isFuncLiteralDeclaration())
 {
 	/* Member functions that have return types that are
 	 * forward references can have semantic() run more than
 	 * once on them.
 	 * See test\interface2.d, test20
 	 */
 	return;
 }
-assert(semanticRun <= 1);
+parent = sc->parent;
-semanticRun = 1;
+Dsymbol *parent = toParent();
+if (semanticRun == PASSsemanticdone)
+{
+	if (!parent->isClassDeclaration())
+	    return;
+	// need to re-run semantic() in order to set the class's vtbl[]
+}
+else
+{
+	assert(semanticRun <= PASSsemantic);
+	semanticRun = PASSsemantic;
+}
+unsigned dprogress_save = Module::dprogress;
+foverrides.setDim(0);	// reset in case semantic() is being retried for this function
 if (!type->deco)
 {
 	type = type->semantic(loc, sc);
 }
 }
 f = (TypeFunction *)(type);
 size_t nparams = Parameter::dim(f->parameters);
 linkage = sc->linkage;
-//    if (!parent)
-{
-	//parent = sc->scopesym;
-	parent = sc->parent;
-}
 protection = sc->protection;
 storage_class |= sc->stc;
 //printf("function storage_class = x%x\n", storage_class);
-Dsymbol *parent = toParent();
 if (ident == Id::ctor && !isCtorDeclaration())
 	error("_ctor is reserved for constructors");
 if (isConst() || isAuto() || isScope())
 #endif
 	    isDtorDeclaration() ||
 	    isInvariantDeclaration() ||
 	    isUnitTestDeclaration() || isNewDeclaration() || isDelete())
 	    error("special function not allowed in interface %s", id->toChars());
-	if (fbody)
+	if (fbody && isVirtual())
 	    error("function body is not abstract in interface %s", id->toChars());
 }
 /* Template member functions aren't virtual:
 *   interface TestInterface { void tpl(T)(); }
 	{
 	    //printf("\tnot virtual\n");
 	    goto Ldone;
 	}
-	// Find index of existing function in vtbl[] to override
+	/* Find index of existing function in base class's vtbl[] to override
-	vi = findVtblIndex(&cd->vtbl, cd->baseClass ? cd->baseClass->vtbl.dim : 0);
+	 * (the index will be the same as in cd's current vtbl[])
+	 */
+	vi = cd->baseClass ? findVtblIndex(&cd->baseClass->vtbl, cd->baseClass->vtbl.dim)
+			   : -1;
 	switch (vi)
 	{
 	    case -1:
 		/* Didn't find one, so
 		 * This is an 'introducing' function which gets a new
 		}
 		break;
 	    case -2:	// can't determine because of fwd refs
 		cd->sizeok = 2;	// can't finish due to forward reference
+		Module::dprogress = dprogress_save;
 		return;
 	    default:
-	    {   FuncDeclaration *fdv = (FuncDeclaration *)cd->vtbl.data[vi];
+	    {   FuncDeclaration *fdv = (FuncDeclaration *)cd->baseClass->vtbl.data[vi];
 		// This function is covariant with fdv
 		if (fdv->isFinal())
 		    error("cannot override final function %s", fdv->toPrettyChars());
 #if DMDV2
 		case -1:
 		    break;
 		case -2:
 		    cd->sizeok = 2;	// can't finish due to forward reference
+		    Module::dprogress = dprogress_save;
 		    return;
 		default:
 		{   FuncDeclaration *fdv = (FuncDeclaration *)b->base->vtbl.data[vi];
 		    Type *ti = NULL;
 		    else if (!type->equals(fdv->type))
 		    {
 			/* Only need to have a tintro if the vptr
 			 * offsets differ
 			 */
+			unsigned errors = global.errors;
+			global.gag++;            // suppress printing of error messages
 			int offset;
-			if (fdv->type->nextOf()->isBaseOf(type->nextOf(), &offset))
+			int baseOf = fdv->type->nextOf()->isBaseOf(type->nextOf(), &offset);
+			global.gag--;            // suppress printing of error messages
+			if (errors != global.errors)
+			{
+			    // any error in isBaseOf() is a forward reference error, so we bail out
+			    global.errors = errors;
+			    cd->sizeok = 2;    // can't finish due to forward reference
+			    Module::dprogress = dprogress_save;
+			    return;
+			}
+			if (baseOf)
 			{
 			    ti = fdv->type;
-#if 0
-			    if (offset)
-				ti = fdv->type;
-			    else if (type->nextOf()->ty == Tclass)
-			    {   ClassDeclaration *cdn = ((TypeClass *)type->nextOf())->sym;
-				if (cdn && cdn->sizeok != 1)
-				    ti = fdv->type;
-			    }
-#endif
 			}
 		    }
 		    if (ti)
 		    {
 			if (tintro && !tintro->equals(ti))
 		    goto Lassignerr;
 	    }
 	}
 }
-if (isVirtual())
+if (isVirtual() && semanticRun != PASSsemanticdone)
 {
 	/* Rewrite contracts as nested functions, then call them.
 	 * Doing it as nested functions means that overriding functions
 	 * can call them.
 	 */
 	    fdensure = fd;
 	}
 }
 Ldone:
+Module::dprogress++;
+semanticRun = PASSsemanticdone;
 /* Save scope for possible later use (if we need the
 * function internals)
 */
 scope = new Scope(*sc);
 scope->setNoFree();
 //printf("storage class = x%x %x\n", sc->stc, storage_class);
 //{ static int x; if (++x == 2) *(char*)0=0; }
 //printf("\tlinkage = %d\n", sc->linkage);
 //printf(" sc->incontract = %d\n", sc->incontract);
-if (semanticRun >= 3)
+if (semanticRun >= PASSsemantic3)
 	return;
-semanticRun = 3;
+semanticRun = PASSsemantic3;
-// LDC
+#if IN_LLVM
 if (!global.params.useAvailableExternally)
 availableExternally = false;
+#endif
 if (!type || type->ty != Tfunction)
 	return;
 f = (TypeFunction *)(type);
 // Check the 'throws' clause
 	}
 	sc2->callSuper = 0;
 	sc2->pop();
 }
-semanticRun = 4;
+semanticRun = PASSsemantic3done;
 }
 void FuncDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 //printf("FuncDeclaration::toCBuffer() '%s'\n", toChars());
 }
 /*************************************************
 * Find index of function in vtbl[0..dim] that
 * this function overrides.
+* Prefer an exact match to a covariant one.
 * Returns:
 *	-1	didn't find one
 *	-2	can't determine because of forward references
 */
 int FuncDeclaration::findVtblIndex(Array *vtbl, int dim)
 {
+FuncDeclaration *mismatch = NULL;
+int bestvi = -1;
 for (int vi = 0; vi < dim; vi++)
 {
 	FuncDeclaration *fdv = ((Dsymbol *)vtbl->data[vi])->isFuncDeclaration();
 	if (fdv && fdv->ident == ident)
 	{
+	    if (type->equals(fdv->type))	// if exact match
+	        return vi;			// no need to look further
 	    int cov = type->covariant(fdv->type);
 	    //printf("\tbaseclass cov = %d\n", cov);
 	    switch (cov)
 	    {
 		case 0:		// types are distinct
 		    break;
 		case 1:
-		    return vi;
+	            bestvi = vi;	// covariant, but not identical
+	            break;		// keep looking for an exact match
 		case 2:
-		    //type->print();
+		    mismatch = fdv;	// overrides, but is not covariant
-		    //fdv->type->print();
+		    break;		// keep looking for an exact match
-		    //printf("%s %s\n", type->deco, fdv->type->deco);
-		    error("of type %s overrides but is not covariant with %s of type %s",
-			type->toChars(), fdv->toPrettyChars(), fdv->type->toChars());
-		    break;
 		case 3:
 		    return -2;	// forward references
 		default:
 		    assert(0);
 	    }
 	}
 }
-return -1;
+if (bestvi == -1 && mismatch)
+{
+	//type->print();
+	//mismatch->type->print();
+	//printf("%s %s\n", type->deco, mismatch->type->deco);
+	error("of type %s overrides but is not covariant with %s of type %s",
+	    type->toChars(), mismatch->toPrettyChars(), mismatch->type->toChars());
+}
+return bestvi;
 }
 /****************************************************
 * Overload this FuncDeclaration with the new one f.
 * Return !=0 if successful; i.e. no conflict.
 	id = "__foreachbody";
 else if (tok == TOKdelegate)
 	id = "__dgliteral";
 else
 	id = "__funcliteral";
-this->ident = Identifier::generateId(id);
+this->ident = Lexer::uniqueId(id);
 this->tok = tok;
 this->fes = fes;
 //printf("FuncLiteralDeclaration() id = '%s', type = '%s'\n", this->ident->toChars(), type->toChars());
 }
 //printf("FuncLiteralDeclaration::syntaxCopy('%s')\n", toChars());
 if (s)
 	f = (FuncLiteralDeclaration *)s;
 else
-	f = new FuncLiteralDeclaration(loc, endloc, type->syntaxCopy(), tok, fes);
+{	f = new FuncLiteralDeclaration(loc, endloc, type->syntaxCopy(), tok, fes);
+	f->ident = ident;		// keep old identifier
+}
 FuncDeclaration::syntaxCopy(f);
 return f;
 }
 int FuncLiteralDeclaration::isNested()
 }
 void CtorDeclaration::semantic(Scope *sc)
 {
-ClassDeclaration *cd;
+//printf("CtorDeclaration::semantic() %s\n", toChars());
-Type *tret;
-//printf("CtorDeclaration::semantic()\n");
-if (type)
-	return;
 sc = sc->push();
 sc->stc &= ~STCstatic;		// not a static constructor
 parent = sc->parent;
 Dsymbol *parent = toParent();
-cd = parent->isClassDeclaration();
+Type *tret;
+ClassDeclaration *cd = parent->isClassDeclaration();
 if (!cd)
 {
 	error("constructors are only for class definitions");
 	fatal();
 	tret = Type::tvoid;
 }
 else
 	tret = cd->type; //->referenceTo();
-type = new TypeFunction(arguments, tret, varargs, LINKd);
+if (!type)
+	type = new TypeFunction(arguments, tret, varargs, LINKd);
 #if STRUCTTHISREF
 if (ad && ad->isStructDeclaration())
 	((TypeFunction *)type)->isref = 1;
 #endif
 if (!originalType)
 sc->flags &= ~SCOPEctor;
 // Append:
 //	return this;
 // to the function body
-if (fbody)
+if (fbody && semanticRun < PASSsemantic)
 {
 	Expression *e = new ThisExp(loc);
 	Statement *s = new ReturnStatement(loc, e);
 	fbody = new CompoundStatement(loc, fbody, s);
 }
 void PostBlitDeclaration::semantic(Scope *sc)
 {
 //printf("PostBlitDeclaration::semantic() %s\n", toChars());
 //printf("ident: %s, %s, %p, %p\n", ident->toChars(), Id::dtor->toChars(), ident, Id::dtor);
+//printf("stc = x%llx\n", sc->stc);
 parent = sc->parent;
 Dsymbol *parent = toParent();
 StructDeclaration *ad = parent->isStructDeclaration();
 if (!ad)
 {
 	error("post blits are only for struct/union definitions, not %s %s", parent->kind(), parent->toChars());
 }
-else if (ident == Id::_postblit)
+else if (ident == Id::_postblit && semanticRun < PASSsemantic)
 	ad->postblits.push(this);
-type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
+if (!type)
+	type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
 sc = sc->push();
 sc->stc &= ~STCstatic;		// not static
 sc->linkage = LINKd;
 return FALSE;
 }
 void PostBlitDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
-if (hgs->hdrgen)
+buf->writestring("this(this)");
-	return;
-buf->writestring("=this()");
 bodyToCBuffer(buf, hgs);
 }
 #endif
 /********************************* DtorDeclaration ****************************/
 if (!cd)
 {
 	error("destructors are only for class/struct/union definitions, not %s %s", parent->kind(), parent->toChars());
 	fatal();
 }
-else
+else if (semanticRun < PASSsemantic)
 	cd->dtors.push(this);
-type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
+if (!type)
+	type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
 sc = sc->push();
 sc->stc &= ~STCstatic;		// not a static destructor
 sc->linkage = LINKd;
 {
 }
 Dsymbol *StaticCtorDeclaration::syntaxCopy(Dsymbol *s)
 {
-StaticCtorDeclaration *scd;
 assert(!s);
-scd = new StaticCtorDeclaration(loc, endloc);
+StaticCtorDeclaration *scd = new StaticCtorDeclaration(loc, endloc);
 return FuncDeclaration::syntaxCopy(scd);
 }
 void StaticCtorDeclaration::semantic(Scope *sc)
 {
 //printf("StaticCtorDeclaration::semantic()\n");
-type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
+if (!type)
+	type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
 /* If the static ctor appears within a template instantiation,
 * it could get called multiple times by the module constructors
 * for different modules. Thus, protect it with a gate.
 */
-if (inTemplateInstance())
+if (inTemplateInstance() && semanticRun < PASSsemantic)
 {
 	/* Add this prefix to the function:
 	 *	static int gate;
 	 *	if (++gate != 1) return;
 	 * Note that this is not thread safe; should not have threads
 Module *m = getModule();
 if (!m)
 	m = sc->module;
 if (m)
 {	m->needmoduleinfo = 1;
+	//printf("module1 %s needs moduleinfo\n", m->toChars());
 #ifdef IN_GCC
 	m->strictlyneedmoduleinfo = 1;
 #endif
 }
 }
 }
 void StaticDtorDeclaration::semantic(Scope *sc)
 {
-ClassDeclaration *cd;
+ClassDeclaration *cd = sc->scopesym->isClassDeclaration();
-Type *tret;
+if (!type)
-cd = sc->scopesym->isClassDeclaration();
+	type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
-if (!cd)
-{
-}
-type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
 /* If the static ctor appears within a template instantiation,
 * it could get called multiple times by the module constructors
 * for different modules. Thus, protect it with a gate.
 */
-if (inTemplateInstance())
+if (inTemplateInstance() && semanticRun < PASSsemantic)
 {
 	/* Add this prefix to the function:
 	 *	static int gate;
 	 *	if (--gate != 0) return;
 	 * Increment gate during constructor execution.
 }
 void InvariantDeclaration::semantic(Scope *sc)
 {
-AggregateDeclaration *ad;
-Type *tret;
 parent = sc->parent;
 Dsymbol *parent = toParent();
-ad = parent->isAggregateDeclaration();
+AggregateDeclaration *ad = parent->isAggregateDeclaration();
 if (!ad)
 {
 	error("invariants are only for struct/union/class definitions");
 	return;
 }
-else if (ad->inv && ad->inv != this)
+else if (ad->inv && ad->inv != this && semanticRun < PASSsemantic)
 {
 	error("more than one invariant for %s", ad->toChars());
 }
 ad->inv = this;
-type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
+if (!type)
+	type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
 sc = sc->push();
 sc->stc &= ~STCstatic;		// not a static invariant
 sc->incontract++;
 sc->linkage = LINKd;
 void UnitTestDeclaration::semantic(Scope *sc)
 {
 if (global.params.useUnitTests)
 {
-	type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
+	if (!type)
+	    type = new TypeFunction(NULL, Type::tvoid, FALSE, LINKd);
 	Scope *sc2 = sc->push();
 	sc2->linkage = LINKd;
 	FuncDeclaration::semantic(sc2);
 	sc2->pop();
 }
 }
 void NewDeclaration::semantic(Scope *sc)
 {
-ClassDeclaration *cd;
-Type *tret;
 //printf("NewDeclaration::semantic()\n");
 parent = sc->parent;
 Dsymbol *parent = toParent();
-cd = parent->isClassDeclaration();
+ClassDeclaration *cd = parent->isClassDeclaration();
 if (!cd && !parent->isStructDeclaration())
 {
 	error("new allocators only are for class or struct definitions");
 }
-tret = Type::tvoid->pointerTo();
+Type *tret = Type::tvoid->pointerTo();
-type = new TypeFunction(arguments, tret, varargs, LINKd);
+if (!type)
+	type = new TypeFunction(arguments, tret, varargs, LINKd);
 type = type->semantic(loc, sc);
 assert(type->ty == Tfunction);
 // Check that there is at least one argument of type size_t
 }
 void DeleteDeclaration::semantic(Scope *sc)
 {
-ClassDeclaration *cd;
 //printf("DeleteDeclaration::semantic()\n");
 parent = sc->parent;
 Dsymbol *parent = toParent();
-cd = parent->isClassDeclaration();
+ClassDeclaration *cd = parent->isClassDeclaration();
 if (!cd && !parent->isStructDeclaration())
 {
 	error("new allocators only are for class or struct definitions");
 }
-type = new TypeFunction(arguments, Type::tvoid, 0, LINKd);
+if (!type)
+	type = new TypeFunction(arguments, Type::tvoid, 0, LINKd);
 type = type->semantic(loc, sc);
 assert(type->ty == Tfunction);
 // Check that there is only one argument of type void*

Mercurial > projects > ldc

comparison dmd/func.c @ 1630:44b145be2ef5