projects/ldc: dmd/mtype.c comparison

comparison dmd/mtype.c @ 1103:b30fe7e1dbb9

- Updated to DMD frontend 1.041. - Removed dmd/inifile.c , it's not under a free license, replaced with libconfig based config file.

author	Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
date	Thu, 12 Mar 2009 20:37:27 +0100
parents	dc608dc33081
children	e7f0c2b48047

comparison

equal deleted inserted replaced

-:ae950bd712d3
+:b30fe7e1dbb9
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2008 by Digital Mars
+// Copyright (c) 1999-2009 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.
 #include <bits/mathdef.h>
 #endif
 static double zero = 0;
 #endif
-#include "mem.h"
+#include "rmem.h"
 #include "dsymbol.h"
 #include "mtype.h"
 #include "scope.h"
 #include "init.h"
 mangleChar[Tinstance] = '@';
 mangleChar[Terror] = '@';
 mangleChar[Ttypeof] = '@';
 mangleChar[Ttuple] = 'B';
 mangleChar[Tslice] = '@';
+mangleChar[Treturn] = '@';
 for (i = 0; i < TMAX; i++)
 {	if (!mangleChar[i])
 	    fprintf(stdmsg, "ty = %d\n", i);
 	assert(mangleChar[i]);
 va_start(ap, format);
 ::verror(loc, format, ap);
 va_end( ap );
 }
+void Type::warning(Loc loc, const char *format, ...)
+{
+if (global.params.warnings && !global.gag)
+{
+	fprintf(stdmsg, "warning - ");
+	va_list ap;
+	va_start(ap, format);
+	::verror(loc, format, ap);
+	va_end( ap );
+}
+}
 Identifier *Type::getTypeInfoIdent(int internal)
 {
 // _init_10TypeInfo_%s
 OutBuffer buf;
 Identifier *id;
 //toTypeInfoBuffer(&buf);
 if (internal)
 {	buf.writeByte(mangleChar[ty]);
 	if (ty == Tarray)
-	    buf.writeByte(mangleChar[next->ty]);
+	    buf.writeByte(mangleChar[((TypeArray *)this)->next->ty]);
 }
 else
 	toDecoBuffer(&buf);
 len = buf.offset;
 name = (char *)alloca(19 + sizeof(len) * 3 + len + 1);
 }
 void Type::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps)
 {
-Type *t;
+//printf("Type::resolve() %s, %d\n", toChars(), ty);
+Type *t = semantic(loc, sc);
-t = semantic(loc, sc);
 *pt = t;
 *pe = NULL;
 *ps = NULL;
 }
 {	integer_t n, n2;
 	dim = semanticLength(sc, tbn, dim);
 	dim = dim->optimize(WANTvalue | WANTinterpret);
-	if (sc->parameterSpecialization && dim->op == TOKvar &&
+	if (sc && sc->parameterSpecialization && dim->op == TOKvar &&
 	    ((VarExp *)dim)->var->storage_class & STCtemplateparameter)
 	{
 	    /* It could be a template parameter N which has no value yet:
 	     *   template Foo(T : T[N], size_t N);
 	     */
 	    if (n2 >= 0x1000000)	// put a 'reasonable' limit on it
 		goto Loverflow;
 	    if (n && n2 / n != d2)
 	    {
 	      Loverflow:
-		error(loc, "index %lld overflow for static array", d1);
+		error(loc, "index %jd overflow for static array", d1);
 		dim = new IntegerExp(0, 1, tsize_t);
 	    }
 	}
 }
 switch (tbn->ty)
 	    assert(dim);
 	    TypeTuple *tt = (TypeTuple *)tbn;
 	    uinteger_t d = dim->toUInteger();
 	    if (d >= tt->arguments->dim)
-	    {	error(loc, "tuple index %llu exceeds %u", 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];
 	    return arg->type;
 	}
 void TypeSArray::toDecoBuffer(OutBuffer *buf)
 {
 buf->writeByte(mangleChar[ty]);
 if (dim)
-	buf->printf("%llu", dim->toInteger());
+	buf->printf("%ju", dim->toInteger());
 if (next)
 	next->toDecoBuffer(buf);
 }
 void TypeSArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 Expression *TypeReference::defaultInit(Loc loc)
 {
 #if LOGDEFAULTINIT
 printf("TypeReference::defaultInit() '%s'\n", toChars());
 #endif
-Expression *e;
+Expression *e = new NullExp(loc);
-e = new NullExp(loc);
 e->type = this;
 return e;
 }
 int TypeReference::isZeroInit()
 this->exp = exp;
 }
 Type *TypeTypeof::syntaxCopy()
 {
+//printf("TypeTypeof::syntaxCopy() %s\n", toChars());
 TypeTypeof *t;
 t = new TypeTypeof(loc, exp->syntaxCopy());
 t->syntaxCopyHelper(this);
 return t;
 if (!sym->symtab)
 	goto Lfwd;
 s = sym->symtab->lookup(ident);
 if (!s)
 {
-	return getProperty(e->loc, ident);
+	if (ident == Id::max ||
+	    ident == Id::min ||
+	    ident == Id::init ||
+	    ident == Id::stringof ||
+	    !sym->memtype
+	   )
+	{
+	    return getProperty(e->loc, ident);
+	}
+	return sym->memtype->dotExp(sc, e, ident);
 }
 m = s->isEnumMember();
 em = m->value->copy();
 em->loc = e->loc;
 return em;
 TypeTuple::TypeTuple(Arguments *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++)
 	{
 }
 Type *TypeTuple::semantic(Loc loc, Scope *sc)
 {
 //printf("TypeTuple::semantic(this = %p)\n", this);
+//printf("TypeTuple::semantic() %s\n", toChars());
 if (!deco)
 	deco = merge()->deco;
 /* Don't return merge(), because a tuple with one type has the
 * same deco as that type.
 upr = semanticLength(sc, tbn, upr);
 upr = upr->optimize(WANTvalue);
 uinteger_t i2 = upr->toUInteger();
 if (!(i1 <= i2 && i2 <= tt->arguments->dim))
-{	error(loc, "slice [%llu..%llu] is out of range of [0..%u]", i1, 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;
 args->reserve(i2 - i1);
 	    uinteger_t i2 = upr->toUInteger();
 	    sc = sc->pop();
 	    if (!(i1 <= i2 && i2 <= td->objects->dim))
-	    {   error(loc, "slice [%llu..%llu] is out of range of [0..%u]", i1, i2, td->objects->dim);
+	    {   error(loc, "slice [%ju..%ju] is out of range of [0..%u]", i1, i2, td->objects->dim);
 		goto Ldefault;
 	    }
 	    if (i1 == 0 && i2 == td->objects->dim)
 	    {

Mercurial > projects > ldc

comparison dmd/mtype.c @ 1103:b30fe7e1dbb9