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

void DeleteMission(CampaignOptions *co){	CASSERT(		co->MissionIndex < (int)co->Setting.Missions.size,		"invalid mission index");	MissionTerminate(CampaignGetCurrentMission(co));	CArrayDelete(&co->Setting.Missions, co->MissionIndex);	if (co->MissionIndex >= (int)co->Setting.Missions.size)	{		co->MissionIndex = MAX(0, (int)co->Setting.Missions.size - 1);	}}

static CStatusCBitmapSurface_Composite(CSurface          *_this,                         CUInt32            x,                         CUInt32            y,                         CUInt32            width,                         CUInt32            height,                         pixman_image_t    *src,                         pixman_image_t    *mask,                         pixman_operator_t  op){	/* declarations */	CBitmap *image;	/* assertions */	CASSERT((_this != 0));	CASSERT((src   != 0));	CASSERT((mask  != 0));	/* get the image */	image = ((CBitmapSurface *)_this)->image;	/* perform the composite synchronously */	CMutex_Lock(image->lock);	{		/* ensure the image data isn't locked */		if(image->locked)		{			CMutex_Unlock(image->lock);			return CStatus_InvalidOperation_ImageLocked;		}		/* perform the composite */		pixman_composite			(op, src, mask, image->image, 0, 0, 0, 0, x, y, width, height);	}	CMutex_Unlock(image->lock);	/* return successfully */	return CStatus_OK;}

