projects/ldc: dmd/func.c comparison

comparison dmd/func.c @ 1607:207a8a438dea

author	Leandro Lucarella <llucax@gmail.com>
date	Wed, 06 Jan 2010 15:18:20 -0300
parents	a413ae7329bf
children	679d101395e8

comparison

equal deleted inserted replaced

-:1b24e9c7cc26
+:207a8a438dea
 {
 	error("%s must be a function", toChars());
 	return;
 }
 f = (TypeFunction *)(type);
-size_t nparams = Argument::dim(f->parameters);
+size_t nparams = Parameter::dim(f->parameters);
 linkage = sc->linkage;
 //    if (!parent)
 {
 	//parent = sc->scopesym;
 	    case 0:
 		break;
 	    case 1:
 	    {
-		Argument *arg0 = Argument::getNth(f->parameters, 0);
+		Parameter *arg0 = Parameter::getNth(f->parameters, 0);
 		if (arg0->type->ty != Tarray ||
 		    arg0->type->nextOf()->ty != Tarray ||
 		    arg0->type->nextOf()->nextOf()->ty != Tchar ||
 		    arg0->storageClass & (STCout | STCref | STClazy))
 		    goto Lmainerr;
 	{   if (f->varargs == 1)
 		goto Lassignerr;
 	}
 	else
 	{
-	    Argument *arg0 = Argument::getNth(f->parameters, 0);
+	    Parameter *arg0 = Parameter::getNth(f->parameters, 0);
 	    Type *t0 = arg0->type->toBasetype();
 	    Type *tb = sd ? sd->type : cd->type;
 	    if (arg0->type->implicitConvTo(tb) ||
 		(sd && t0->ty == Tpointer && t0->nextOf()->implicitConvTo(tb))
 	       )
 	    {
 		if (nparams == 1)
 		    goto Lassignerr;
-		Argument *arg1 = Argument::getNth(f->parameters, 1);
+		Parameter *arg1 = Parameter::getNth(f->parameters, 1);
 		if (arg1->defaultArg)
 		    goto Lassignerr;
 	    }
 	}
 }
 	     */
 	    if (!outId && f->nextOf()->toBasetype()->ty != Tvoid)
 		outId = Id::result;	// provide a default
 	    Loc loc = fensure->loc;
-	    Arguments *arguments = new Arguments();
+	    Parameters *arguments = new Parameters();
-	    Argument *a = NULL;
+	    Parameter *a = NULL;
 	    if (outId)
-	    {	a = new Argument(STCref, f->nextOf(), outId, NULL);
+	    {	a = new Parameter(STCref, f->nextOf(), outId, NULL);
 		arguments->push(a);
 	    }
 	    TypeFunction *tf = new TypeFunction(arguments, Type::tvoid, 0, LINKd);
 	    FuncDeclaration *fd = new FuncDeclaration(loc, loc,
 		Id::ensure, STCundefined, tf);
 #if IN_LLVM
 // LDC make sure argument type is semanticed.
 // Turns TypeTuple!(int, int) into two int parameters, for instance.
 if (f->parameters)
 {
-for (size_t i = 0; i < Argument::dim(f->parameters); i++)
+for (size_t i = 0; i < Parameter::dim(f->parameters); i++)
-	    {	Argument *arg = (Argument *)Argument::getNth(f->parameters, i);
+	    {	Parameter *arg = (Parameter *)Parameter::getNth(f->parameters, i);
 Type* nw = arg->type->semantic(0, sc);
 if (arg->type != nw) {
 arg->type = nw;
 // Examine this index again.
 // This is important if it turned into a tuple.
 	// Propagate storage class from tuple parameters to their element-parameters.
 	if (f->parameters)
 	{
 	    for (size_t i = 0; i < f->parameters->dim; i++)
-	    {	Argument *arg = (Argument *)f->parameters->data[i];
+	    {	Parameter *arg = (Parameter *)f->parameters->data[i];
 		//printf("[%d] arg->type->ty = %d %s\n", i, arg->type->ty, arg->type->toChars());
 		if (arg->type->ty == Ttuple)
 		{   TypeTuple *t = (TypeTuple *)arg->type;
-		    size_t dim = Argument::dim(t->arguments);
+		    size_t dim = Parameter::dim(t->arguments);
 		    for (size_t j = 0; j < dim; j++)
-		    {	Argument *narg = Argument::getNth(t->arguments, j);
+		    {	Parameter *narg = Parameter::getNth(t->arguments, j);
 			narg->storageClass = arg->storageClass;
 		    }
 		}
 	    }
 	}
 	/* Declare all the function parameters as variables
 	 * and install them in parameters[]
 	 */
-	size_t nparams = Argument::dim(f->parameters);
+	size_t nparams = Parameter::dim(f->parameters);
 	if (nparams)
 	{   /* parameters[] has all the tuples removed, as the back end
 	     * doesn't know about tuples
 	     */
 	    parameters = new Dsymbols();
 	    parameters->reserve(nparams);
 	    for (size_t i = 0; i < nparams; i++)
 	    {
-		Argument *arg = Argument::getNth(f->parameters, i);
+		Parameter *arg = Parameter::getNth(f->parameters, i);
 		Identifier *id = arg->ident;
 		if (!id)
 		{
 		    /* Generate identifier for un-named parameter,
 		     * because we need it later on.
 	// Declare the tuple symbols and put them in the symbol table,
 	// but not in parameters[].
 	if (f->parameters)
 	{
 	    for (size_t i = 0; i < f->parameters->dim; i++)
-	    {	Argument *arg = (Argument *)f->parameters->data[i];
+	    {	Parameter *arg = (Parameter *)f->parameters->data[i];
 		if (!arg->ident)
 		    continue;			// never used, so ignore
 		if (arg->type->ty == Ttuple)
 		{   TypeTuple *t = (TypeTuple *)arg->type;
-		    size_t dim = Argument::dim(t->arguments);
+		    size_t dim = Parameter::dim(t->arguments);
 		    Objects *exps = new Objects();
 		    exps->setDim(dim);
 		    for (size_t j = 0; j < dim; j++)
-		    {	Argument *narg = Argument::getNth(t->arguments, j);
+		    {	Parameter *narg = Parameter::getNth(t->arguments, j);
 			assert(narg->ident);
 			VarDeclaration *v = sc2->search(0, narg->ident, NULL)->isVarDeclaration();
 			assert(v);
 			Expression *e = new VarExp(v->loc, v);
 			exps->data[j] = (void *)e;
 	{
 	    tf = (TypeFunction *)type;
 	    //printf("tf = %s, args = %s\n", tf->deco, ((Expression *)arguments->data[0])->type->deco);
 	    error(loc, "%s does not match parameter types (%s)",
-		Argument::argsTypesToChars(tf->parameters, tf->varargs),
+		Parameter::argsTypesToChars(tf->parameters, tf->varargs),
 		buf.toChars());
 	    return m.anyf;		// as long as it's not a FuncAliasDeclaration
 	}
 	else
 	{
 	    TypeFunction *t1 = (TypeFunction *)m.lastf->type;
 	    TypeFunction *t2 = (TypeFunction *)m.nextf->type;
 	    error(loc, "called with argument types:\n\t(%s)\nmatches both:\n\t%s%s\nand:\n\t%s%s",
 		    buf.toChars(),
-		    m.lastf->toPrettyChars(), Argument::argsTypesToChars(t1->parameters, t1->varargs),
+		    m.lastf->toPrettyChars(), Parameter::argsTypesToChars(t1->parameters, t1->varargs),
-		    m.nextf->toPrettyChars(), Argument::argsTypesToChars(t2->parameters, t2->varargs));
+		    m.nextf->toPrettyChars(), Parameter::argsTypesToChars(t2->parameters, t2->varargs));
 #else
 	    error(loc, "overloads %s and %s both match argument list for %s",
 		    m.lastf->type->toChars(),
 		    m.nextf->type->toChars(),
 		    m.lastf->toChars());
 * as g() is.
 */
 TypeFunction *tf = (TypeFunction *)type;
 TypeFunction *tg = (TypeFunction *)g->type;
-size_t nfparams = Argument::dim(tf->parameters);
+size_t nfparams = Parameter::dim(tf->parameters);
-size_t ngparams = Argument::dim(tg->parameters);
+size_t ngparams = Parameter::dim(tg->parameters);
 MATCH match = MATCHexact;
 /* If both functions have a 'this' pointer, and the mods are not
 * the same and g's is not const, then this is less specialized.
 */
 */
 Expressions args;
 args.setDim(nfparams);
 for (int u = 0; u < nfparams; u++)
 {
-	Argument *p = Argument::getNth(tf->parameters, u);
+	Parameter *p = Parameter::getNth(tf->parameters, u);
 	Expression *e;
 	if (p->storageClass & (STCref | STCout))
 	{
 	    e = new IdentifierExp(0, p->ident);
 	    e->type = p->type;
 //
 // LDC: Adjusted to give argument info to the runtime function decl.
 //
-FuncDeclaration *FuncDeclaration::genCfunc(Arguments *args, Type *treturn, const char *name)
+FuncDeclaration *FuncDeclaration::genCfunc(Parameters *args, Type *treturn, const char *name)
 {
 return genCfunc(args, treturn, Lexer::idPool(name));
 }
-FuncDeclaration *FuncDeclaration::genCfunc(Arguments *args, Type *treturn, Identifier *id)
+FuncDeclaration *FuncDeclaration::genCfunc(Parameters *args, Type *treturn, Identifier *id)
 {
 FuncDeclaration *fd;
 TypeFunction *tf;
 Dsymbol *s;
 static DsymbolTable *st = NULL;
 }
 /********************************* CtorDeclaration ****************************/
-CtorDeclaration::CtorDeclaration(Loc loc, Loc endloc, Arguments *arguments, int varargs)
+CtorDeclaration::CtorDeclaration(Loc loc, Loc endloc, Parameters *arguments, int varargs)
 : FuncDeclaration(loc, endloc, Id::ctor, STCundefined, NULL)
 {
 this->arguments = arguments;
 this->varargs = varargs;
 //printf("CtorDeclaration(loc = %s) %s\n", loc.toChars(), toChars());
 f->frequire = frequire ? frequire->syntaxCopy() : NULL;
 f->fensure  = fensure  ? fensure->syntaxCopy()  : NULL;
 f->fbody    = fbody    ? fbody->syntaxCopy()    : NULL;
 assert(!fthrows); // deprecated
-f->arguments = Argument::arraySyntaxCopy(arguments);
+f->arguments = Parameter::arraySyntaxCopy(arguments);
 return f;
 }
 void CtorDeclaration::semantic(Scope *sc)
 FuncDeclaration::semantic(sc);
 sc->pop();
 // See if it's the default constructor
-if (cd && varargs == 0 && Argument::dim(arguments) == 0)
+if (cd && varargs == 0 && Parameter::dim(arguments) == 0)
 	cd->defaultCtor = this;
 }
 const char *CtorDeclaration::kind()
 {
 void CtorDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("this");
-Argument::argsToCBuffer(buf, hgs, arguments, varargs);
+Parameter::argsToCBuffer(buf, hgs, arguments, varargs);
 bodyToCBuffer(buf, hgs);
 }
 /********************************* PostBlitDeclaration ****************************/
 bodyToCBuffer(buf, hgs);
 }
 /********************************* NewDeclaration ****************************/
-NewDeclaration::NewDeclaration(Loc loc, Loc endloc, Arguments *arguments, int varargs)
+NewDeclaration::NewDeclaration(Loc loc, Loc endloc, Parameters *arguments, int varargs)
 : FuncDeclaration(loc, endloc, Id::classNew, STCstatic, NULL)
 {
 this->arguments = arguments;
 this->varargs = varargs;
 }
 f = new NewDeclaration(loc, endloc, NULL, varargs);
 FuncDeclaration::syntaxCopy(f);
-f->arguments = Argument::arraySyntaxCopy(arguments);
+f->arguments = Parameter::arraySyntaxCopy(arguments);
 return f;
 }
 type = type->semantic(loc, sc);
 assert(type->ty == Tfunction);
 // Check that there is at least one argument of type size_t
 TypeFunction *tf = (TypeFunction *)type;
-if (Argument::dim(tf->parameters) < 1)
+if (Parameter::dim(tf->parameters) < 1)
 {
 	error("at least one argument of type size_t expected");
 }
 else
 {
-	Argument *a = Argument::getNth(tf->parameters, 0);
+	Parameter *a = Parameter::getNth(tf->parameters, 0);
 	if (!a->type->equals(Type::tsize_t))
 	    error("first argument must be type size_t, not %s", a->type->toChars());
 }
 FuncDeclaration::semantic(sc);
 }
 void NewDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("new");
-Argument::argsToCBuffer(buf, hgs, arguments, varargs);
+Parameter::argsToCBuffer(buf, hgs, arguments, varargs);
 bodyToCBuffer(buf, hgs);
 }
 /********************************* DeleteDeclaration ****************************/
-DeleteDeclaration::DeleteDeclaration(Loc loc, Loc endloc, Arguments *arguments)
+DeleteDeclaration::DeleteDeclaration(Loc loc, Loc endloc, Parameters *arguments)
 : FuncDeclaration(loc, endloc, Id::classDelete, STCstatic, NULL)
 {
 this->arguments = arguments;
 }
 f = new DeleteDeclaration(loc, endloc, NULL);
 FuncDeclaration::syntaxCopy(f);
-f->arguments = Argument::arraySyntaxCopy(arguments);
+f->arguments = Parameter::arraySyntaxCopy(arguments);
 return f;
 }
 type = type->semantic(loc, sc);
 assert(type->ty == Tfunction);
 // Check that there is only one argument of type void*
 TypeFunction *tf = (TypeFunction *)type;
-if (Argument::dim(tf->parameters) != 1)
+if (Parameter::dim(tf->parameters) != 1)
 {
 	error("one argument of type void* expected");
 }
 else
 {
-	Argument *a = Argument::getNth(tf->parameters, 0);
+	Parameter *a = Parameter::getNth(tf->parameters, 0);
 	if (!a->type->equals(Type::tvoid->pointerTo()))
 	    error("one argument of type void* expected, not %s", a->type->toChars());
 }
 FuncDeclaration::semantic(sc);
 }
 void DeleteDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("delete");
-Argument::argsToCBuffer(buf, hgs, arguments, 0);
+Parameter::argsToCBuffer(buf, hgs, arguments, 0);
 bodyToCBuffer(buf, hgs);
 }

Mercurial > projects > ldc

comparison dmd/func.c @ 1607:207a8a438dea