747 TBool TEntryPointList::AlreadyCalled(TLinAddr aEP)

   748 	{

   749 	TInt i;

   750 

   751 	// if we find it in the list before the current one

   752 	// then it was already called, return true

   753 	for (i=0; i<iCurrentEP; ++i)

   754 		if (iEPs[i] == aEP)

   755 			return ETrue;

   756 

   757 	// if it *is* the current one (i==iCurrentEP here)

   758 	// then we're in some kind of hideous cycle. There is no

   759 	// way to resolve this that isn't wrong, but some people

   760 	// may depend on it anyway. The safest thing to do is to

   761 	// just claim the EP is already called and hope that

   762 	// the constructors aren't actually dependent on each other.

   763 	if (iEPs[i] == aEP)

   764 		return ETrue;

   765 		

   766 	// if we find it *after* the current one then it's not

   767 	// already been called, but we need to call it now

   768 	// rather than when we get that far back up the stack,

   769 	// so set that copy to -1.

   770 	for (++i; i<iNumEPs; ++i)

   771 		if (iEPs[i] == aEP)

   772 			iEPs[i] = 0xFFFFFFFFU;

   773 

   774 	// if this is not the top of the stack recurse, otherwise

   775 	// return false so the current load will call it

   776 	if (iPrevList)

   777 		return iPrevList->AlreadyCalled(aEP);

   778 	else

   779 		return EFalse;

   780 	}

   781 

   782 

   783 TInt TEntryPointList::CallEPs()

   784 	{

   785 	// The TLS entry for KNestedEntryPointCallKey is the head

   786 	// of a linked list of TEntryPointList objects. Add this one

   787 	// to the front of the list. iPrevList will end up NULL if

   788 	// there is no nested load yet.

   789 	// Only one thread per process can be doing a load at a time

   790 	// because of the DLL lock, so using TLS for this is fine.

   791 	iPrevList=(TEntryPointList*)UserSvr::DllTls(KNestedEntryPointCallKey, KDllUid_Special);

   792 	TInt r=UserSvr::DllSetTls(KNestedEntryPointCallKey, KDllUid_Special, this);

   793 	if (r != KErrNone)

   794 		return r;

   795 

   796 	// call each entry point unless it's already been called higher

   797 	// in the nested loading process, or it's been set to -1 because

   798 	// it was called lower in the nested load.

   799 	for (iCurrentEP=0; iCurrentEP<iNumEPs; ++iCurrentEP)

   800 		{

   801 		TLinAddr ep=iEPs[iCurrentEP];

   802 		if (ep != 0xFFFFFFFFU && (!iPrevList || !iPrevList->AlreadyCalled(ep)))

   803 			{

   804 			TLibraryEntry f=(TLibraryEntry)ep;

   805 			r = (*f)(KModuleEntryReasonProcessAttach);

   806 			if (r != KErrNone)

   807 				break;

   808 			}

   809 		}

   810 

   811 	// Take this object off the list before returning

   812 	UserSvr::DllSetTls(KNestedEntryPointCallKey, KDllUid_Special, iPrevList);

   813 

   814 	return r;

   815 	}

   816 

   817 

   818 

   819 

   827 	eplist.iNumEPs -= 1; // last EP is always process entry point

   851 	E32Loader::StaticCallsDone();