自学教程：C++ EmAssert函数代码示例

void EmFileRef::SetEmulatorRef	(const EmFileRef& ref){	EmAssert (ref.IsSpecified ());	EmAssert (!gEmulatorRef.IsSpecified ());	gEmulatorRef = ref;}

void EmHAL::AddHandler (EmHALHandler* handler){	EmAssert (handler->fNextHandler == NULL);	EmAssert (handler->fPrevHandler == NULL);	EmAssert (fgRootHandler == NULL || fgRootHandler->fPrevHandler == NULL);	if (fgRootHandler != NULL)	{		fgRootHandler->fPrevHandler = handler;		handler->fNextHandler = fgRootHandler;	}	fgRootHandler = handler;}

EmDocument* EmDocument::DoNewBound (void){	EmAssert (gApplication->IsBoundPartially ());	// Create the new document.	EmDocument*	doc = EmDocument::HostCreateDocument ();	try	{		// Create the new session.		doc->fSession = new EmSession;		doc->fSession->CreateBound ();		doc->fSession->CreateThread (false);	// !!! Created here, but destroyed in EmSession::~EmSession!	}	catch (...)	{		delete doc;		throw;	}	// If we got here, then everything worked.  Open a window on the session.	doc->PrvOpenWindow ();	return doc;}

EmApplicationFltk::EmApplicationFltk (void) :	EmApplication (),	fAppWindow (NULL){	EmAssert (gHostApplication == NULL);	gHostApplication = this;}

void StateBehavior::StdOnSignal() {    EmAssert(this->getParent() != NULL, "Parent NULL");    if (p_CurrentStateItem == NULL && m_vStateItem.size() == 0) return;    // initialize origo, this is a ugle hack    if (m_iTick == 0) {        this->getParent()->getTranslation(m_vtxTr.x, m_vtxTr.y, m_vtxTr.z);        this->getParent()->getRotation(m_vtxRot.x, m_vtxRot.y, m_vtxRot.z);    }#if EM_DEBUG    if (Loader::getInstance()->getSignal(GetSignal()) != NULL) {        EM_COUT("Got signal " << Loader::getInstance()->getSignal(GetSignal()), 0);    }#endif    OnSignal( PBL_SIG_RESET_ALL) {        this->setState(m_vStateItem[0]);        // do a fast move        if (m_bMove) {            this->getParent()->setTransform(m_vtxTr.x + p_CurrentStateItem->m_vtxTr.x,                                            m_vtxTr.y + p_CurrentStateItem->m_vtxTr.y,                                            m_vtxTr.z + p_CurrentStateItem->m_vtxTr.z,                                            m_vtxRot.x + p_CurrentStateItem->m_vtxRot.x,                                            m_vtxRot.y + p_CurrentStateItem->m_vtxRot.y,                                            m_vtxRot.z + p_CurrentStateItem->m_vtxRot.z);        }    }    else {

EmApplicationFltk::~EmApplicationFltk (void){	delete fAppWindow;	EmAssert (gHostApplication == this);	gHostApplication = NULL;}

void EmHAL::EnsureCoverage (void){#if 0	// Rats...can't get this work...	Bool			isHandled[20];	EmHALHandler*	thisHandler = fgRootHandler;	EmHALHandler	baseHandler;	while (thisHandler)	{		typedef void (EmHALHandler::*CycleHandler)(Bool);		CycleHandler	p1 = (thisHandler->Cycle);		CycleHandler	p2 = (baseHandler.Cycle);		if (p1 != p2)		{			isHandled[0] = true;		}		thisHandler = thisHandler->fNextHandler;	}	for (int ii = 0; ii < sizeof (isHandled); ++ii)	{		EmAssert (isHandled[ii]);	}#endif}

Bool PrvHandleTrap12 (ExceptionNumber){	EmAssert (gSession);	gSession->ScheduleSuspendSubroutineReturn ();	return true;}

EmDocument::EmDocument (void) :	EmActionHandler (),	fSession (NULL),	fFile (){	EmAssert (gDocument == NULL);	gDocument = this;}

ATrap::~ATrap (void){	// Put things back the way they were.	EmPalmOS::ForgetStack (EmBankMapped::GetEmulatedAddress (this->GetStackBase ()));	EmAssert (gCPU68K);	gCPU68K->SetRegisters (fOldRegisters);	// Check to see if anything interesting was registered while we	// were making the Palm OS subroutine call.  The "check after end	// of cycle" bit may have gotten cleared when restoring the old	// registers, so set it on the off chance that it was.  Doing this	// is harmless if there really aren't any scheduled tasks.	EmAssert (gSession);	gCPU68K->CheckAfterCycle ();}

void StdAnimation::onTick() {    EmAssert(this->getParent() != NULL, "Parent not allowed to be null");    float x, y, z;    float sX, sY, sZ;    float eX, eY, eZ;    float k=0.0;    int index;    int size = m_vVertex.size();    if (m_iTick >= size*m_iStep) {        m_iTick = 0;    }    index = (int)(m_iTick/m_iStep);    sX = m_vVertex[index].x;    sY = m_vVertex[index].y;    sZ = m_vVertex[index].z;    if (index + 1 < size) {        eX = m_vVertex[index+1].x;        eY = m_vVertex[index+1].y;        eZ = m_vVertex[index+1].z;    } else {        eX = m_vtxEnd.x;        eY = m_vtxEnd.y;        eZ = m_vtxEnd.z;    }    k = ((float)(m_iTick%m_iStep)/m_iStep);    x = (float)(sX + (eX - sX)*k);    y = (float)(sY + (eY - sY)*k);    z = (float)(sZ + (eZ - sZ)*k);    m_iTick++;    if (m_iAnimType & EM_TRANSLATION) {        this->getParent()->setTranslation(x, y, z);    }	else if (m_iAnimType & EM_ROTATION) {        this->getParent()->setRotation(x, y, z);    }	else if (m_iAnimType & EM_LIGHT) {        Light* l = this->getParent()->getLight();        if (l != NULL) {            l->setColor(x, y, z);        }    } else if (m_iAnimType & EM_BILLBOARD_SIZE) {        BillBoard * b = this->getParent()->getBillBoard();        if (b != NULL) {            b->setSize(x, y);            b->setZOffset(z);        }    }}

void Memory::Save (SessionFile& f){	EmBankDummy::Save (f);	EmBankRegs::Save (f);	EmBankSRAM::Save (f);	EmBankDRAM::Save (f);	EmBankROM::Save (f);	EmBankMapped::Save (f);	EmAssert (gSession);	if (gSession->GetDevice ().HasFlash ())		EmBankFlash::Save (f);	MetaMemory::Save (f);}

ATrap::ATrap (void) :#if (__GNUC__ < 2)/* Can't call the default constructor because there isn't one defined *//* on a struct as there is with a class under GCC 2.8.1 */	fNewRegisters (),#endif	fEmulatedStackMapper (this->GetStackBase (), kStackSize){	// Get the registers.	EmAssert (gCPU68K);	gCPU68K->GetRegisters (fOldRegisters);	fNewRegisters = fOldRegisters;	// Make sure the CPU is not stopped.  I suppose that we could force the CPU	// to no longer be stopped, but I'd rather that the Palm OS itself woke up	// first before we try making calls into it.  Therefore, anything making	// an out-of-the-blue Palm OS call via this class (that is, a call outside	// of the context of a Palm OS function head- or tailpatch) should first	// bring the CPU to a halt by calling EmSession::ExecuteUntilSysCall first.	EmAssert (fNewRegisters.stopped == 0);	// Give ourselves our own private stack.  We'll want this in case	// we're in the debugger and the stack pointer is hosed.	m68k_areg (fNewRegisters, 7) = EmBankMapped::GetEmulatedAddress (										this->GetStackBase () + kStackSize - 4);	// Remember this as a stack so that our stack sniffer won't complain.	char*	stackBase = this->GetStackBase ();	StackRange	range (	EmBankMapped::GetEmulatedAddress (&stackBase[0]), 						EmBankMapped::GetEmulatedAddress (&stackBase[kStackSize - 4]));	EmPalmOS::RememberStackRange (range);}

void CollisionBounds::addIntersect(Polygon3D* p) {	EmAssert(p != NULL, "CollisionBounds::add polygon NULL");	EM_COUT("CollisionBounds::add" << endl, 0);	// add polygons only to leafs	if (m_vCollisionBounds.size() > 0) {		vector<CollisionBounds*>::iterator iter = m_vCollisionBounds.begin();		vector<CollisionBounds*>::iterator end = m_vCollisionBounds.end();		for (; iter != end; ++iter) {			(*iter)->addIntersect(p);		}	} else {		// add intersection polygon to bounds		if (this->intersect(p)) {			m_vPolygon.push_back(p);		}	}}

void Memory::Initialize (	EmStream&		hROM,							RAMSizeType		ramSize){	// Clear everything out.		memset (gEmMemBanks, 0, sizeof (gEmMemBanks));	// Initialize the valid memory banks.	EmBankDummy::Initialize ();	// Initialize the Hardware registers memory bank.  Do this	// *before* initializing the other RAM banks so that we	// know how memory is laid out from the chip selects.	EmBankRegs::Initialize ();	// Initialize EmBankDRAM after initializing the EmBankSRAM. The order is	// important for DragonballEZ. On Dragonball devices, DRAM is	// at 0x00000000, and SRAM is at 0x10000000. But on EZ devices,	// both start at 0x00000000. By calling EmBankDRAM::Initialize	// second, we allow it to overwrite the EmAddressBank handlers	// for the part of memory where they overlap.	EmBankSRAM::Initialize (ramSize);	EmBankDRAM::Initialize ();	EmBankROM::Initialize (hROM);	EmBankMapped::Initialize ();	EmAssert (gSession);	if (gSession->GetDevice ().HasFlash ())		EmBankFlash::Initialize ();	MetaMemory::Initialize ();//	Memory::ResetBankHandlers ();	// Can't do this yet.  We can't set the									// bank handlers until we know how memory									// is laid out, and that information isn't									// determined until reset.}