void NetInputPoll(NetInput *n){	if (n->channel.sock == NULL)	{		return;	}	switch (n->channel.state)	{	case CHANNEL_STATE_CLOSED:		CASSERT(false, "Unexpected channel state closed");		return;	case CHANNEL_STATE_DISCONNECTED:		if (!TryRecvSynAndSendSynAck(n))		{			return;		}		n->channel.state = CHANNEL_STATE_WAIT_HANDSHAKE;		// fallthrough	case CHANNEL_STATE_WAIT_HANDSHAKE:		// listen for ACK		if (!NetInputRecvNonBlocking(&n->channel, TryParseAck, &n->channel))		{			return;		}		n->channel.state = CHANNEL_STATE_CONNECTED;		// fallthrough	case CHANNEL_STATE_CONNECTED:		RecvCmd(n);		break;	default:		CASSERT(false, "Unknown channel state");		break;	}}

/*/|*| Ensure the capacity of point and type lists of this path.|*||*|   _this - this path|*|   count - the total minimum capacity required|*||*|  Returns status code./*/static CStatusCPath_EnsureCapacity(CPath   *_this,                     CUInt32  minimum){	/* assertions */	CASSERT((_this != 0));	/* ensure capacity */	_EnsurePathCapacity(_this, minimum);	/* return successfully */	return CStatus_OK;}

void LogModuleSetLevel(const LogModule m, const LogLevel l){	switch (m)	{	case LM_MAIN: llMain = l; break;	case LM_NET: llNet = l; break;	case LM_INPUT: llInput = l; break;	case LM_ACTOR: llActor = l; break;	default:		CASSERT(false, "Unknown log module");		break;	}}

WPRIVATE void * WKV_destructor (void * _self){  struct WKV  * const self = _self;  /* preconditions */  CASSERT (self);  if (VALUE)    destroy (VALUE), VALUE = NIL;  return (self);}

/* Handle a change signal. */CINTERNAL voidCBrush_OnChange(CBrush *_this){	/* assertions */	CASSERT((_this != 0));	/* destroy the current pattern, as needed */	if(_this->pattern.image != 0)	{		pixman_image_destroy(_this->pattern.image);		_this->pattern.image = 0;	}}

/* cook up a Binary key */void SymmetricKeyInfoProvider::CssmKeyToBinary(	CssmKey				*paramKey,	// ignored	CSSM_KEYATTR_FLAGS	&attrFlags,	// IN/OUT	BinaryKey 			**binKey){	CASSERT(mKey.keyClass() == CSSM_KEYCLASS_SESSION_KEY);	SymmetricBinaryKey *symBinKey = new SymmetricBinaryKey(		mKey.KeyHeader.LogicalKeySizeInBits);	copyCssmData(mKey, 		symBinKey->mKeyData, 		symBinKey->mAllocator);	*binKey = symBinKey;}

/* Fill this path to trapezoids. */CINTERNAL CStatusCPath_Fill(CPath       *_this,           CTrapezoids *trapezoids){	/* declarations */	CFillMode fillMode;	/* assertions */	CASSERT((_this      != 0));	CASSERT((trapezoids != 0));	/* get the fill mode */	fillMode = (_this->winding ? CFillMode_Winding : CFillMode_Alternate);	/* fill the path */	CStatus_Check		(CTrapezoids_Fill			(trapezoids, _this->points, _this->types, _this->count, fillMode));	/* return successfully */	return CStatus_OK;}

/* Get a pattern for this brush. */CINTERNAL CStatusCBrush_GetPattern(CBrush   *_this,                  CPattern *pattern){	/* assertions */	CASSERT((_this   != 0));	CASSERT((pattern != 0));	/* create a pattern, as needed */	if(_this->pattern.image == 0)	{		CStatus_Check			(_this->_class->CreatePattern				(_this, &(_this->pattern)));	}	/* get the pattern */	*pattern = _this->pattern;	/* return successfully */	return CStatus_OK;}

LogLevel LogModuleGetLevel(const LogModule m){	switch (m)	{	case LM_MAIN: return llMain;	case LM_NET: return llNet;	case LM_INPUT: return llInput;	case LM_ACTOR: return llActor;	default:		CASSERT(false, "Unknown log module");		return LL_ERROR;	}}

void wordAppend(char *str, word_ptr w_grp){    word_ptr wptr, wtmp;    CASSERT(str != NULL && w_grp != NULL, "wordAppend: NULL argument(s)/n");    wptr = w_grp->next_anagram;  /* the first actual word in this group */    CASSERT(wptr != NULL, "no word in a group!/n");    wtmp = newnode();    wtmp->str = strdup(str);    CASSERT(wtmp->str, "Out of memory!/n");    wtmp->next = NULL;    wtmp->prev_anagram = NULL;    wtmp->next_anagram = wptr;    wptr->prev_anagram = wtmp;    w_grp->next_anagram = wtmp;}

static void DeathmatchFinalScoresDraw(void *data){	UNUSED(data);	// This will only draw once	const int w = gGraphicsDevice.cachedConfig.Res.x;	const int h = gGraphicsDevice.cachedConfig.Res.y;	GraphicsBlitBkg(&gGraphicsDevice);	// Work out the highest kills	int maxKills = 0;	for (int i = 0; i < (int)gPlayerDatas.size; i++)	{		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		if (p->kills > maxKills)		{			maxKills = p->kills;		}	}	// Draw players and their names spread evenly around the screen.	CASSERT(		gPlayerDatas.size >= 2 && gPlayerDatas.size <= 4,		"Unimplemented number of players for deathmatch");#define LAST_MAN_TEXT	"Last man standing!"	for (int i = 0; i < (int)gPlayerDatas.size; i++)	{		const Vec2i pos = Vec2iNew(			w / 4 + (i & 1) * w / 2,			gPlayerDatas.size == 2 ? h / 2 : h / 4 + (i / 2) * h / 2);		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		DisplayCharacterAndName(pos, &p->Char, p->name);				// Kills		char s[16];		sprintf(s, "Kills: %d", p->kills);		FontStrMask(			s, Vec2iNew(pos.x - FontStrW(s) / 2, pos.y + 20),			p->kills == maxKills ? colorGreen : colorWhite);		// Last man standing?		if (p->Lives > 0)		{			FontStrMask(				LAST_MAN_TEXT,				Vec2iNew(pos.x - FontStrW(LAST_MAN_TEXT) / 2, pos.y + 30),				colorGreen);		}	}}

voidAsyncLoop::executeSocketAction( SocketHandle socket, SocketActionMask actionMask )  // nofail{    CASSERT( SA_POLL_IN == CURL_CSELECT_IN );    CASSERT( SA_POLL_OUT == CURL_CSELECT_OUT );    CASSERT( SA_POLL_ERR == CURL_CSELECT_ERR );    CASSERT( sizeof( curl_socket_t ) == sizeof( SocketHandle ) );    try    {        int stillRunning = 0;        CURLMcode multiCurlCode =            curl_multi_socket_action( m_multiCurl, ( curl_socket_t ) socket, actionMask, &stillRunning );        raiseIfError( multiCurlCode );    }    catch( ... )    {        // We cannot fail this method, handle the error and continue.        handleBackgroundError();    }}

/* Clone this hatch brush. */static CStatusCHatchBrush_Clone(CBrush  *_this,                  CBrush **_clone){	/* declarations */	CHatchBrush  *brush;	CHatchBrush **clone;	/* assertions */	CASSERT((_this  != 0));	CASSERT((_clone != 0));	/* get this as a hatch brush */	brush = (CHatchBrush *)_this;	/* get the clone as a hatch brush */	clone = (CHatchBrush **)_clone;	/* create the clone */	return		CHatchBrush_Create			(clone, brush->style, brush->foreground, brush->background);}

GunDescription *IdGunDescription(const int i){	CASSERT(		i >= 0 &&		i < (int)gGunDescriptions.Guns.size +		(int)gGunDescriptions.CustomGuns.size,		"Gun index out of bounds");	if (i < (int)gGunDescriptions.Guns.size)	{		return CArrayGet(&gGunDescriptions.Guns, i);	}	return CArrayGet(		&gGunDescriptions.CustomGuns, i - gGunDescriptions.Guns.size);}

static void PlayerSelectionDraw(void *data){	const PlayerSelectionData *pData = data;	GraphicsBlitBkg(&gGraphicsDevice);	const int w = gGraphicsDevice.cachedConfig.Res.x;	const int h = gGraphicsDevice.cachedConfig.Res.y;	int idx = 0;	for (int i = 0; i < (int)gPlayerDatas.size; i++, idx++)	{		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		if (!p->IsLocal)		{			idx--;			continue;		}		if (p->inputDevice != INPUT_DEVICE_UNSET)		{			MenuDisplay(&pData->menus[idx].ms);		}		else		{			Vec2i center = Vec2iZero();			const char *prompt = "Press Fire to join...";			const Vec2i offset = Vec2iScaleDiv(FontStrSize(prompt), -2);			switch (GetNumPlayers(false, false, true))			{			case 1:				// Center of screen				center = Vec2iNew(w / 2, h / 2);				break;			case 2:				// Side by side				center = Vec2iNew(idx * w / 2 + w / 4, h / 2);				break;			case 3:			case 4:				// Four corners				center = Vec2iNew(					(idx & 1) * w / 2 + w / 4, (idx / 2) * h / 2 + h / 4);				break;			default:				CASSERT(false, "not implemented");				break;			}			FontStr(prompt, Vec2iAdd(center, offset));		}	}}

bool MissionTrySetTile(Mission *m, Vec2i pos, unsigned short tile){	if (pos.x < 0 || pos.x >= m->Size.x || pos.y < 0 || pos.y >= m->Size.y)	{		return false;	}	CASSERT(m->Type == MAPTYPE_STATIC, "cannot set tile for map type");	switch (tile)	{	case MAP_WALL:		// Check that there are no incompatible doors		if (HasDoorOrientedAt(m, Vec2iNew(pos.x - 1, pos.y), 0) ||			HasDoorOrientedAt(m, Vec2iNew(pos.x + 1, pos.y), 0) ||			HasDoorOrientedAt(m, Vec2iNew(pos.x, pos.y - 1), 1) ||			HasDoorOrientedAt(m, Vec2iNew(pos.x, pos.y + 1), 1))		{			// Can't place this wall			return false;		}		break;	case MAP_DOOR:		{			// Check that there is a clear passage through this door			int isHClear =				IsClear(GetTileAt(m, Vec2iNew(pos.x - 1, pos.y))) &&				IsClear(GetTileAt(m, Vec2iNew(pos.x + 1, pos.y)));			int isVClear =				IsClear(GetTileAt(m, Vec2iNew(pos.x, pos.y - 1))) &&				IsClear(GetTileAt(m, Vec2iNew(pos.x, pos.y + 1)));			if (!isHClear && !isVClear)			{				return false;			}			// Check that there are no incompatible doors			if (HasDoorOrientedAt(m, Vec2iNew(pos.x - 1, pos.y), 0) ||				HasDoorOrientedAt(m, Vec2iNew(pos.x + 1, pos.y), 0) ||				HasDoorOrientedAt(m, Vec2iNew(pos.x, pos.y - 1), 1) ||				HasDoorOrientedAt(m, Vec2iNew(pos.x, pos.y + 1), 1))			{				// Can't place this door				return false;			}		}		break;	}	const int idx = pos.y * m->Size.x + pos.x;	*(unsigned short *)CArrayGet(&m->u.Static.Tiles, idx) = tile;	return true;}

void NetInputSendMsg(    NetInput *n, const int peerIndex, ServerMsg msg, const void *data){    if (!n->server)    {        return;    }    CASSERT(        peerIndex >= 0 && peerIndex < (int)n->peers.size,        "invalid peer index");    // Find the peer and send    for (int i = 0; i < (int)n->peers.size; i++)    {        ENetPeer **peer = CArrayGet(&n->peers, i);        if ((int)(*peer)->data == peerIndex)        {            enet_peer_send(*peer, 0, MakePacket(msg, data));            enet_host_flush(n->server);            return;        }    }    CASSERT(false, "Cannot find peer by id");}

static voidCPath_Initialize(CPath *_this){	/* assertions */	CASSERT((_this != 0));	/* initialize the path */	_this->capacity  = 0;	_this->count     = 0;	_this->points    = 0;	_this->types     = 0;	_this->winding   = 0;	_this->newFigure = 1;	_this->hasCurves = 0;}

CINTERNAL voidCFiller_Reset(CFiller *_this){	/* assertions */	CASSERT((_this != 0));	/* reset the trapezoids */	_this->trapezoids = 0;	/* reset the polygon */	CPolygonX_Reset(&(_this->polygon));	/* reset the point array */	CPointArray_Count(_this->array) = 0;}

ENetPacket *NetEncode(const GameEventType e, const void *data){	uint8_t buffer[1024];	pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof buffer);	const pb_field_t *fields = GameEventGetEntry(e).Fields;	const bool status =		(data && fields) ? pb_encode(&stream, fields, data) : true;	CASSERT(status, "Failed to encode pb");	int msgId = (int)e;	ENetPacket *packet = enet_packet_create(		&msgId, NET_MSG_SIZE + stream.bytes_written,		ENET_PACKET_FLAG_RELIABLE);	memcpy(packet->data + NET_MSG_SIZE, buffer, stream.bytes_written);	return packet;}

static voidCBitmapSurface_Finalize(CSurface *_this){	/* declarations */	CBitmapSurface *surface;	/* assertions */	CASSERT((_this != 0));	/* get this as a bitmap surface */	surface = (CBitmapSurface *)_this;	/* finalize the bitmap surface */	CImage_Destroy((CImage **)&(surface->image));}

static CStatusCBitmapSurface_GetDpiY(CSurface *_this,                       CFloat   *dpiY){	/* declarations */	CBitmap *image;	/* assertions */	CASSERT((_this != 0));	CASSERT((dpiY  != 0));	/* get the image */	image = ((CBitmapSurface *)_this)->image;	/* get the vertical resolution, synchronously */	CMutex_Lock(image->lock);	{		*dpiY = image->dpiY;	}	CMutex_Unlock(image->lock);	/* return successfully */	return CStatus_OK;}

static CPicDrawContext GetBulletDrawContext(const int id){	const TMobileObject *obj = CArrayGet(&gMobObjs, id);	CASSERT(obj->isInUse, "Cannot draw non-existent mobobj");	// Calculate direction based on velocity	const direction_e dir = RadiansToDirection(Vec2iToRadians(obj->vel));	const Pic *pic = CPicGetPic(&obj->tileItem.CPic, dir);	CPicDrawContext c;	c.Dir = dir;	if (pic != NULL)	{		c.Offset = Vec2iNew(			pic->size.x / -2, pic->size.y / -2 - obj->z / Z_FACTOR);	}	return c;}

static void CheckCampaignDefComplete(menu_t *menu, void *data){	UNUSED(data);	if (gCampaign.IsLoaded)	{		if (gCampaign.IsError)		{			// Failed to load campaign; signal that we want to abort			MenuSystem *ms = data;			ms->hasAbort = true;		}		CASSERT(gCampaign.IsClient, "campaign is not client");		// Hack to force the menu to exit		menu->type = MENU_TYPE_RETURN;	}}

int DestructibleMapObjectIndex(const MapObject *mo){	if (mo == NULL)	{		return 0;	}	CA_FOREACH(const char *, name, gMapObjects.Destructibles)		const MapObject *d = StrMapObject(*name);		if (d == mo)		{			return _ca_index;		}	CA_FOREACH_END()	CASSERT(false, "cannot find destructible map object");	return -1;}

static bool HitItemFunc(TTileItem *ti, void *data){	HitItemData *hData = data;	if (!CanHit(hData->Obj->flags, hData->Obj->ActorUID, ti))	{		goto bail;	}	int targetUID = -1;	switch (ti->kind)	{	case KIND_CHARACTER:		hData->HitType = HIT_FLESH;		targetUID = ((const TActor *)CArrayGet(&gActors, ti->id))->uid;		break;	case KIND_OBJECT:		hData->HitType = HIT_OBJECT;		targetUID = ((const TObject *)CArrayGet(&gObjs, ti->id))->uid;		break;	default:		CASSERT(false, "cannot damage target kind");		break;	}	if (hData->Obj->soundLock > 0 ||		!HasHitSound(		hData->Obj->bulletClass->Power, hData->Obj->flags, hData->Obj->PlayerUID,		ti->kind, targetUID, hData->Obj->bulletClass->Special, true))	{		hData->HitType = HIT_NONE;	}	Damage(		hData->Obj->vel, hData->Obj->bulletClass->Power,		hData->Obj->flags, hData->Obj->PlayerUID, hData->Obj->ActorUID,		ti->kind, targetUID,		hData->Obj->bulletClass->Special);	if (hData->Obj->soundLock <= 0)	{		hData->Obj->soundLock += SOUND_LOCK_MOBILE_OBJECT;	}	if (hData->Obj->specialLock <= 0)	{		hData->Obj->specialLock += SPECIAL_LOCK;	}bail:	// Whether to produce multiple hits from the same TMobileObject	return hData->MultipleHits;}