projects/ldc: dmd/func.c comparison

comparison dmd/func.c @ 336:aaade6ded589 trunk

[svn r357] Merged DMD 1.033

author	lindquist
date	Sat, 12 Jul 2008 19:38:31 +0200
parents	f7190d9eb70c
children	d8234836b40f

comparison

equal deleted inserted replaced

-:17b844102023
+:aaade6ded589
 void FuncDeclaration::semantic(Scope *sc)
 {   TypeFunction *f;
 StructDeclaration *sd;
 ClassDeclaration *cd;
 InterfaceDeclaration *id;
+Dsymbol *pd;
 #if 0
 printf("FuncDeclaration::semantic(sc = %p, this = %p, '%s', linkage = %d)\n", sc, this, toPrettyChars(), sc->linkage);
 if (isFuncLiteralDeclaration())
 	printf("\tFuncLiteralDeclaration()\n");
 	    isInvariantDeclaration() ||
 	    isUnitTestDeclaration() || isNewDeclaration() || isDelete())
 	    error("special function not allowed in interface %s", id->toChars());
 	if (fbody)
 	    error("function body is not abstract in interface %s", id->toChars());
+}
+/* Template member functions aren't virtual:
+*   interface TestInterface { void tpl(T)(); }
+* and so won't work in interfaces
+*/
+if ((pd = toParent()) != NULL &&
+	pd->isTemplateInstance() &&
+	(pd = toParent2()) != NULL &&
+	(id = pd->isInterfaceDeclaration()) != NULL)
+{
+	error("template member function not allowed in interface %s", id->toChars());
 }
 cd = parent->isClassDeclaration();
 if (cd)
 {	int vi;
 	    {   FuncDeclaration *fdv = (FuncDeclaration *)cd->vtbl.data[vi];
 		// This function is covariant with fdv
 		if (fdv->isFinal())
 		    error("cannot override final function %s", fdv->toPrettyChars());
-#if V2
+#if DMDV2
 		if (!isOverride() && global.params.warnings)
 		    warning("%s: overrides base class function %s, but is not marked with 'override'", locToChars() fdv->toPrettyChars());
 #endif
 		if (fdv->toParent() == parent)
 			break;
 		    if (!this->parent->isClassDeclaration()
 #if !BREAKABI
 			&& !isDtorDeclaration()
 #endif
-#if V2
+#if DMDV2
 			&& !isPostBlitDeclaration()
 #endif
 			)
 			error("multiple overrides of same function");
 		}
 		    type = type->semantic(loc, sc);
 		}
 		f = (TypeFunction *)type;
 	    }
-	    int offend = fbody ? fbody->fallOffEnd() : TRUE;
+	    int offend = fbody ? fbody->blockExit() & BEfallthru : TRUE;
+	    //int offend = fbody ? fbody->fallOffEnd() : TRUE;
 	    if (isStaticCtorDeclaration())
 	    {	/* It's a static constructor. Ensure that all
 		 * ctor consts were initialized.
 		 */
 if (t->equals(f->type))
 {	p->f = f;
 	return 1;
 }
-#if V2
+#if DMDV2
 /* Allow covariant matches, if it's just a const conversion
 * of the return type
 */
 if (t->ty == Tfunction)
 {   TypeFunction *tf = (TypeFunction *)f->type;
 	s = new LabelDsymbol(ident);
 	labtab->insert(s);
 }
 return (LabelDsymbol *)s;
 }
 /****************************************
 * If non-static member function that has a 'this' pointer,
 * return the aggregate it is a member of.
 * Otherwise, return NULL.
 */
 	st->insert(fd);
 }
 return fd;
 }
-char *FuncDeclaration::kind()
+const char *FuncDeclaration::kind()
 {
 return "function";
 }
 /*******************************
 * Look at all the variables in this function that are referenced
 * by nested functions, and determine if a closure needs to be
 * created for them.
 */
-#if V2
+#if DMDV2
 int FuncDeclaration::needsClosure()
 {
 /* Need a closure for all the closureVars[] if any of the
 * closureVars[] are accessed by a
 * function that escapes the scope of this function.
 * We take the conservative approach and decide that any function that:
 * 1) is a virtual function
 * 2) has its address taken
 * 3) has a parent that escapes
-* escapes.
+*
+* Note that since a non-virtual function can be called by
+* a virtual one, if that non-virtual function accesses a closure
+* var, the closure still has to be taken. Hence, we check for isThis()
+* instead of isVirtual(). (thanks to David Friedman)
 */
 //printf("FuncDeclaration::needsClosure() %s\n", toChars());
 for (int i = 0; i < closureVars.dim; i++)
 {	VarDeclaration *v = (VarDeclaration *)closureVars.data[i];
 	for (int j = 0; j < v->nestedrefs.dim; j++)
 	{   FuncDeclaration *f = (FuncDeclaration *)v->nestedrefs.data[j];
 	    assert(f != this);
 	    //printf("\t\tf = %s, %d, %d\n", f->toChars(), f->isVirtual(), f->tookAddressOf);
-	    if (f->isVirtual() || f->tookAddressOf)
+	    if (f->isThis() || f->tookAddressOf)
 		goto Lyes;	// assume f escapes this function's scope
 	    // Look to see if any parents of f that are below this escape
 	    for (Dsymbol *s = f->parent; s != this; s = s->parent)
 	    {
 		f = s->isFuncDeclaration();
-		if (f && (f->isVirtual() || f->tookAddressOf))
+		if (f && (f->isThis() || f->tookAddressOf))
 		    goto Lyes;
 	    }
 	}
 }
 return 0;
 {
 assert(funcalias != this);
 this->funcalias = funcalias;
 }
-char *FuncAliasDeclaration::kind()
+const char *FuncAliasDeclaration::kind()
 {
 return "function alias";
 }
 {
 //printf("FuncLiteralDeclaration::isNested() '%s'\n", toChars());
 return (tok == TOKdelegate);
 }
-char *FuncLiteralDeclaration::kind()
+int FuncLiteralDeclaration::isVirtual()
+{
+return FALSE;
+}
+const char *FuncLiteralDeclaration::kind()
 {
 // GCC requires the (char*) casts
 return (tok == TOKdelegate) ? (char*)"delegate" : (char*)"function";
 }
 	tret = Type::tvoid;
 }
 else
 	tret = cd->type; //->referenceTo();
 type = new TypeFunction(arguments, tret, varargs, LINKd);
