projects/ldc: dmd2/mtype.c comparison

comparison dmd2/mtype.c @ 1577:e4f7b5d9c68a

DMD 2.032 Merge.

author	Robert Clipsham <robert@octarineparrot.com>
date	Tue, 08 Sep 2009 10:07:56 +0100
parents	54b3c1394d62
children

comparison

equal deleted inserted replaced

-:4551475bc6b6
+:e4f7b5d9c68a
 for (i = 0; i < TMAX; i++)
 	sizeTy[i] = sizeof(TypeBasic);
 sizeTy[Tsarray] = sizeof(TypeSArray);
 sizeTy[Tarray] = sizeof(TypeDArray);
+//sizeTy[Tnarray] = sizeof(TypeNArray);
 sizeTy[Taarray] = sizeof(TypeAArray);
 sizeTy[Tpointer] = sizeof(TypePointer);
 sizeTy[Treference] = sizeof(TypeReference);
 sizeTy[Tfunction] = sizeof(TypeFunction);
 sizeTy[Tdelegate] = sizeof(TypeDelegate);
 sizeTy[Tslice] = sizeof(TypeSlice);
 sizeTy[Treturn] = sizeof(TypeReturn);
 mangleChar[Tarray] = 'A';
 mangleChar[Tsarray] = 'G';
+mangleChar[Tnarray] = '@';
 mangleChar[Taarray] = 'H';
 mangleChar[Tpointer] = 'P';
 mangleChar[Treference] = 'R';
 mangleChar[Tfunction] = 'F';
 mangleChar[Tident] = 'I';
 	if (this->mod & MODshared)
 	    buf->writeByte(')');
 }
 }
+void Type::modToBuffer(OutBuffer *buf)
+{
+if (mod & MODshared)
+buf->writestring(" shared");
+if (mod & MODconst)
+buf->writestring(" const");
+if (mod & MODinvariant)
+buf->writestring(" immutable");
+}
 /************************************
 */
 Type *Type::merge()
 {   Type *t;
 Type *TypeNext::reliesOnTident()
 {
 return next->reliesOnTident();
 }
+/*******************************
+* For TypeFunction, nextOf() can return NULL if the function return
+* type is meant to be inferred, and semantic() hasn't yet ben run
+* on the function. After semantic(), it must no longer be NULL.
+*/
 Type *TypeNext::nextOf()
 {
 return next;
 }
 int TypeDArray::hasPointers()
 {
 return TRUE;
 }
+/***************************** TypeNewArray *****************************/
+#if 0
+TypeNewArray::TypeNewArray(Type *telement)
+	: TypeArray(Tnewarray, telement)
+{
+sym = NULL;
+}
+Type *TypeNewArray::syntaxCopy()
+{
+Type *t = next->syntaxCopy();
+if (t == next)
+	t = this;
+else
+{	t = new TypeNewArray(t);
+	t->mod = mod;
+}
+return t;
+}
+d_uns64 TypeNewArray::size(Loc loc)
+{
+//printf("TypeNewArray::size()\n");
+return PTRSIZE;
+}
+unsigned TypeNewArray::alignsize()
+{
+return PTRSIZE;
+}
+Type *TypeNewArray::semantic(Loc loc, Scope *sc)
+{   Type *tn = next;
+tn = next->semantic(loc,sc);
+Type *tbn = tn->toBasetype();
+switch (tbn->ty)
+{
+	case Tfunction:
+	case Tnone:
+	case Ttuple:
+	    error(loc, "can't have array of %s", tbn->toChars());
+	    tn = next = tint32;
+	    break;
+	case Tstruct:
+	{   TypeStruct *ts = (TypeStruct *)tbn;
+	    if (ts->sym->isnested)
+		error(loc, "cannot have array of inner structs %s", ts->toChars());
+	    break;
+	}
+}
+if (tn->isauto())
+	error(loc, "cannot have array of auto %s", tn->toChars());
+next = tn;
+transitive();
+return merge();
+}
+void TypeNewArray::toDecoBuffer(OutBuffer *buf, int flag)
+{
+Type::toDecoBuffer(buf, flag);
+buf->writeByte('e');
+if (next)
+	next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod);
+}
+void TypeNewArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
+{
+if (mod != this->mod)
+{	toCBuffer3(buf, hgs, mod);
+	return;
+}
+next->toCBuffer2(buf, hgs, this->mod);
+buf->writestring("[new]");
+}
+#endif
 /***************************** TypeAArray *****************************/
 TypeAArray::TypeAArray(Type *t, Type *index)
 : TypeArray(Taarray, t)
 {
 this->varargs = varargs;
 this->linkage = linkage;
 this->inuse = 0;
 this->isnothrow = false;
 this->ispure = false;
+this->isproperty = false;
 this->isref = false;
 #if IN_LLVM
 this->funcdecl = NULL;
 #endif
 Arguments *params = Argument::arraySyntaxCopy(parameters);
 TypeFunction *t = new TypeFunction(params, treturn, varargs, linkage);
 t->mod = mod;
 t->isnothrow = isnothrow;
 t->ispure = ispure;
+t->isproperty = isproperty;
 t->isref = isref;
 return t;
 }
 /*******************************
 	default:
 	    assert(0);
 }
 buf->writeByte(mc);
+if (ispure || isnothrow || isproperty || isref)
-if (ispure || isnothrow || isref)
 {
 	if (ispure)
 	    buf->writestring("Na");
 	if (isnothrow)
 	    buf->writestring("Nb");
 	if (isref)
 	    buf->writestring("Nc");
+	if (isproperty)
+	    buf->writestring("Nd");
 }
 // LDC: if we're not producing a mangle string, add the this
 // type to prevent merging different member function
 if (!mangle && funcdecl)
 if (ispure)
 	buf->writestring("pure ");
 if (isnothrow)
 	buf->writestring("nothrow ");
+if (isproperty)
+	buf->writestring("@property ");
 if (isref)
 	buf->writestring("ref ");
 if (next && (!ident || ident->toHChars2() == ident->toChars()))
 	next->toCBuffer2(buf, hgs, 0);
 /* Use postfix style for attributes
 */
 if (mod != this->mod)
 {
-	if (mod & MODconst)
+	modToBuffer(buf);
-	    buf->writestring(" const");
-	if (mod & MODinvariant)
-	    buf->writestring(" immutable");
-	if (mod & MODshared)
-	    buf->writestring(" shared");
 }
 if (ispure)
 	buf->writestring(" pure");
 if (isnothrow)
 	buf->writestring(" nothrow");
+if (isproperty)
+	buf->writestring(" @property");
 if (isref)
 	buf->writestring(" ref");
 inuse--;
 }
 char *TypeClass::toChars()
 {
 if (mod)
 	return Type::toChars();
-return sym->toPrettyChars();
+return (char *)sym->toPrettyChars();
 }
 Type *TypeClass::syntaxCopy()
 {
 return this;

Mercurial > projects > ldc

comparison dmd2/mtype.c @ 1577:e4f7b5d9c68a