projects/ldc: dmd/mtype.c comparison

comparison dmd/mtype.c @ 1607:207a8a438dea

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

comparison

equal deleted inserted replaced

-:1b24e9c7cc26
+:207a8a438dea
 	Expressions *arguments;
 	//LDC: Build arguments.
 	static FuncDeclaration *adReverseChar_fd = NULL;
 	if(!adReverseChar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::tchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adReverseChar_fd = FuncDeclaration::genCfunc(args, arrty, "_adReverseChar");
 	}
 	static FuncDeclaration *adReverseWchar_fd = NULL;
 	if(!adReverseWchar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::twchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adReverseWchar_fd = FuncDeclaration::genCfunc(args, arrty, "_adReverseWchar");
 	}
 	if(n->ty == Twchar)
 	    ec = new VarExp(0, adReverseWchar_fd);
 	Expressions *arguments;
 	//LDC: Build arguments.
 	static FuncDeclaration *adSortChar_fd = NULL;
 	if(!adSortChar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::tchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adSortChar_fd = FuncDeclaration::genCfunc(args, arrty, "_adSortChar");
 	}
 	static FuncDeclaration *adSortWchar_fd = NULL;
 	if(!adSortWchar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::twchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adSortWchar_fd = FuncDeclaration::genCfunc(args, arrty, "_adSortWchar");
 	}
 	if(n->ty == Twchar)
 	    ec = new VarExp(0, adSortWchar_fd);
 	assert(size);
 	dup = (ident == Id::dup);
 	//LDC: Build arguments.
 	static FuncDeclaration *adDup_fd = NULL;
 	if(!adDup_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
 	    adDup_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::adDup);
 	}
 	static FuncDeclaration *adReverse_fd = NULL;
 	if(!adReverse_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
 	    adReverse_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::adReverse);
 	}
 	if(dup)
 	    ec = new VarExp(0, adDup_fd);
 	bool isBit = (n->ty == Tbit);
 	//LDC: Build arguments.
 	static FuncDeclaration *adSort_fd = NULL;
 	if(!adSort_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
 	    adSort_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), "_adSort");
 	}
 	static FuncDeclaration *adSortBit_fd = NULL;
 	if(!adSortBit_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
 	    adSortBit_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), "_adSortBit");
 	}
 	if(isBit)
 	    ec = new VarExp(0, adSortBit_fd);
 	    if (d >= tt->arguments->dim)
 	    {	error(loc, "tuple index %ju exceeds %u", d, tt->arguments->dim);
 		return Type::terror;
 	    }
-	    Argument *arg = (Argument *)tt->arguments->data[(size_t)d];
+	    Parameter *arg = (Parameter *)tt->arguments->data[(size_t)d];
 	    return arg->type;
 	}
 	case Tfunction:
 	case Tnone:
 	    error(loc, "can't have array of %s", tbn->toChars());
 	Expressions *arguments;
 	//LDC: Build arguments.
 	static FuncDeclaration *aaLen_fd = NULL;
 	if(!aaLen_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
 	    aaLen_fd = FuncDeclaration::genCfunc(args, Type::tsize_t, Id::aaLen);
 	}
 	ec = new VarExp(0, aaLen_fd);
 	arguments = new Expressions();
 	assert(size);
 	//LDC: Build arguments.
 	static FuncDeclaration *aaKeys_fd = NULL;
 	if(!aaKeys_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
 	    aaKeys_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::aaKeys);
 	}
 	ec = new VarExp(0, aaKeys_fd);
 	arguments = new Expressions();
 	Expressions *arguments;
 	//LDC: Build arguments.
 	static FuncDeclaration *aaValues_fd = NULL;
 	if(!aaValues_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
 	    aaValues_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::aaValues);
 	}
 	ec = new VarExp(0, aaValues_fd);
 	arguments = new Expressions();
 	Expressions *arguments;
 	//LDC: Build arguments.
 	static FuncDeclaration *aaRehash_fd = NULL;
 	if(!aaRehash_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
 	    aaRehash_fd = FuncDeclaration::genCfunc(args, Type::tvoidptr, Id::aaRehash);
 	}
 	ec = new VarExp(0, aaRehash_fd);
 	arguments = new Expressions();
 }
 /***************************** TypeFunction *****************************/