+if (!originalType)
+	originalType = type;
 sc->flags |= SCOPEctor;
 type = type->semantic(loc, sc);
 sc->flags &= ~SCOPEctor;
 // See if it's the default constructor
 if (cd && varargs == 0 && Argument::dim(arguments) == 0)
 	cd->defaultCtor = this;
 }
-char *CtorDeclaration::kind()
+const char *CtorDeclaration::kind()
 {
 return "constructor";
 }
 char *CtorDeclaration::toChars()
 void StaticCtorDeclaration::semantic(Scope *sc)
 {
 //printf("StaticCtorDeclaration::semantic()\n");
 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())
+{
+	/* Add this prefix to the function:
+	 *	static int gate;
+	 *	if (++gate != 1) return;
+	 * Note that this is not thread safe; should not have threads
+	 * during static construction.
+	 */
+	Identifier *id = Lexer::idPool("__gate");
+	VarDeclaration *v = new VarDeclaration(0, Type::tint32, id, NULL);
+	v->storage_class = STCstatic;
+	Statements *sa = new Statements();
+	Statement *s = new DeclarationStatement(0, v);
+	sa->push(s);
+	Expression *e = new IdentifierExp(0, id);
+	e = new AddAssignExp(0, e, new IntegerExp(1));
+	e = new EqualExp(TOKnotequal, 0, e, new IntegerExp(1));
+	s = new IfStatement(0, NULL, e, new ReturnStatement(0, NULL), NULL);
+	sa->push(s);
+	if (fbody)
+	    sa->push(fbody);
+	fbody = new CompoundStatement(0, sa);
+}
 FuncDeclaration::semantic(sc);
 // We're going to need ModuleInfo
 Module *m = getModule();
 StaticDtorDeclaration::StaticDtorDeclaration(Loc loc, Loc endloc)
 : FuncDeclaration(loc, endloc,
 Identifier::generateId("_staticDtor"), STCstatic, NULL)
 {
+vgate = NULL;
 }
 Dsymbol *StaticDtorDeclaration::syntaxCopy(Dsymbol *s)
 {
 StaticDtorDeclaration *sdd;
 cd = sc->scopesym->isClassDeclaration();
 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())
+{
+	/* Add this prefix to the function:
+	 *	static int gate;
+	 *	if (--gate != 0) return;
+	 * Increment gate during constructor execution.
+	 * Note that this is not thread safe; should not have threads
+	 * during static destruction.
+	 */
+	Identifier *id = Lexer::idPool("__gate");
+	VarDeclaration *v = new VarDeclaration(0, Type::tint32, id, NULL);
+	v->storage_class = STCstatic;
+	Statements *sa = new Statements();
+	Statement *s = new DeclarationStatement(0, v);
+	sa->push(s);
+	Expression *e = new IdentifierExp(0, id);
+	e = new AddAssignExp(0, e, new IntegerExp(-1));
+	e = new EqualExp(TOKnotequal, 0, e, new IntegerExp(1));
+	s = new IfStatement(0, NULL, e, new ReturnStatement(0, NULL), NULL);
+	sa->push(s);
+	if (fbody)
+	    sa->push(fbody);
+	fbody = new CompoundStatement(0, sa);
+	vgate = v;
+}
 FuncDeclaration::semantic(sc);
 // We're going to need ModuleInfo
 Module *m = getModule();
 * instances per module.
 */
 static Identifier *unitTestId()
 {
-static int n;
+return Lexer::uniqueId("__unittest");
-char buffer[10 + sizeof(n)*3 + 1];
-sprintf(buffer,"__unittest%d", n);
-n++;
-return Lexer::idPool(buffer);
 }
 UnitTestDeclaration::UnitTestDeclaration(Loc loc, Loc endloc)
 : FuncDeclaration(loc, endloc, unitTestId(), STCundefined, NULL)
 {
 }
 FuncDeclaration::semantic(sc);
 }
-char *NewDeclaration::kind()
+const char *NewDeclaration::kind()
 {
 return "allocator";
 }
 int NewDeclaration::isVirtual()
 }
 FuncDeclaration::semantic(sc);
 }
-char *DeleteDeclaration::kind()
+const char *DeleteDeclaration::kind()
 {
 return "deallocator";
 }
 int DeleteDeclaration::isDelete()

Mercurial > projects > ldc

comparison dmd/func.c @ 336:aaade6ded589 trunk