projects/ldc: dmd/template.c comparison

comparison dmd/template.c @ 875:330f999ade44

Merged DMD 1.038

author	Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
date	Tue, 06 Jan 2009 16:33:51 +0100
parents	eef8ac26c66c
children	27a379f288bf

comparison

equal deleted inserted replaced

-:2ddee23bd70e
+:330f999ade44
 		       (Object *)v2->objects.data[i],
 		       tempdecl, sc))
 		goto Lnomatch;
 	}
 }
+//printf("match\n");
 return 1;	// match
 Lnomatch:
+//printf("nomatch\n");
 return 0;	// nomatch;
 }
 /****************************************
 */
 if (scope)
 	return;		// semantic() already run
 if (sc->func)
 {
+#if DMDV1
 	error("cannot declare template at function scope %s", sc->func->toChars());
+#endif
 }
 if (/*global.params.useArrayBounds &&*/ sc->module)
 {
 	// Generate this function as it may be used
 	    goto Lnomatch;
 }
 if (!flag)
 {
-	// Any parameter left without a type gets the type of its corresponding arg
+	/* Any parameter left without a type gets the type of
+	 * its corresponding arg
+	 */
 	for (int i = 0; i < dedtypes_dim; i++)
 	{
 	    if (!dedtypes->data[i])
 	    {   assert(i < ti->tiargs->dim);
 		dedtypes->data[i] = ti->tiargs->data[i];
 	    }
 	}
 }
+#if DMDV2
+if (m && constraint && !(flag & 1))
+{	/* Check to see if constraint is satisfied.
+	 */
+	Expression *e = constraint->syntaxCopy();
+	paramscope->flags |= SCOPEstaticif;
+	e = e->semantic(paramscope);
+	e = e->optimize(WANTvalue | WANTinterpret);
+if (e->isBool(TRUE))
+;
+else if (e->isBool(FALSE))
+goto Lnomatch;
+else
+{
+e->error("constraint %s is not constant or does not evaluate to a bool", e->toChars());
+}
+}
+#endif
 #if LOGM
 // Print out the results
 printf("--------------------------\n");
 printf("template %s\n", toChars());
 /*************************************************
 * Match function arguments against a specific template function.
 * Input:
+*	loc		instantiation location
 *	targsi		Expression/Type initial list of template arguments
+*	ethis		'this' argument if !NULL
 *	fargs		arguments to function
 * Output:
 *	dedargs		Expression/Type deduced template arguments
 * Returns:
 *	match level
 */
-MATCH TemplateDeclaration::deduceFunctionTemplateMatch(Objects *targsi, Expressions *fargs,
+MATCH TemplateDeclaration::deduceFunctionTemplateMatch(Loc loc, Objects *targsi,
+	Expression *ethis, Expressions *fargs,
 	Objects *dedargs)
 {
 size_t i;
 size_t nfparams;
 size_t nfargs;
 	    goto Lnomatch;		// too many args, no match
 	match = MATCHconvert;		// match ... with a conversion
 }
 L2:
+#if DMDV2
+// Match 'ethis' to any TemplateThisParameter's
+if (ethis)
+{
+	for (size_t i = 0; i < parameters->dim; i++)
+	{   TemplateParameter *tp = (TemplateParameter *)parameters->data[i];
+	    TemplateThisParameter *ttp = tp->isTemplateThisParameter();
+	    if (ttp)
+	    {	MATCH m;
+		Type *t = new TypeIdentifier(0, ttp->ident);
+		m = ethis->type->deduceType(scope, t, parameters, &dedtypes);
+		if (!m)
+		    goto Lnomatch;
+		if (m < match)
+		    match = m;		// pick worst match
+	    }
+	}
+}
+#endif
 // Loop through the function parameters
 for (i = 0; i < nfparams; i++)
 {
 	/* Skip over function parameters which wound up
 	 * as part of a template tuple parameter.
 		    if (dedtypes.data[i] != oded)
 			error("specialization not allowed for deduced parameter %s", tp->ident->toChars());
 		}
 	    }
 	    else
-	    {	oded = tp->defaultArg(paramscope);
+	    {	oded = tp->defaultArg(loc, paramscope);
 		if (!oded)
 		    goto Lnomatch;
 	    }
 	    declareParameter(paramscope, tp, oded);
 	    dedargs->data[i] = (void *)oded;
 	}
 }
+#if DMDV2
+if (constraint)
+{	/* Check to see if constraint is satisfied.
+	 */
+	Expression *e = constraint->syntaxCopy();
+	paramscope->flags |= SCOPEstaticif;
+	e = e->semantic(paramscope);
+	e = e->optimize(WANTvalue | WANTinterpret);
+if (e->isBool(TRUE))
+;
+else if (e->isBool(FALSE))
+goto Lnomatch;
+else
+{
+e->error("constraint %s is not constant or does not evaluate to a bool", e->toChars());
+}
+}
+#endif
 #if 0
 for (i = 0; i < dedargs->dim; i++)
 {	Type *t = (Type *)dedargs->data[i];
 	printf("\tdedargs[%d] = %d, %s\n", i, t->dyncast(), t->toChars());
 * If no match, give error message and return NULL.
 * Input:
 *	sc		instantiation scope
 *	loc		instantiation location
 *	targsi		initial list of template arguments
+*	ethis		if !NULL, the 'this' pointer argument
 *	fargs		arguments to function
+*	flags		1: do not issue error message on no match, just return NULL
 */
 FuncDeclaration *TemplateDeclaration::deduceFunctionTemplate(Scope *sc, Loc loc,
-	Objects *targsi, Expressions *fargs)
+	Objects *targsi, Expression *ethis, Expressions *fargs, int flags)
 {
 MATCH m_best = MATCHnomatch;
 TemplateDeclaration *td_ambig = NULL;
 TemplateDeclaration *td_best = NULL;
 Objects *tdargs = new Objects();
 	}
 	MATCH m;
 	Objects dedargs;
-	m = td->deduceFunctionTemplateMatch(targsi, fargs, &dedargs);
+	m = td->deduceFunctionTemplateMatch(loc, targsi, ethis, fargs, &dedargs);
 	//printf("deduceFunctionTemplateMatch = %d\n", m);
 	if (!m)			// if no match
 	    continue;
 	if (m < m_best)
 	goto Lerror;
 return fd;
 Lerror:
 {
+	HdrGenState hgs;
+	OutBuffer bufa;
+	Objects *args = targsi;
+	if (args)
+	{   for (int i = 0; i < args->dim; i++)
+	    {
+		if (i)
+		    bufa.writeByte(',');
+		Object *oarg = (Object *)args->data[i];
+		ObjectToCBuffer(&bufa, &hgs, oarg);
+	    }
+	}
 	OutBuffer buf;
-	HdrGenState hgs;
 	argExpTypesToCBuffer(&buf, fargs, &hgs);
-	error(loc, "cannot deduce template function from argument types (%s)",
+	error(loc, "cannot deduce template function from argument types !(%s)(%s)",
-		buf.toChars());
+		bufa.toChars(), buf.toChars());
-	return NULL;
+}
-}
+return NULL;
 }
 void TemplateDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 #if 0 // Should handle template functions
 	if (i)
 	    buf->writeByte(',');
 	tp->toCBuffer(buf, hgs);
 }
 buf->writeByte(')');
