projects/ddmd: dmd/ClassDeclaration.d comparison

comparison dmd/ClassDeclaration.d @ 176:fa9a71a9f5a8

Moved all the mutable globals to Global

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

comparison

equal deleted inserted replaced

-:94b6033c07f3
+:fa9a71a9f5a8
 	bool visit(FuncDeclaration fd2)
 	{
 		//printf("param = %p, fd = %p %s\n", param, fd, fd.toChars());
 		return fd is fd2;
 	}
 	FuncDeclaration fd;
 }
 class ClassDeclaration : AggregateDeclaration
 {
 int inuse;				// to prevent recursive attempts
 this(Loc loc, Identifier id, BaseClasses baseclasses)
 	{
 		super(loc, id);
 		vtbl = new Array();
 		vtblFinal = new Array();
 		enum msg = "only object.d can define this reserved class name";
 		if (baseclasses) {
 			this.baseclasses = baseclasses;
 		} else {
 			// BUG: What if this is the wrong TypeInfo, i.e. it is nested?
 			if (id.toChars()[0] == 'T')
 			{
 				if (id is Id.TypeInfo)
 				{
 					if (global.typeinfo) {
 						global.typeinfo.error("%s", msg);
 					}
 					global.typeinfo = this;
 				}
 				if (id is Id.TypeInfo_Class)
 				{
 					if (global.typeinfoclass)
 						global.typeinfoclass.error("%s", msg);
 					global.typeinfoclass = this;
 				}
 				if (id is Id.TypeInfo_Interface)
 				{
 					if (global.typeinfointerface)
 						global.typeinfointerface.error("%s", msg);
 					global.typeinfointerface = this;
 				}
 				if (id is Id.TypeInfo_Struct)
 				{
 					if (global.typeinfostruct)
 						global.typeinfostruct.error("%s", msg);
 					global.typeinfostruct = this;
 				}
 				if (id is Id.TypeInfo_Typedef)
 				{
 					if (global.typeinfotypedef)
 						global.typeinfotypedef.error("%s", msg);
 					global.typeinfotypedef = this;
 				}
 				if (id is Id.TypeInfo_Pointer)
 				{
 					if (global.typeinfopointer)
 						global.typeinfopointer.error("%s", msg);
 					global.typeinfopointer = this;
 				}
 				if (id is Id.TypeInfo_Array)
 				{
 					if (global.typeinfoarray)
 						global.typeinfoarray.error("%s", msg);
 					global.typeinfoarray = this;
 				}
 					//global.typeinfostaticarray.error("%s", msg);
 					global.typeinfostaticarray = this;
 				}
 				if (id is Id.TypeInfo_AssociativeArray)
 				{
 					if (global.typeinfoassociativearray)
 						global.typeinfoassociativearray.error("%s", msg);
 					global.typeinfoassociativearray = this;
 				}
 				if (id is Id.TypeInfo_Enum)
 				{
 					if (global.typeinfoenum)
 						global.typeinfoenum.error("%s", msg);
 					global.typeinfoenum = this;
 				}
 				if (id is Id.TypeInfo_Function)
 				{
 					if (global.typeinfofunction)
 						global.typeinfofunction.error("%s", msg);
 					global.typeinfofunction = this;
 				}
 				if (id is Id.TypeInfo_Delegate)
 				{
 					if (global.typeinfodelegate)
 						global.typeinfodelegate.error("%s", msg);
 					global.typeinfodelegate = this;
 				}
 				if (id is Id.TypeInfo_Tuple)
 				{
 					if (global.typeinfotypelist)
 						global.typeinfotypelist.error("%s", msg);
 					global.typeinfotypelist = this;
 				}
 	version (DMDV2) {
 				if (id is Id.TypeInfo_Const)
 				{
 					if (global.typeinfoconst)
 						global.typeinfoconst.error("%s", msg);
 					global.typeinfoconst = this;
 				}
 				if (id is Id.TypeInfo_Invariant)
 				{
 					if (global.typeinfoinvariant)
 						global.typeinfoinvariant.error("%s", msg);
 					global.typeinfoinvariant = this;
 				}
 				if (id is Id.TypeInfo_Shared)
 				{
 					if (global.typeinfoshared)
 						global.typeinfoshared.error("%s", msg);
 					global.typeinfoshared = this;
 				}
 	            }
 	}
 			}
 			if (id is Id.Object_)
 			{
 				if (global.object)
 					global.object.error("%s", msg);
 				global.object = this;
 			}
 //			if (id is Id.ClassInfo)
 			if (id is Id.TypeInfo_Class)
 			{
 				if (global.classinfo)
 					global.classinfo.error("%s", msg);
 				global.classinfo = this;
 			}
 			if (id is Id.ModuleInfo)
 			{
 				if (global.moduleinfo)
 					global.moduleinfo.error("%s", msg);
 				global.moduleinfo = this;
 			}
 		}
 		com = 0;
 		isauto = false;
 		isabstract = false;
 		inuse = 0;
 	}
 override Dsymbol syntaxCopy(Dsymbol s)
 	{
 		ClassDeclaration cd;
 		//printf("ClassDeclaration.syntaxCopy('%s')\n", toChars());
 		}
 		ScopeDsymbol.syntaxCopy(cd);
 		return cd;
 	}
 override void semantic(Scope sc)
 	{
 		uint offset;
 		//printf("ClassDeclaration.semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
 		//printf("sc.stc = %x\n", sc.stc);
 		//{ static int n;  if (++n == 20) *(char*)0=0; }
 		if (!ident)		// if anonymous class
 		{
 			string id = "__anonclass";
 			ident = Identifier.generateId(id);
 		}
 		if (!sc)
 		type = type.semantic(loc, sc);
 		handle = type;
 		if (!members)			// if forward reference
 		{
 			//printf("\tclass '%s' is forward referenced\n", toChars());
 			return;
 		}
 		if (symtab)
 		{	if (sizeok == 1 || !scope_)
 		if (sc.linkage == LINK.LINKcpp)
 		error("cannot create C++ classes");
 		// Expand any tuples in baseclasses[]
 		for (size_t i = 0; i < baseclasses.dim; )
 		{
 			auto b = baseclasses[i];
 		//printf("test1 %s %s\n", toChars(), b.type.toChars());
 			b.type = b.type.semantic(loc, sc);
 		//printf("test2\n");
 			Type tb = b.type.toBasetype();
 			if (tb.ty == TY.Ttuple)
 			{
 				TypeTuple tup = cast(TypeTuple)tb;
 				enum PROT protection = b.protection;
 				baseclasses.remove(i);
 				size_t dim = Parameter.dim(tup.arguments);
 				for (size_t j = 0; j < dim; j++)
 				{
 					auto arg = Parameter.getNth(tup.arguments, j);
 					b = new BaseClass(arg.type, protection);
 					baseclasses.insert(i + j, b);
 				}
 			}
 				i++;
 		}
 		// See if there's a base class as first in baseclasses[]
 		if (baseclasses.dim)
 		{
 			TypeClass tc;
 			BaseClass b;
 			Type tb;
 			b = baseclasses[0];
 			}
 			isnested = false;
 			}
 		}
 		else if (!(storage_class & STC.STCstatic))
 		{
 			Dsymbol s = toParent2();
 			if (s)
 			{
 				AggregateDeclaration ad = s.isClassDeclaration();
 				FuncDeclaration fd = s.isFuncDeclaration();
 				{   isnested = true;
 					Type t;
 					if (ad)
 						t = ad.handle;
 					else if (fd)
 					{
 						AggregateDeclaration ad2 = fd.isMember2();
 						if (ad2)
 							t = ad2.handle;
 						else
 						{
-							t = Type.tvoidptr;
+							t = global.tvoidptr;
 						}
 					}
 					else
 						assert(0);
 					if (t.ty == TY.Tstruct)	// ref to struct
-						t = Type.tvoidptr;
+						t = global.tvoidptr;
 					assert(!vthis);
 					vthis = new ThisDeclaration(loc, t);
 					members.push(vthis);
 				}
 			}
 	        {
 	            //printf("setScope %s %s\n", s->kind(), s->toChars());
 	            s.setScope(sc);
 	        }
 }
 		foreach (Dsymbol s; members) {
 			s.semantic(sc);
 		}
 		if (sizeok == 2)
 		//b.fillVtbl(this, &b.vtbl, 1);
 		}
 }
 		//printf("-ClassDeclaration.semantic(%s), type = %p\n", toChars(), type);
 	}
 override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
 	{
 		if (!isAnonymous())
 		{
 			buf.printf("%s ", kind());
 		}
 		else
 			buf.writeByte(';');
 		buf.writenl();
 	}
 	/*********************************************
 	 * Determine if 'this' is a base class of cd.
 	 * This is used to detect circular inheritance only.
 	 */
 int isBaseOf2(ClassDeclaration cd)
 	{
 		if (!cd)
 			return 0;
 		//printf("ClassDeclaration::isBaseOf2(this = '%s', cd = '%s')\n", toChars(), cd.toChars());
 		foreach (b; cd.baseclasses)
 		{
 			if (b.base is this || isBaseOf2(b.base))
 				return 1;
 		}
 		return 0;
 	}
 	{
 		if (!cd)
 			return 0;
 		//printf("ClassDeclaration::isBaseOf2(this = '%s', cd = '%s')\n", toChars(), cd.toChars());
 		foreach (b; cd.baseclasses)
 		{
 			if (b.base == this || isBaseOf2(b.base))
 				return 1;
 		}
 		return 0;
 				}
 			}
 		}
 		return s;
 	}
 version (DMDV2) {
 bool isFuncHidden(FuncDeclaration fd)
 	{
 		//printf("ClassDeclaration::isFuncHidden(class = %s, fd = %s)\n", toChars(), fd.toChars());
 		Dsymbol s = search(Loc(0), fd.ident, 4|2);
 		if (!s)
 		{
 			//printf("not found\n");
 			/* Because, due to a hack, if there are multiple definitions
 			 * of fd.ident, null is returned.
 			 */
 			return false;
 		}
 		FuncDeclarationFinder p; p.fd = fd;
 		s = s.toAlias();
 		OverloadSet os = s.isOverloadSet();
 		if (os)
 		{
 			foreach (s2; os.a)
 			{
 				auto f2 = s2.isFuncDeclaration();
 				if (f2 && overloadApply(f2, p))
 					return false;
 			}
 			return true;
 }
 bool isCOMclass()
 	{
 		return com;
 	}
 bool isCOMinterface()
 	{
 		return false;
 	}
 			}
 		}
 		return false;
 	}
 int vtblOffset()
 	{
 		assert(false);
 	}
 override string kind()
 	{
 		return "class";
 	}
 override string mangle()
 	{
 		Dsymbol parentsave = parent;
 		//printf("ClassDeclaration.mangle() %s.%s\n", parent.toChars(), toChars());
 		/* These are reserved to the compiler, so keep simple
 		 * names for them.
 		 */
 		if (ident is Id.Exception)
 		{
 			if (parent.ident is Id.object)
 				parent = null;
 		}
 		else if (ident is Id.TypeInfo   ||
 		//	ident is Id.Exception ||
 		string id = Dsymbol.mangle();
 		parent = parentsave;
 		return id;
 	}
 override void toDocBuffer(OutBuffer buf)
 	{
 		assert(false);
 	}
 			{
 				access_ret = smember.prot();
 			}
 			foreach (b; baseclasses)
 			{
 				access = b.base.getAccess(smember);
 				switch (access)
 				{
 					case PROT.PROTnone:
 						break;
 		if (!members)
 			return;
 		if (multiobj)
 		{
 			obj_append(this);
 			return;
 		}
 		if (global.params.symdebug)
 static if (false) {
 		// Build destructor by aggregating dtors[]
 		Symbol* sdtor;
 		switch (dtors.dim)
 		{
 			case 0:
 				// No destructors for this class
 				sdtor = null;
 				break;
 				// One destructor, just use it directly
 				sdtor = (cast(DtorDeclaration)dtors.data[0]).toSymbol();
 				break;
 			default:
 			{
 				/* Build a destructor that calls all the
 				 * other destructors in dtors[].
 				 */
 				elem* edtor = null;
 				sthis.Sfl = FLauto;
 				// Call each of the destructors in dtors[]
 				// in reverse order
 				for (size_t i = 0; i < dtors.dim; i++)
 				{
 					DtorDeclaration d = cast(DtorDeclaration)dtors.data[i];
 					Symbol* s = d.toSymbol();
 					elem* e = el_bin(OPcall, TYvoid, el_var(s), el_var(sthis));
 					edtor = el_combine(e, edtor);
 				}
 		offset = CLASSINFO_SIZE;			// must be ClassInfo.size
 		if (global.classinfo)
 		{
 			if (global.classinfo.structsize != CLASSINFO_SIZE)
 				error("D compiler and phobos' object.d are mismatched");
 			dtxoff(&dt, global.classinfo.toVtblSymbol(), 0, TYnptr); // vtbl for ClassInfo
 		}
 		else
 		{
 			dtdword(&dt, 0);		// BUG: should be an assert()
 		// name[]
 		string name = ident.toChars();
 		size_t namelen = name.length;
 		if (!(namelen > 9 && name[0..9] == "TypeInfo_"))
 		{
 			name = toPrettyChars();
 			namelen = name.length;
 		}
 		dtdword(&dt, namelen);
 		dtabytes(&dt, TYnptr, 0, namelen + 1, toStringz(name));
 		// Put out vtblInterfaces.data[]. Must immediately follow csym, because
 		// of the fixup (*)
 		offset += vtblInterfaces.dim * (4 * PTRSIZE);
 		foreach (b; vtblInterfaces)
 		{
 			ClassDeclaration id = b.base;
 			/* The layout is:
 	         *  struct Interface
 *  {
 		// Put out the vtblInterfaces.data[].vtbl[]
 		// This must be mirrored with ClassDeclaration.baseVtblOffset()
 		//printf("putting out %d interface vtbl[]s for '%s'\n", vtblInterfaces.dim, toChars());
 		foreach (size_t i, BaseClass b; vtblInterfaces)
 		{
 			ClassDeclaration id = b.base;
 			int j;
 			//printf("    interface[%d] is '%s'\n", i, id.toChars());
 			j = 0;
 				// First entry is struct Interface reference
 				dtxoff(&dt, csym, CLASSINFO_SIZE + i * (4 * PTRSIZE), TYnptr);
 				j = 1;
 			}
 			assert(id.vtbl.dim == b.vtbl.dim);
 			for (; j < id.vtbl.dim; j++)
 			{
 				assert(j < b.vtbl.dim);
 		static if (false) {
 		scope Array bvtbl = new Array();
 		for (cd = this.baseClass; cd; cd = cd.baseClass)
 		{
 			foreach (size_t k, BaseClass bs; cd.vtblInterfaces)
 			{
 				if (bs.fillVtbl(this, bvtbl, 0))
 				{
 					//printf("\toverriding vtbl[] for %s\n", bs.base.toChars());
 					ClassDeclaration id = bs.base;
 					int j;
 					}
 				}
 			}
 		}
 	}
 	version (INTERFACE_VIRTUAL) {
 		// Put out the overriding interface vtbl[]s.
 		// This must be mirrored with ClassDeclaration.baseVtblOffset()
 		//printf("putting out overriding interface vtbl[]s for '%s' at offset x%x\n", toChars(), offset);
 		for (size_t i = 0; i < vtblInterfaces.dim; i++)
 		{
 			BaseClass b = cast(BaseClass)vtblInterfaces.data[i];
 			ClassDeclaration cd;
 			for (cd = this.baseClass; cd; cd = cd.baseClass)
 			{
 				for (int k = 0; k < cd.vtblInterfaces.dim; k++)
 				{
 					BaseClass bs = cast(BaseClass)cd.vtblInterfaces.data[k];
 					if (b.base == bs.base)
 					{
 						//printf("\toverriding vtbl[] for %s\n", b.base.toChars());
 		dt = null;
 		size_t i;
 		if (0)
 			i = 0;
 		else
 		{
 			dtxoff(&dt, csym, 0, TYnptr);		// first entry is ClassInfo reference
 			i = 1;
 		}
 		for (; i < vtbl.dim; i++)
 		{
 			FuncDeclaration fd = (cast(Dsymbol)vtbl.data[i]).isFuncDeclaration();
 			//printf("\tvtbl[%d] = %p\n", i, fd);
 			if (fd && (fd.fbody || !isAbstract()))
 			{
 				Symbol* s = fd.toSymbol();
 		version (DMDV2) {
 				if (isFuncHidden(fd))
 				{
 					/* fd is hidden from the view of this class.
 					 * If fd overlaps with any function in the vtbl[], then
 					 * issue 'hidden' error.
 					 */
 					for (int j = 1; j < vtbl.dim; j++)
 					{
 						if (j == i)
 							continue;
 						FuncDeclaration fd2 = (cast(Dsymbol)vtbl.data[j]).isFuncDeclaration();
 						if (!fd2.ident.equals(fd.ident))
 							continue;
 	}
 		outdata(vtblsym);
 		if (isExport())
 			obj_export(vtblsym,0);
 	}
 void toDebug()
 	{
 		assert(false);
 	}
 	/******************************************
 	 * Get offset of base class's vtbl[] initializer from start of csym.
 	 * Returns ~0 if not this csym.
 	 */
 uint baseVtblOffset(BaseClass bc)
 		Array bvtbl;
 		for (cd = this.baseClass; cd; cd = cd.baseClass)
 		{
 			foreach(bs; cd.vtblInterfaces)
 			{
 				if (bs.fillVtbl(this, null, 0))
 				{
 					if (bc == bs)
 					{
 						//printf("\tcsymoffset = x%x\n", csymoffset);
 						return csymoffset;
 					}
 					csymoffset += bs.base.vtbl.dim * PTRSIZE;
 				}
 			}
 		}
 	}
 	version (INTERFACE_VIRTUAL) {
 		for (size_t i = 0; i < vtblInterfaces.dim; i++)
 		{
 			BaseClass b = cast(BaseClass)vtblInterfaces.data[i];
 			ClassDeclaration cd;
 			for (cd = this.baseClass; cd; cd = cd.baseClass)
 			{
 				//printf("\tbase class %s\n", cd.toChars());
 				for (int k = 0; k < cd.vtblInterfaces.dim; k++)
 				{
 					BaseClass bs = cast(BaseClass)cd.vtblInterfaces.data[k];
 					if (bc == bs)
 					{
 						//printf("\tcsymoffset = x%x\n", csymoffset);
 						return csymoffset;
 					}
 					if (b.base == bs.base)
 						csymoffset += bs.base.vtbl.dim * PTRSIZE;
 		}
 	}
 		return ~0;
 	}
-	static private __gshared Classsym* scc;
 	/*************************************
 	 * Create the "ClassInfo" symbol
 	 */
 override Symbol* toSymbol()
 	{
 		if (!csym)
 		{
 			Symbol* s;
-			if (!scc)
+			s = toSymbolX("__Class", SC.SCextern, global.scc.Stype, "Z");
-				scc = fake_classsym(Id.ClassInfo);
-			s = toSymbolX("__Class", SC.SCextern, scc.Stype, "Z");
 			s.Sfl = FL.FLextern;
 			s.Sflags |= SFL.SFLnodebug;
 			csym = s;
 			slist_add(s);
 		}
 			vtblsym = s;
 			slist_add(s);
 		}
 		return vtblsym;
 	}
 	// Generate the data for the static initializer.
 void toDt(dt_t **pdt)
 	{
 		//printf("ClassDeclaration.toDt(this = '%s')\n", toChars());
 		// Put in the rest
 		toDt2(pdt, this);
 		//printf("-ClassDeclaration.toDt(this = '%s')\n", toChars());
 	}
 void toDt2(dt_t** pdt, ClassDeclaration cd)
 	{
 		uint offset;
 		dt_t* dt;
 			//printf("\t\tv = '%s' v.offset = %2d, offset = %2d\n", v.toChars(), v.offset, offset);
 			dt = null;
 			init = v.init;
 			if (init)
 			{
 				//printf("\t\t%s has initializer %s\n", v.toChars(), init.toChars());
 				ExpInitializer ei = init.isExpInitializer();
 				Type tb = v.type.toBasetype();
 				if (ei && tb.ty == Tsarray)
 					(cast(TypeSArray)tb).toDtElem(&dt, ei.exp);
 		// Interface vptr initializations
 		toSymbol();						// define csym
 		foreach (b; vtblInterfaces)
 		{
 ///		version (1 || INTERFACE_VIRTUAL) {
 			for (ClassDeclaration cd2 = cd; 1; cd2 = cd2.baseClass)
 			{
 				assert(cd2);
 				csymoffset = cd2.baseVtblOffset(b);

Mercurial > projects > ddmd

comparison dmd/ClassDeclaration.d @ 176:fa9a71a9f5a8