projects/ddmd: dmd/AggregateDeclaration.d comparison

comparison dmd/AggregateDeclaration.d @ 176:fa9a71a9f5a8

Moved all the mutable globals to Global

author	korDen
date	Sun, 10 Oct 2010 05:22:45 +0400
parents	206db751bd4c
children	e3afd1303184

comparison

equal deleted inserted replaced

-:94b6033c07f3
+:fa9a71a9f5a8
 import dmd.StructDeclaration;
 import dmd.Declaration;
 import dmd.TypeClass;
 import dmd.TOK;
 import dmd.ThisExp;
+import dmd.Global;
 import dmd.PROT;
 import dmd.Expression;
 import dmd.STC;
 import dmd.DotIdExp;
 import dmd.CallExp;
 		{
 			ClassDeclaration cdthis = dthis.isClassDeclaration();
 			if (cdthis)
 			{
 				foreach (b; cdthis.baseclasses)
 				{
 					PROT access = b.base.getAccess(smember);
 					if (access >= PROT.PROTprotected || accessCheckX(smember, sfunc, b.base, cdscope))
 						return true;
 				}
 		{
 			ClassDeclaration cdthis = dthis.isClassDeclaration();
 			if (cdthis)
 			{
 				foreach (b; cdthis.baseclasses)
 				{
 					if (accessCheckX(smember, sfunc, b.base, cdscope))
 						return true;
 				}
 			}
 		}
 uint sizeok;		// set when structsize contains valid data
 				// 0: no size
 				// 1: size is correct
 				// 2: cannot determine size; fwd referenced
 bool isdeprecated;		// true if deprecated
 version (DMDV2) {
 bool isnested;		// true if is nested
 VarDeclaration vthis;	// 'this' parameter if this aggregate is nested
 }
 // Special member functions
 this(Loc loc, Identifier id)
 	{
 		super(id);
 		this.loc = loc;
 		fields = new VarDeclarations();	///
 		dtors = new FuncDeclarations();
 	}
 override void semantic2(Scope sc)
 	{
 		//printf("AggregateDeclaration.semantic2(%s)\n", toChars());
 		if (scope_ && members)
 		{
 			error("has forward references");
 			return;
 		}
 		if (members)
 		{
 				//printf("inline scan aggregate symbol '%s'\n", s.toChars());
 				s.inlineScan();
 			}
 		}
 	}
 override uint size(Loc loc)
 	{
 		//printf("AggregateDeclaration.size() = %d\n", structsize);
 		if (!members)
 			error(loc, "unknown size");
 		if (sizeok != 1)
 		{
 			error(loc, "no size yet for forward reference");
 			//*(char*)0=0;
 		}
 		return structsize;
 	}
 	/****************************
 	 * Do byte or word alignment as necessary.
 	 * Align sizes of 0, as we may not know array sizes yet.
 	 */
 static void alignmember(uint salign, uint size, uint* poffset)
 				sa = salign;
 			*poffset = (*poffset + sa - 1) & ~(sa - 1);
 		}
 		//printf("result = %d\n",offset);
 	}
 override Type getType()
 	{
 		return type;
 	}
 void addField(Scope sc, VarDeclaration v)
 	{
 		uint memsize;		// size of member
 		uint memalignsize;	// size of member for alignment purposes
 		uint xalign;		// alignment boundaries
 		// Check for forward referenced types which will fail the size() call
 		Type t = v.type.toBasetype();
 		if (v.storage_class & STC.STCref)
 		{	// References are the size of a pointer
-		t = Type.tvoidptr;
+		t = global.tvoidptr;
 		}
 		if (t.ty == TY.Tstruct /*&& isStructDeclaration()*/)
 		{	TypeStruct ts = cast(TypeStruct)t;
 version (DMDV2) {
 		if (ts.sym == this)
 		v.storage_class |= STC.STCfield;
 		//printf(" addField '%s' to '%s' at offset %d, size = %d\n", v.toChars(), toChars(), v.offset, memsize);
 		fields.push(v);
 	}
 override bool isDeprecated()		// is aggregate deprecated?
 	{
 		return isdeprecated;
 	}
 			}
 			if (tv.ty == TY.Tstruct)
 			{   TypeStruct ts = cast(TypeStruct)tv;
 				StructDeclaration sd = ts.sym;
 				if (sd.dtor)
 				{
 					Expression ex;
 					// this.v
 					ex = new ThisExp(Loc(0));
 					ex = new DotVarExp(Loc(0), ex, v, 0);
 					if (dim == 1)
 					{
 						// this.v.dtor()
 						ex = new DotVarExp(Loc(0), ex, sd.dtor, 0);
 						ex = new CallExp(Loc(0), ex);
 					}
 					else
 		}
 		/* Build our own "destructor" which executes e
 		 */
 		if (e)
 		{
 			//printf("Building __fieldDtor()\n");
 			DtorDeclaration dd = new DtorDeclaration(Loc(0), Loc(0), Lexer.idPool("__fieldDtor"));
 			dd.fbody = new ExpStatement(Loc(0), e);
 			dtors.shift(dd);
 			members.push(dd);
 override void emitComment(Scope sc)
 	{
 		assert(false);
 	}
 	override void toJsonBuffer(OutBuffer buf)
 	{
 		//writef("AggregateDeclaration.toJsonBuffer()\n");
 		buf.writestring("{\n");
 		JsonProperty(buf, Pname, toChars());
 		JsonProperty(buf, Pkind, kind());
 		if (comment)
 			JsonProperty(buf, Pcomment, comment);
 		if (loc.linnum)
 			JsonProperty(buf, Pline, loc.linnum);
 		ClassDeclaration cd = isClassDeclaration();
 		if (cd)
 		{
 			if (cd.baseClass)
 			{
 				}
 				JsonRemoveComma(buf);
 				buf.writestring("],\n");
 			}
 		}
 		JsonString(buf, Pmembers);
 		buf.writestring(" : [\n");
 		size_t offset = buf.offset;
 		foreach (Dsymbol s; members)
 		{
 			}
 			s.toJsonBuffer(buf);
 		}
 		JsonRemoveComma(buf);
 		buf.writestring("]\n");
 		buf.writestring("}\n");
 	}
 override void toDocBuffer(OutBuffer buf)
 	{
 version (LOG) {
 		printf("\tnot friend\n");
 }
 		return false;
 	}
 	/**********************************
 	 * Determine if smember has access to private members of this declaration.
 	 */
 bool hasPrivateAccess(Dsymbol smember)	// does smember have private access to members of this class?
 	{
 				return true;		// so we get private access
 			}
 			// If both are members of the same module, grant access
 			while (true)
 			{
 				Dsymbol sp = smember.toParent();
 				if (sp.isFuncDeclaration() && smember.isFuncDeclaration())
 					smember = sp;
 				else
 					break;
 	version (LOG) {
 		printf("\tno\n");
 	}
 		return false;
 	}
 	/*******************************
 	 * Do access check for member of this class, this class being the
 	 * type of the 'this' pointer used to access smember.
 	 */
 void accessCheck(Loc loc, Scope sc, Dsymbol smember)
 		// BUG: should enable this check
 		//assert(smember.parent.isBaseOf(this, null));
 		if (smemberparent == this)
 		{
 			PROT access2 = smember.prot();
 			result = access2 >= PROT.PROTpublic ||
 				hasPrivateAccess(f) ||
 				isFriendOf(cdscope) ||

Mercurial > projects > ddmd

comparison dmd/AggregateDeclaration.d @ 176:fa9a71a9f5a8