-TypeFunction::TypeFunction(Arguments *parameters, Type *treturn, int varargs, enum LINK linkage)
+TypeFunction::TypeFunction(Parameters *parameters, Type *treturn, int varargs, enum LINK linkage)
 : Type(Tfunction, treturn)
 {
 //if (!treturn) *(char*)0=0;
 //    assert(treturn);
 this->parameters = parameters;
 }
 Type *TypeFunction::syntaxCopy()
 {
 Type *treturn = next ? next->syntaxCopy() : NULL;
-Arguments *params = Argument::arraySyntaxCopy(parameters);
+Parameters *params = Parameter::arraySyntaxCopy(parameters);
-TypeFunction *t = new TypeFunction(params, treturn, varargs, linkage);
+Type *t = new TypeFunction(params, treturn, varargs, linkage);
 return t;
 }
 /*******************************
 * Returns:
 if (t1->varargs != t2->varargs)
 	goto Ldistinct;
 if (t1->parameters && t2->parameters)
 {
-	size_t dim = Argument::dim(t1->parameters);
+	size_t dim = Parameter::dim(t1->parameters);
-	if (dim != Argument::dim(t2->parameters))
+	if (dim != Parameter::dim(t2->parameters))
 	    goto Ldistinct;
 	for (size_t i = 0; i < dim; i++)
-	{   Argument *arg1 = Argument::getNth(t1->parameters, i);
+	{   Parameter *arg1 = Parameter::getNth(t1->parameters, i);
-	    Argument *arg2 = Argument::getNth(t2->parameters, i);
+	    Parameter *arg2 = Parameter::getNth(t2->parameters, i);
 	    if (!arg1->type->equals(arg2->type))
 		goto Ldistinct;
 	    if (arg1->storageClass != arg2->storageClass)
 		inoutmismatch = 1;
 	    }
 	}*/
 }
 // Write argument types
-Argument::argsToDecoBuffer(buf, parameters, mangle);
+Parameter::argsToDecoBuffer(buf, parameters, mangle);
 //if (buf->data[buf->offset - 1] == '@') halt();
 buf->writeByte('Z' - varargs);	// mark end of arg list
 next->toDecoBuffer(buf, mangle);
 inuse--;
 }
 	buf->writestring(p);
 if (ident)
 {   buf->writeByte(' ');
 	buf->writestring(ident->toHChars2());
 }
-Argument::argsToCBuffer(buf, hgs, parameters, varargs);
+Parameter::argsToCBuffer(buf, hgs, parameters, varargs);
 inuse--;
 }
 void TypeFunction::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 }
 if (!hgs->hdrgen && p)
 	buf->writestring(p);
 buf->writestring(" function");
