projects/ddmd: dmd/TypeStruct.d comparison

comparison dmd/TypeStruct.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	14feb7ae01a6
children	e3afd1303184

comparison

equal deleted inserted replaced

-:d237b38b5858
+:af724d3510d7
 	{
 		super(TY.Tstruct);
 		this.sym = sym;
 	}
 version (DumbClone) {
 } else {
 	final TypeStruct cloneTo(TypeStruct t)
 	{
 		super.cloneTo(t);
 		assert(t.sym is sym);
 		return t;
 	}
 	TypeStruct clone()
 	{
 		assert(this.classinfo == TypeStruct.classinfo);
 		return cloneTo(new TypeStruct(sym));
 	}
 }
 override ulong size(Loc loc)
 	{
 		return sym.size(loc);
 	}
 override uint alignsize()
 	{
 		uint sz;
 		sym.size(Loc(0));		// give error for forward references
 		sz = sym.alignsize;
 		if (sz > sym.structalign)
 			sz = sym.structalign;
 		return sz;
 	}
 override string toChars()
 	{
 		//printf("sym.parent: %s, deco = %s\n", sym.parent.toChars(), deco);
 		if (mod)
 			return Type.toChars();
 		{
 			return ti.toChars();
 		}
 		return sym.toChars();
 	}
 override Type syntaxCopy()
 	{
 		assert(false);
 	}
 override Type semantic(Loc loc, Scope sc)
 	{
 		//printf("TypeStruct.semantic('%s')\n", sym.toChars());
 		/* Cannot do semantic for sym because scope chain may not
 		 */
 		//sym.semantic(sc);
 		return merge();
 	}
 override Dsymbol toDsymbol(Scope sc)
 	{
 		return sym;
 	}
 override void toDecoBuffer(OutBuffer buf, int flag)
 	{
 		string name = sym.mangle();
 		//printf("TypeStruct.toDecoBuffer('%s') = '%s'\n", toChars(), name);
 		Type.toDecoBuffer(buf, flag);
 		buf.printf("%s", name);
 	}
 override void toCBuffer2(OutBuffer buf, HdrGenState* hgs, MOD mod)
 	{
 		if (mod != this.mod)
 		{
 			toCBuffer3(buf, hgs, mod);
 			return;
 		}
 		TemplateInstance ti = sym.parent.isTemplateInstance();
 		if (ti && ti.toAlias() == sym)
 			buf.writestring(ti.toChars());
 		else
 			buf.writestring(sym.toChars());
 	}
 override Expression dotExp(Scope sc, Expression e, Identifier ident)
 	{
 		uint offset;
 		VarDeclaration v;
 			 */
 			e = e.semantic(sc);	// do this before turning on noaccesscheck
 			auto exps = new Expressions;
 			exps.reserve(sym.fields.dim);
 			for (size_t i = 0; i < sym.fields.dim; i++)
 			{
 				VarDeclaration v2 = cast(VarDeclaration)sym.fields[i];
 				Expression fe = new DotVarExp(e.loc, e, v2);
 				exps.push(fe);
 			}
 			e = new TupleExp(e.loc, exps);
 			sc.pop();
 			return e;
 		}
 		if (e.op == TOK.TOKdotexp)
 		{
 			DotExp de2 = cast(DotExp)e;
 			if (de2.e1.op == TOK.TOKimport)
 			{
 				assert(0);	// cannot find a case where this happens; leave
 		v = s.isVarDeclaration();
 		if (v && !v.isDataseg())
 		{
 			Expression ei = v.getConstInitializer();
 			if (ei)
 			{
 				e = ei.copy();	// need to copy it if it's a StringExp
 				e = e.semantic(sc);
 				return e;
 			}
 		}
 			return e;
 		}
 		TemplateInstance ti = s.isTemplateInstance();
 		if (ti)
 		{
 			if (!ti.semanticRun)
 				ti.semantic(sc);
 			s = ti.inst.toAlias();
 			if (!s.isTemplateInstance())
 				goto L1;
 			return e;
 		}
 		OverloadSet o = s.isOverloadSet();
 		if (o)
 		{
 			/* We really should allow this, triggered by:
 			 *   template c()
 			 *   {
 			 *		void a();
 			 *		void b () { this.a(); }
 			writef("d = %s '%s'\n", s.kind(), s.toChars());
 	}
 		assert(d);
 		if (e.op == TOK.TOKtype)
 		{
 			FuncDeclaration fd = sc.func;
 			if (d.isTupleDeclaration())
 			{
 				e = new TupleExp(e.loc, d.isTupleDeclaration());
 		}
 		de = new DotVarExp(e.loc, e, d);
 		return de.semantic(sc);
 	}
 override uint memalign(uint salign)
 	{
 		sym.size(Loc(0));		// give error for forward references
 		return sym.structalign;
 	}
 override Expression defaultInit(Loc loc)
 	{
 	version (LOGDEFAULTINIT) {
 		printf("TypeStruct::defaultInit() '%s'\n", toChars());
 	}
 		Declaration d = new SymbolDeclaration(sym.loc, s, sym);
 		assert(d);
 		d.type = this;
 		return new VarExp(sym.loc, d);
 	}
 /***************************************
 * Use when we prefer the default initializer to be a literal,
 * rather than a global immutable variable.
 */
 override Expression defaultInitLiteral(Loc loc)
 	        auto vd = cast(VarDeclaration)(sym.fields[j]);
 	        Expression e;
 	        if (vd.init)
 	            e = vd.init.toExpression();
 	        else
-	            e = vd.type.defaultInitLiteral();
+	            e = vd.type.defaultInitLiteral(Loc(0));
 	        structelems[j] = e;
 }
 auto structinit = new StructLiteralExp(loc, cast(StructDeclaration)sym, structelems);
 // Why doesn't the StructLiteralExp constructor do this, when
 // sym->type != NULL ?
 structinit.type = sym.type;
 return structinit;
 }
 override bool isZeroInit(Loc loc)
 	{
 		return sym.zeroInit;
 	}
 override bool isAssignable()
 	{
 		/* If any of the fields are const or invariant,
 		 * then one cannot assign this struct.
 		 */
 		for (size_t i = 0; i < sym.fields.dim; i++)
 		{
 			VarDeclaration v = cast(VarDeclaration)sym.fields[i];
 			if (v.isConst() || v.isImmutable())
 				return false;
 		}
 		return true;
 	}
 override bool checkBoolean()
 	{
 		return false;
 	}
 override dt_t** toDt(dt_t** pdt)
 	{
 		sym.toDt(pdt);
 		return pdt;
 	}
 override MATCH deduceType(Scope sc, Type tparam, TemplateParameters parameters, Objects dedtypes)
 	{
 		//printf("TypeStruct.deduceType()\n");
 		//printf("\tthis.parent   = %s, ", sym.parent.toChars()); print();
 		//printf("\ttparam = %d, ", tparam.ty); tparam.print();
 			if (sym != tp.sym)
 				return MATCHnomatch;
 		}
 		return Type.deduceType(sc, tparam, parameters, dedtypes);
 	}
 override TypeInfoDeclaration getTypeInfoDeclaration()
 	{
 		return new TypeInfoStructDeclaration(this);
 	}
 override bool hasPointers()
 	{
 // Probably should cache this information in sym rather than recompute
 		StructDeclaration s = sym;
 				return true;
 		}
 		return false;
 	}
 override MATCH implicitConvTo(Type to)
 	{
 		MATCH m;
 		//printf("TypeStruct.implicitConvTo(%s => %s)\n", toChars(), to.toChars());
 		if (ty == to.ty && sym == (cast(TypeStruct)to).sym)
 		{
 			m = MATCHexact;		// exact match
 			if (mod != to.mod)
 			{
 				if (MODimplicitConv(mod, to.mod))
 					m = MATCHconst;
 				else
 				{	/* Check all the fields. If they can all be converted,
 					 * allow the conversion.
 					 */
 					foreach (VarDeclaration v; sym.fields)
 					{
 						assert(v && v.storage_class & STCfield);
 						// 'from' type
 						Type tvf = v.type.addMod(mod);
 		else if (sym.aliasthis)
 		{
 			m = MATCHnomatch;
 			Declaration d = sym.aliasthis.isDeclaration();
 			if (d)
 			{
 				assert(d.type);
 				Type t = d.type.addMod(mod);
 				m = t.implicitConvTo(to);
 			}
 		}
 		else
 			m = MATCHnomatch;	// no match
 		return m;
 	}
 override MATCH constConv(Type to)
 	{
 		if (equals(to))
 			return MATCHexact;
 		if (ty == to.ty && sym == (cast(TypeStruct)to).sym &&
 MODimplicitConv(mod, to.mod))
 			return MATCHconst;
 		return MATCHnomatch;
 	}
 override Type toHeadMutable()
 	{
 		assert(false);
 	}
 version (CPP_MANGLE) {
 void toCppMangle(OutBuffer buf, CppMangleState* cms)
 	{
 		assert(false);
 	}
 		/* Add in fields of the struct
 		 * (after setting ctype to avoid infinite recursion)
 		 */
 		if (global.params.symdebug) {
 			for (int i = 0; i < sym.fields.dim; i++)
 			{
 				VarDeclaration v = cast(VarDeclaration)sym.fields[i];
 				Symbol* s2 = symbol_name(toStringz(v.ident.toChars()), SC.SCmember, v.type.toCtype());
 				s2.Smemoff = v.offset;
 				list_append(&s.Sstruct.Sfldlst, s2);

Mercurial > projects > ddmd

comparison dmd/TypeStruct.d @ 174:af724d3510d7