projects/ddmd: dmd/NewExp.d comparison

comparison dmd/NewExp.d @ 174:af724d3510d7

lot os toCBuffer methods implemented moved shared Type.* stuff into Global

author	korDen
date	Sun, 10 Oct 2010 03:47:23 +0400
parents	60bb0fe4563e
children	e3afd1303184

comparison

equal deleted inserted replaced

-:d237b38b5858
+:af724d3510d7
 import dmd.NewDeclaration;
 import dmd.CtorDeclaration;
 import dmd.ClassDeclaration;
 import dmd.Type;
 import dmd.OutBuffer;
+import dmd.PREC;
 import dmd.Loc;
 import dmd.Scope;
 import dmd.IRState;
 import dmd.InlineDoState;
 import dmd.HdrGenState;
 		if (type)			// if semantic() already run
 			return this;
 	Lagain:
 		if (thisexp)
 		{
 			thisexp = thisexp.semantic(sc);
 			cdthis = thisexp.type.isClassHandle();
 			if (cdthis)
 			{
 				sc = sc.push(cdthis);
 		if (thisexp && tb.ty != Tclass)
 			error("e.new is only for allocating nested classes, not %s", tb.toChars());
 		if (tb.ty == Tclass)
 		{
 			TypeFunction tf;
 			TypeClass tc = cast(TypeClass)tb;
 			ClassDeclaration cd = tc.sym.isClassDeclaration();
 			if (cd.isInterfaceDeclaration())
 				error("cannot create instance of interface %s", cd.toChars());
 			else if (cd.isAbstract())
 			{
 				error("cannot create instance of abstract class %s", cd.toChars());
 				for (int j = 0; j < cd.vtbl.dim; j++)
 				{
 					FuncDeclaration fd = (cast(Dsymbol)cd.vtbl.data[j]).isFuncDeclaration();
 					if (fd && fd.isAbstract())
 						error("function %s is abstract", fd.toChars());
 				}
 			}
 					if (!cdthis)
 					{
 						// Supply an implicit 'this' and try again
 						thisexp = new ThisExp(loc);
 						for (Dsymbol sp = sc.parent; 1; sp = sp.parent)
 						{
 							if (!sp)
 							{
 								error("outer class %s 'this' needed to 'new' nested class %s", cdn.toChars(), cd.toChars());
 								break;
 							}
 						}
 					}
 				}
 	///} else {
 	///			else if (fdn)
 	///			{
 	///				/* The nested class cd is nested inside a function,
 	///				 * we'll let getEthis() look for errors.
 	///				 */
 	///				//printf("nested class %s is nested inside function %s, we're in %s\n", cd.toChars(), fdn.toChars(), sc.func.toChars());
 	///				if (thisexp)
 		else if (tb.ty == Tarray && (arguments && arguments.dim))
 		{
 			for (size_t j = 0; j < arguments.dim; j++)
 			{
 				if (tb.ty != Tarray)
 				{
 					error("too many arguments for array");
 					arguments.dim = i;
 					break;
 				}
 		// Optimize parameters
 		if (newargs)
 		{
 			foreach (ref Expression e; newargs)
 			{
 				e = e.optimize(WANTvalue);
 			}
 		}
 		if (arguments)
 		{
 			foreach (ref Expression e; arguments)
 			{
 				e = e.optimize(WANTvalue);
 			}
 		}
 		return this;
 	}
 			elem *ex = null;
 			elem *ey = null;
 			elem *ez = null;
 			if (allocator || onstack)
 			{
 				elem *ei;
 				Symbol *si;
 				if (onstack)
 				{
 				//elem_print(ey);
 				//elem_print(ez);
 			}
 			if (thisexp)
 			{
 				ClassDeclaration cdthis = thisexp.type.isClassHandle();
 				assert(cdthis);
 				//printf("cd = %s\n", cd.toChars());
 				//printf("cdthis = %s\n", cdthis.toChars());
 				assert(cd.isNested());
 				//printf("member = %p\n", member);
 				//printf("cdp = %s\n", cdp.toChars());
 				//printf("cdthis = %s\n", cdthis.toChars());
 				if (cdp != cdthis)
 				{
 					int i = cdp.isClassDeclaration().isBaseOf(cdthis, &offset);
 					assert(i);
 				}
 				ethis = thisexp.toElem(irs);
 				if (offset)
 				//printf("ex: "); elem_print(ex);
 				//printf("ey: "); elem_print(ey);
 				//printf("ez: "); elem_print(ez);
 			}
 			else if (cd.isNested())
 			{
 				/* Initialize cd.vthis:
 				 *	*(ey + cd.vthis.offset) = this;
 				 */
 				ey = setEthis(loc, irs, ey, cd);
 			}
 			elem* ex = null;
 			elem* ey = null;
 			elem* ez = null;
 			if (allocator)
 			{
 				elem *ei;
 				Symbol *si;
 				ex = el_var(allocator.toSymbol());
 				ex = callfunc(loc, irs, 1, type, ex, allocator.type,
 				}
 				else if (member)
 					ez = el_same(&ex);
 				if (!member)
 				{
 					/* Statically intialize with default initializer
 					 */
 					ex = el_una(OPind, TYstruct, ex);
 					ex = el_bin(OPstreq, TYnptr, ex, ei);
 					ex.Enumbytes = cd.size(loc);
 				//elem_print(ey);
 				//elem_print(ez);
 			}
 			if (cd.isNested())
 			{
 				/* Initialize cd.vthis:
 				 *	*(ey + cd.vthis.offset) = this;
 				 */
 				ey = setEthis(loc, irs, ey, cd);
 			}
 			if (member)
 			{
 				// Call constructor
 				ez = callfunc(loc, irs, 1, type, ez, ectype, member, member.type, null, arguments);
 		version (STRUCTTHISREF) {
 				/* Structs return a ref, which gets automatically dereferenced.
 				 * But we want a pointer to the instance.
 		{
 			TypeDArray tda = cast(TypeDArray)t;
 			assert(arguments && arguments.dim >= 1);
 			if (arguments.dim == 1)
 			{
 				// Single dimension array allocations
 				auto arg = arguments[0];	// gives array length
 				e = arg.toElem(irs);
 				ulong elemsize = tda.next.size();
 				e = el_param(e, type.getTypeInfo(null).toElem(irs));
 				int rtl = tda.next.isZeroInit(Loc(0)) ? RTLSYM_NEWARRAYT : RTLSYM_NEWARRAYIT;
 				e = el_bin(OPcall,TYdarray,el_var(rtlsym[rtl]),e);
 			}
 			else
 			{
 				// Multidimensional array allocations
 				e = el_long(TYint, arguments.dim);
 				foreach (Expression arg; arguments)
 				{
 					e = el_param(arg.toElem(irs), e);
 		return true;
 	}
 	override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
 	{
-		assert(false);
+		int i;
+		if (thisexp)
+		{
+			expToCBuffer(buf, hgs, thisexp, PREC.PREC_primary);
+			buf.writeByte('.');
+		}
+		buf.writestring("new ");
+		if (newargs && newargs.dim)
+		{
+			buf.writeByte('(');
+			argsToCBuffer(buf, newargs, hgs);
+			buf.writeByte(')');
+		}
+		newtype.toCBuffer(buf, null, hgs);
+		if (arguments && arguments.dim)
+		{
+			buf.writeByte('(');
+			argsToCBuffer(buf, arguments, hgs);
+			buf.writeByte(')');
+		}
 	}
 	override void scanForNestedRef(Scope sc)
 	{
 	    //printf("NewExp.scanForNestedRef(Scope *sc): %s\n", toChars());
 	override bool canThrow()
 	{
 		return 1;
 	}
 }
 	//int inlineCost(InlineCostState *ics);
 	override Expression doInline(InlineDoState ids)
 	{
 		//printf("NewExp.doInline(): %s\n", toChars());
 			ne.thisexp = thisexp.doInline(ids);
 		ne.newargs = arrayExpressiondoInline(ne.newargs, ids);
 		ne.arguments = arrayExpressiondoInline(ne.arguments, ids);
 		return ne;
 	}
 	//Expression inlineScan(InlineScanState *iss);
 }

Mercurial > projects > ddmd

comparison dmd/NewExp.d @ 174:af724d3510d7