+#if DMDV2
+if (constraint)
+{	buf->writestring(" if (");
+	constraint->toCBuffer(buf, hgs);
+	buf->writeByte(')');
+}
+#endif
 if (hgs->hdrgen)
 {
 	hgs->tpltMember++;
 	buf->writenl();
 	if (i)
 	    buf.writeByte(',');
 	tp->toCBuffer(&buf, &hgs);
 }
 buf.writeByte(')');
+#if DMDV2
+if (constraint)
+{	buf.writestring(" if (");
+	constraint->toCBuffer(&buf, &hgs);
+	buf.writeByte(')');
+}
+#endif
 buf.writeByte(0);
 return (char *)buf.extractData();
 }
 /* ======================== Type ============================================ */
 */
 MATCH Type::deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters,
 	Objects *dedtypes)
 {
-//printf("Type::deduceType()\n");
+#if 0
-//printf("\tthis   = %d, ", ty); print();
+printf("Type::deduceType()\n");
-//printf("\ttparam = %d, ", tparam->ty); tparam->print();
+printf("\tthis   = %d, ", ty); print();
+printf("\ttparam = %d, ", tparam->ty); tparam->print();
+#endif
 if (!tparam)
 	goto Lnomatch;
 if (this == tparam)
 	goto Lexact;
 if (i < tiargs->dim)
 	oarg = (Object *)tiargs->data[i];
 else
 {	// Get default argument instead
-	oarg = defaultArg(sc);
+	oarg = defaultArg(loc, sc);
 	if (!oarg)
 	{   assert(i < dedtypes->dim);
 	    // It might have already been deduced
 	    oarg = (Object *)dedtypes->data[i];
 	    if (!oarg)
 {
 return specType;
 }
-Object *TemplateTypeParameter::defaultArg(Scope *sc)
+Object *TemplateTypeParameter::defaultArg(Loc loc, Scope *sc)
 {
 Type *t;
 t = defaultType;
 if (t)
 if (i < tiargs->dim)
 	oarg = (Object *)tiargs->data[i];
 else
 {	// Get default argument instead
-	oarg = defaultArg(sc);
+	oarg = defaultArg(loc, sc);
 	if (!oarg)
 	{   assert(i < dedtypes->dim);
 	    // It might have already been deduced
 	    oarg = (Object *)dedtypes->data[i];
 	    if (!oarg)
 {
 return specAliasT;
 }
-Object *TemplateAliasParameter::defaultArg(Scope *sc)
+Object *TemplateAliasParameter::defaultArg(Loc loc, Scope *sc)
 {
 Dsymbol *s = NULL;
 if (defaultAlias)
 {
 if (i < tiargs->dim)
 	oarg = (Object *)tiargs->data[i];
 else
 {	// Get default argument instead
-	oarg = defaultArg(sc);
+	oarg = defaultArg(loc, sc);
 	if (!oarg)
 	{   assert(i < dedtypes->dim);
 	    // It might have already been deduced
 	    oarg = (Object *)dedtypes->data[i];
 	    if (!oarg)
 {
 return specValue;
 }
-Object *TemplateValueParameter::defaultArg(Scope *sc)
+Object *TemplateValueParameter::defaultArg(Loc loc, Scope *sc)
 {
 Expression *e = defaultValue;
 if (e)
 {
 	e = e->syntaxCopy();
 {
 return NULL;
 }
-Object *TemplateTupleParameter::defaultArg(Scope *sc)
+Object *TemplateTupleParameter::defaultArg(Loc loc, Scope *sc)
 {
 return NULL;
 }
 /* ======================== TemplateInstance ================================ */
 this->isnested = NULL;
 this->errors = 0;
 this->tinst = NULL;
 }
+/*****************
+* This constructor is only called when we figured out which function
+* template to instantiate.
+*/
 TemplateInstance::TemplateInstance(Loc loc, TemplateDeclaration *td, Objects *tiargs)
 : ScopeDsymbol(NULL)
 {
 #if LOG
 }
 Dsymbol *TemplateInstance::syntaxCopy(Dsymbol *s)
 {
 TemplateInstance *ti;
-int i;
 if (s)
 	ti = (TemplateInstance *)s;
 else
 	ti = new TemplateInstance(loc, name);
 	    return;
 	}
 }
 else
 {
-	// Run semantic on each argument, place results in tiargs[]
+	/* Run semantic on each argument, place results in tiargs[]
+	 * (if we havetempdecl, then tiargs is already evaluated)
+	 */
 	semanticTiargs(sc);
 	tempdecl = findTemplateDeclaration(sc);
 	if (tempdecl)
 	    tempdecl = findBestMatch(sc);
 // Add 'this' to the enclosing scope's members[] so the semantic routines
 // will get called on the instance members
 #if 1
 int dosemantic3 = 0;
 {	Array *a;
-	int i;
+	Scope *scx = sc;
-	if (sc->scopesym && sc->scopesym->members && !sc->scopesym->isTemplateMixin())
+#if 0
-	{
+	for (scx = sc; scx; scx = scx->enclosing)
-	    //printf("\t1: adding to %s %s\n", sc->scopesym->kind(), sc->scopesym->toChars());
+	    if (scx->scopesym)
-	    a = sc->scopesym->members;
+		break;
+#endif
+	//if (scx && scx->scopesym) printf("3: scx is %s %s\n", scx->scopesym->kind(), scx->scopesym->toChars());
+	if (scx && scx->scopesym &&
+	    scx->scopesym->members && !scx->scopesym->isTemplateMixin() &&
+	    /* The following test should really be if scx->module recursively
+	     * imports itself. Because if it does, see bugzilla 2500.
+	     */
+	    //scx->module == tempdecl->getModule()
+	    !scx->module->imports(scx->module)
+	   )
+	{
+	    //printf("\t1: adding to %s %s\n", scx->scopesym->kind(), scx->scopesym->toChars());
+	    a = scx->scopesym->members;
 	}
 	else
 	{   Module *m = sc->module->importedFrom;
 	    //printf("\t2: adding to module %s instead of module %s\n", m->toChars(), sc->module->toChars());
 	    a = m->members;
 	{
 	    error("forward reference to template declaration %s", td->toChars());
 	    return NULL;
 	}
 	m = td->matchWithInstance(this, &dedtypes, 0);
-	//printf("m = %d\n", m);
+	//printf("matchWithInstance = %d\n", m);
 	if (!m)			// no match at all
 	    continue;
-#if 1
 	if (m < m_best)
 	    goto Ltd_best;
 	if (m > m_best)
 	    goto Ltd;
-#else
-	if (!m_best)
-	    goto Ltd;
-#endif
 	{
 	// Disambiguate by picking the most specialized TemplateDeclaration
 	int c1 = td->leastAsSpecialized(td_best);
 	int c2 = td_best->leastAsSpecialized(td);
 	//printf("c1 = %d, c2 = %d\n", c1, c2);
 	    assert(0);
 }
 buf.writeByte('Z');
 id = buf.toChars();
 buf.data = NULL;
+//printf("\tgenIdent = %s\n", id);
 return new Identifier(id, TOKidentifier);
 }
 /****************************************************
 //printf("TemplateInstance::declareParameters()\n");
 for (int i = 0; i < tdtypes.dim; i++)
 {
 	TemplateParameter *tp = (TemplateParameter *)tempdecl->parameters->data[i];
 	//Object *o = (Object *)tiargs->data[i];
-	Object *o = (Object *)tdtypes.data[i];
+	Object *o = (Object *)tdtypes.data[i];		// initializer for tp
 	//printf("\ttdtypes[%d] = %p\n", i, o);
 	tempdecl->declareParameter(scope, tp, o);
 }
 }

Mercurial > projects > ldc

comparison dmd/template.c @ 875:330f999ade44