-Argument::argsToCBuffer(buf, hgs, parameters, varargs);
+Parameter::argsToCBuffer(buf, hgs, parameters, varargs);
 inuse--;
 }
 Type *TypeFunction::semantic(Loc loc, Scope *sc)
 {
 //printf("TypeFunction::semantic() this = %p\n", this);
 TypeFunction *tf = (TypeFunction *)mem.malloc(sizeof(TypeFunction));
 memcpy(tf, this, sizeof(TypeFunction));
 if (parameters)
-{	tf->parameters = (Arguments *)parameters->copy();
+{	tf->parameters = (Parameters *)parameters->copy();
 	for (size_t i = 0; i < parameters->dim; i++)
-	{   Argument *arg = (Argument *)parameters->data[i];
+	{   Parameter *arg = (Parameter *)parameters->data[i];
-	    Argument *cpy = (Argument *)mem.malloc(sizeof(Argument));
+	    Parameter *cpy = (Parameter *)mem.malloc(sizeof(Parameter));
-	    memcpy(cpy, arg, sizeof(Argument));
+	    memcpy(cpy, arg, sizeof(Parameter));
 	    tf->parameters->data[i] = (void *)cpy;
 	}
 }
 tf->linkage = sc->linkage;
 	 */
 	Scope *argsc = sc->push();
 	argsc->stc = 0;			// don't inherit storage class
 	argsc->protection = PROTpublic;
-	size_t dim = Argument::dim(tf->parameters);
+	size_t dim = Parameter::dim(tf->parameters);
 	for (size_t i = 0; i < dim; i++)
-	{   Argument *arg = Argument::getNth(tf->parameters, i);
+	{   Parameter *arg = Parameter::getNth(tf->parameters, i);
 	    tf->inuse++;
 	    arg->type = arg->type->semantic(loc, argsc);
 	    if (tf->inuse == 1) tf->inuse--;
 	    /* If arg turns out to be a tuple, the number of parameters may
 	     * change.
 	     */
 	    if (t->ty == Ttuple)
-	    {	dim = Argument::dim(tf->parameters);
+	    {	dim = Parameter::dim(tf->parameters);
 		i--;
 	    }
 	}
 	argsc->pop();
 }
 {	error(loc, "recursive type");
 	tf->inuse = 0;
 	return terror;
 }
-if (tf->varargs == 1 && tf->linkage != LINKd && Argument::dim(tf->parameters) == 0)
+if (tf->varargs == 1 && tf->linkage != LINKd && Parameter::dim(tf->parameters) == 0)
 	error(loc, "variadic functions with non-D linkage must have at least one parameter");
 /* Don't return merge(), because arg identifiers and default args
 * can be different
 * even though the types match
 int TypeFunction::callMatch(Expressions *args)
 {
 //printf("TypeFunction::callMatch()\n");
 int match = MATCHexact;		// assume exact match
-size_t nparams = Argument::dim(parameters);
+size_t nparams = Parameter::dim(parameters);
 size_t nargs = args ? args->dim : 0;
 if (nparams == nargs)
 	;
 else if (nargs > nparams)
 {
 {	int m;
 	Expression *arg;
 	// BUG: what about out and ref?
-	Argument *p = Argument::getNth(parameters, u);
+	Parameter *p = Parameter::getNth(parameters, u);
 	assert(p);
 	if (u >= nargs)
 	{
 	    if (p->defaultArg)
 		continue;
 Type *TypeFunction::reliesOnTident()
 {
 if (parameters)
 {
 	for (size_t i = 0; i < parameters->dim; i++)
-	{   Argument *arg = (Argument *)parameters->data[i];
+	{   Parameter *arg = (Parameter *)parameters->data[i];
 	    Type *t = arg->type->reliesOnTident();
 	    if (t)
 		return t;
 	}
 }
 }
 TypeFunction *tf = (TypeFunction *)next;
 tf->next->toCBuffer2(buf, hgs, 0);
 buf->writestring(" delegate");
-Argument::argsToCBuffer(buf, hgs, tf->parameters, tf->varargs);
+Parameter::argsToCBuffer(buf, hgs, tf->parameters, tf->varargs);
 }
 Expression *TypeDelegate::defaultInit(Loc loc)
 {
 #if LOGDEFAULTINIT
 return TRUE;
 }
 /***************************** TypeTuple *****************************/
-TypeTuple::TypeTuple(Arguments *arguments)
+TypeTuple::TypeTuple(Parameters *arguments)
 : Type(Ttuple, NULL)
 {
 //printf("TypeTuple(this = %p)\n", this);
 this->arguments = arguments;
 //printf("TypeTuple() %s\n", toChars());
 #ifdef DEBUG
 if (arguments)
 {
 	for (size_t i = 0; i < arguments->dim; i++)
 	{
-	    Argument *arg = (Argument *)arguments->data[i];
+	    Parameter *arg = (Parameter *)arguments->data[i];
 	    assert(arg && arg->type);
 	}
 }
 #endif
 }
 */
 TypeTuple::TypeTuple(Expressions *exps)
 : Type(Ttuple, NULL)
 {
-Arguments *arguments = new Arguments;
+Parameters *arguments = new Parameters;
 if (exps)
 {
 	arguments->setDim(exps->dim);
 	for (size_t i = 0; i < exps->dim; i++)
 	{   Expression *e = (Expression *)exps->data[i];
 	    if (e->type->ty == Ttuple)
 		e->error("cannot form tuple of tuples");
-	    Argument *arg = new Argument(STCin, e->type, NULL, NULL);
+	    Parameter *arg = new Parameter(STCin, e->type, NULL, NULL);
 	    arguments->data[i] = (void *)arg;
 	}
 }
 this->arguments = arguments;
 }
 Type *TypeTuple::syntaxCopy()
 {
-Arguments *args = Argument::arraySyntaxCopy(arguments);
+Parameters *args = Parameter::arraySyntaxCopy(arguments);
 Type *t = new TypeTuple(args);
 return t;
 }
 Type *TypeTuple::semantic(Loc loc, Scope *sc)
 {	TypeTuple *tt = (TypeTuple *)t;
 	if (arguments->dim == tt->arguments->dim)
 	{
 	    for (size_t i = 0; i < tt->arguments->dim; i++)
-	    {   Argument *arg1 = (Argument *)arguments->data[i];
+	    {   Parameter *arg1 = (Parameter *)arguments->data[i];
-		Argument *arg2 = (Argument *)tt->arguments->data[i];
+		Parameter *arg2 = (Parameter *)tt->arguments->data[i];
 		if (!arg1->type->equals(arg2->type))
 		    return 0;
 	    }
 	    return 1;
 {
 if (arguments)
 {
 	for (size_t i = 0; i < arguments->dim; i++)
 	{
-	    Argument *arg = (Argument *)arguments->data[i];
+	    Parameter *arg = (Parameter *)arguments->data[i];
 	    Type *t = arg->type->reliesOnTident();
 	    if (t)
 		return t;
 	}
 }
 return NULL;
 }
 void TypeTuple::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
-Argument::argsToCBuffer(buf, hgs, arguments, 0);
+Parameter::argsToCBuffer(buf, hgs, arguments, 0);
 }
 void TypeTuple::toDecoBuffer(OutBuffer *buf, bool mangle)
 {
 //printf("TypeTuple::toDecoBuffer() this = %p\n", this);
 OutBuffer buf2;
-Argument::argsToDecoBuffer(&buf2, arguments, mangle);
+Parameter::argsToDecoBuffer(&buf2, arguments, mangle);
 unsigned len = buf2.offset;
 buf->printf("%c%d%.*s", mangleChar[ty], len, len, (char *)buf2.extractData());
 }
 Expression *TypeTuple::getProperty(Loc loc, Identifier *ident)
 if (!(i1 <= i2 && i2 <= tt->arguments->dim))
 {	error(loc, "slice [%ju..%ju] is out of range of [0..%u]", i1, i2, tt->arguments->dim);
 	return Type::terror;
 }
-Arguments *args = new Arguments;
+Parameters *args = new Parameters;
 args->reserve(i2 - i1);
 for (size_t i = i1; i < i2; i++)
-{	Argument *arg = (Argument *)tt->arguments->data[i];
+{	Parameter *arg = (Parameter *)tt->arguments->data[i];
 	args->push(arg);
 }
 return new TypeTuple(args);
 }
 buf->printf("[%s .. ", lwr->toChars());
 buf->printf("%s]", upr->toChars());
 }
-/***************************** Argument *****************************/
+/***************************** Parameter *****************************/
-Argument::Argument(unsigned storageClass, Type *type, Identifier *ident, Expression *defaultArg)
+Parameter::Parameter(unsigned storageClass, Type *type, Identifier *ident, Expression *defaultArg)
 {
 this->type = type;
 this->ident = ident;
 this->storageClass = storageClass;
 this->defaultArg = defaultArg;
 }
-Argument *Argument::syntaxCopy()
+Parameter *Parameter::syntaxCopy()
 {
-Argument *a = new Argument(storageClass,
+Parameter *a = new Parameter(storageClass,
 		type ? type->syntaxCopy() : NULL,
 		ident,
 		defaultArg ? defaultArg->syntaxCopy() : NULL);
 return a;
 }
-Arguments *Argument::arraySyntaxCopy(Arguments *args)
+Parameters *Parameter::arraySyntaxCopy(Parameters *args)
-{   Arguments *a = NULL;
+{   Parameters *a = NULL;
 if (args)
 {
-	a = new Arguments();
+	a = new Parameters();
 	a->setDim(args->dim);
 	for (size_t i = 0; i < a->dim; i++)
-	{   Argument *arg = (Argument *)args->data[i];
+	{   Parameter *arg = (Parameter *)args->data[i];
 	    arg = arg->syntaxCopy();
 	    a->data[i] = (void *)arg;
 	}
 }
 return a;
 }
-char *Argument::argsTypesToChars(Arguments *args, int varargs)
+char *Parameter::argsTypesToChars(Parameters *args, int varargs)
 {   OutBuffer *buf;
 buf = new OutBuffer();
 buf->writeByte('(');
 {	int i;
 	OutBuffer argbuf;
 	HdrGenState hgs;
 	for (i = 0; i < args->dim; i++)
-	{   Argument *arg;
+	{   Parameter *arg;
 	    if (i)
 		buf->writeByte(',');
-	    arg = (Argument *)args->data[i];
+	    arg = (Parameter *)args->data[i];
 	    argbuf.reset();
 	    arg->type->toCBuffer2(&argbuf, &hgs, 0);
 	    buf->write(&argbuf);
 	}
 	if (varargs)
 buf->writeByte(')');
 return buf->toChars();
 }
-void Argument::argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Arguments *arguments, int varargs)
+void Parameter::argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Parameters *arguments, int varargs)
 {
 buf->writeByte('(');
 if (arguments)
 {	int i;
 	OutBuffer argbuf;
 	for (i = 0; i < arguments->dim; i++)
-	{   Argument *arg;
+	{   Parameter *arg;
 	    if (i)
 		buf->writestring(", ");
-	    arg = (Argument *)arguments->data[i];
+	    arg = (Parameter *)arguments->data[i];
 	    if (arg->storageClass & STCout)
 		buf->writestring("out ");
 	    else if (arg->storageClass & STCref)
 		buf->writestring((global.params.Dversion == 1)
 			? (char *)"inout " : (char *)"ref ");
 }
 buf->writeByte(')');
 }
-void Argument::argsToDecoBuffer(OutBuffer *buf, Arguments *arguments, bool mangle)
+void Parameter::argsToDecoBuffer(OutBuffer *buf, Parameters *arguments, bool mangle)
 {
-//printf("Argument::argsToDecoBuffer()\n");
+//printf("Parameter::argsToDecoBuffer()\n");
 // Write argument types
 if (arguments)
 {
-	size_t dim = Argument::dim(arguments);
+	size_t dim = Parameter::dim(arguments);
 	for (size_t i = 0; i < dim; i++)
 	{
-	    Argument *arg = Argument::getNth(arguments, i);
+	    Parameter *arg = Parameter::getNth(arguments, i);
 	    arg->toDecoBuffer(buf, mangle);
 	}
 }
 }
 * Determine if parameter is a lazy array of delegates.
 * If so, return the return type of those delegates.
 * If not, return NULL.
 */
-Type *Argument::isLazyArray()
+Type *Parameter::isLazyArray()
 {
 //    if (inout == Lazy)
 {
 	Type *tb = type->toBasetype();
 	if (tb->ty == Tsarray || tb->ty == Tarray)
 	    if (tel->ty == Tdelegate)
 	    {
 		TypeDelegate *td = (TypeDelegate *)tel;
 		TypeFunction *tf = (TypeFunction *)td->next;
-		if (!tf->varargs && Argument::dim(tf->parameters) == 0)
+		if (!tf->varargs && Parameter::dim(tf->parameters) == 0)
 		{
 		    return tf->next;	// return type of delegate
 		}
 	    }
 	}
 }
 return NULL;
 }
-void Argument::toDecoBuffer(OutBuffer *buf, bool mangle)
+void Parameter::toDecoBuffer(OutBuffer *buf, bool mangle)
 {
 switch (storageClass & (STCin | STCout | STCref | STClazy))
 {   case 0:
 	case STCin:
 	    break;
 /***************************************
 * Determine number of arguments, folding in tuples.
 */
-size_t Argument::dim(Arguments *args)
+size_t Parameter::dim(Parameters *args)
 {
 size_t n = 0;
 if (args)
 {
 	for (size_t i = 0; i < args->dim; i++)
-	{   Argument *arg = (Argument *)args->data[i];
+	{   Parameter *arg = (Parameter *)args->data[i];
 	    Type *t = arg->type->toBasetype();
 	    if (t->ty == Ttuple)
 	    {   TypeTuple *tu = (TypeTuple *)t;
 		n += dim(tu->arguments);
 }
 return n;
 }
 /***************************************
-* Get nth Argument, folding in tuples.
+* Get nth Parameter, folding in tuples.
 * Returns:
-*	Argument*	nth Argument
+*	Parameter*	nth Parameter
 *	NULL		not found, *pn gets incremented by the number
-*			of Arguments
+*			of Parameters
 */
-Argument *Argument::getNth(Arguments *args, size_t nth, size_t *pn)
+Parameter *Parameter::getNth(Parameters *args, size_t nth, size_t *pn)
 {
 if (!args)
 	return NULL;
 size_t n = 0;
 for (size_t i = 0; i < args->dim; i++)
-{   Argument *arg = (Argument *)args->data[i];
+{   Parameter *arg = (Parameter *)args->data[i];
 	Type *t = arg->type->toBasetype();
 	if (t->ty == Ttuple)
 	{   TypeTuple *tu = (TypeTuple *)t;
 	    arg = getNth(tu->arguments, nth - n, &n);

Mercurial > projects > ldc

comparison dmd/mtype.c @ 1607:207a8a438dea