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

int Gettimeofday(struct timeval *tv, struct timezone *tz) {   int result, _errno;#if WITH_MSGLEVEL <= E_DEBUG   if (tz) {      Debug3("gettimeofday(%p, {%d,%d})",	     tv, tz->tz_minuteswest, tz->tz_dsttime);   } else {      Debug1("gettimeofday(%p, NULL)", tv);   }#endif /* WITH_MSGLEVEL <= E_DEBUG */   result = gettimeofday(tv, tz);   _errno = errno;#if WITH_MSGLEVEL <= E_DEBUG   if (tz) {      Debug5("gettimeofday({%ld,%ld}, {%d,%d}) -> %d",             tv->tv_sec, tv->tv_usec, tz->tz_minuteswest, tz->tz_dsttime,	     result);   } else {      Debug3("gettimeofday({%ld,%ld},) -> %d",	     tv->tv_sec, tv->tv_usec, result);   }#endif /* WITH_MSGLEVEL <= E_DEBUG */   errno = _errno;   return result;}

bool EntityManager::DeletePlayer(Client * client){    gemActor *actor = client->GetActor();    if (actor && actor->GetCharacterData()!=NULL)    {        // take the actor off his mount if he got one        if(actor->GetMount())            RemoveRideRelation(actor);                    //As we show the logged in status only when the client gets ready we check if it         //was ready before doing this        if(client->IsReady())        {            // Check for buddy list members            usermanager->NotifyBuddies(client, UserManager::LOGGED_OFF);                    // Check for Guild members to notify            usermanager->NotifyGuildBuddies(client, UserManager::LOGGED_OFF);                        //check for alliance members to notify            usermanager->NotifyAllianceBuddies(client, UserManager::LOGGED_OFF);        }        // Any objects wanting to know when the actor is 'gone' are callback'd here.        actor->Disconnect();        if (!dynamic_cast<gemNPC*> (actor))  // NPC cast null means a human player        {            // Save current character state in the database            psServer::CharacterLoader.SaveCharacterData(actor->GetCharacterData(),actor);        }                 gemActor *familiar = client->GetFamiliar();        if ( familiar != NULL && familiar->IsValid())        {            // Send OwnerActionLogoff Perception            //familiar->Disconnect();            Debug3(LOG_NET,client->GetClientNum(),"EntityManager Removing actor %s from client %s.",familiar->GetName(),client->GetName() );            psServer::CharacterLoader.SaveCharacterData(familiar->GetCharacterData(),familiar);            client->SetFamiliar( NULL );            RemoveActor( familiar );        }        // This removes the actor from the world data        Debug3(LOG_NET,client->GetClientNum(),"EntityManager Removing actor %s from client %s.",actor->GetName(),client->GetName() );        gem->RemoveClientFromLootables(client->GetClientNum());        client->SetActor(NULL); // Prevent anyone from getting to a deleted actor through the client        RemoveActor(actor);    }    return true;}

unsigned int Nanosleep(const struct timespec *req, struct timespec *rem) {   int retval, _errno;   Debug3("nanosleep({"F_time",%ld},%p)", req->tv_sec, req->tv_nsec, rem);   retval = nanosleep(req, rem);   _errno = errno;   if (rem) {      Debug3("nanosleep(,{"F_time",%ld}) -> %d",	     rem->tv_sec, rem->tv_nsec, retval);   } else {      Debug1("nanosleep() -> %d", retval);   }   errno = _errno;   return retval;}

void pawsContainerDescWindow::HandleUpdateItem( MsgEntry* me ){    psViewItemUpdate mesg( me, ((psNetManager*)psengine->GetNetManager())->GetConnection()->GetAccessPointers() );    csString sigData, data;    // We send ownerID to multiple clients, so each client must decide if the item is owned by    // them or not.  This is double checked on the server if someone tries to move an item,    // so hacking this to override just breaks the display, but does not enable a cheat.    if (mesg.ownerID.IsValid() && mesg.ownerID != psengine->GetCelClient()->GetMainPlayer()->GetEID())    {        mesg.stackCount = -1; // hardcoded signal that item is not owned by this player    }    sigData.Format("invslot_%d", mesg.containerID.Unbox() * 100 + mesg.slotID + 16);    if (!mesg.clearSlot)    {        data.Format("%s %d %d %s %s %s", mesg.icon.GetData(), mesg.stackCount, 0, mesg.meshName.GetData(), mesg.materialName.GetData(), mesg.name.GetData());    }    Debug3(LOG_CHARACTER, 0, "Got item update for %s: %s/n", sigData.GetDataSafe(), data.GetDataSafe() );    // FIXME: psViewItemMessages should probably send out purification status    PawsManager::GetSingleton().Publish(sigData, data);}

void pawsNpcDialogWindow::OnStringEntered(const char* name, int param, const char* value){    //The user cancelled the operation. So show again the last window and do nothing else.    if(value == NULL)    {        Show();        return;    }    Debug3(LOG_QUESTS, 0,"Got name=%s, value=%s/n", name, value);    csString cmd;    if(param != -1)    {        cmd.Format("/tellnpc {%d} %s", param, value);    }    else    {        cmd.Format("/tellnpc %s", value);    }    psengine->GetCmdHandler()->Publish(cmd);    DisplayTextInChat(value);    ticks = csGetTicks(); // reset time, so we can wait for the next server response    gotNewMenu = false;}

int sycSSL_read(SSL *ssl, void *buf, int num) {   int result;   Debug3("SSL_read(%p, %p, %d)", ssl, buf, num);   result = SSL_read(ssl, buf, num);   Debug1("SSL_read() -> %d", result);   return result;}

int Sigprocmask(int how, const sigset_t *set, sigset_t *oset) {   int retval;   Debug3("sigprocmask(%d, %p, %p)", how, set, oset);   retval = sigprocmask(how, set, oset);   Debug1("sigprocmask() -> %d", retval);   return retval;}

int sycSSL_write(SSL *ssl, const void *buf, int num) {   int result;   Debug3("SSL_write(%p, %p, %d)", ssl, buf, num);   result = SSL_write(ssl, buf, num);   Debug1("SSL_write() -> %d", result);   return result;}

bool psEntity::CanPlay(int time, float range) const{    EntityState* entityState;    // checking if it is in the undefined state    entityState = states.Get(state, 0);    if(entityState == 0)    {        Debug3(LOG_SOUND, 0, "psEntity::CanPlay %s meshid: %u undefined state.", entityName.GetData(), GetMeshID());        return false;    }    // checking time, range and delay    if(range < minRange || range > maxRange)    {        Debug6(LOG_SOUND, 0, "psEntity::CanPlay %s meshid: %u range %f %f %f", entityName.GetData(),GetMeshID(), minRange, range, maxRange);        return false;    }    else if(time < entityState->timeOfDayStart || entityState->timeOfDayEnd < time)    {        Debug6(LOG_SOUND, 0, "psEntity::CanPlay %s meshid: %u time of day %d %d %d", entityName.GetData(),GetMeshID(), entityState->timeOfDayStart,time,entityState->timeOfDayEnd);        return false;    }    else if(when <= 0)    {        Debug4(LOG_SOUND, 0, "psEntity::CanPlay TRUE %s meshid: %u when <0 : %d", entityName.GetData(),GetMeshID(), when);        return true;    }    Debug4(LOG_SOUND, 0, "psEntity::CanPlay %s meshid: %u when : %d", entityName.GetData(),GetMeshID(), when);    return false;}

/* * Merge error information in "lr" with "parentr" error code and string. */static voidmerge_error_info( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr ){	if ( lr->lr_res_errno == LDAP_PARTIAL_RESULTS ) {		parentr->lr_res_errno = lr->lr_res_errno;		if ( lr->lr_res_error != NULL ) {			(void)ldap_append_referral( ld, &parentr->lr_res_error,				lr->lr_res_error );		}	} else if ( lr->lr_res_errno != LDAP_SUCCESS &&		parentr->lr_res_errno == LDAP_SUCCESS )	{		parentr->lr_res_errno = lr->lr_res_errno;		if ( parentr->lr_res_error != NULL ) {			LDAP_FREE( parentr->lr_res_error );		}		parentr->lr_res_error = lr->lr_res_error;		lr->lr_res_error = NULL;		if ( LDAP_NAME_ERROR( lr->lr_res_errno ) ) {			if ( parentr->lr_res_matched != NULL ) {				LDAP_FREE( parentr->lr_res_matched );			}			parentr->lr_res_matched = lr->lr_res_matched;			lr->lr_res_matched = NULL;		}	}	Debug1( LDAP_DEBUG_TRACE, "merged parent (id %d) error info:  ",		parentr->lr_msgid );	Debug3( LDAP_DEBUG_TRACE, "result errno %d, error <%s>, matched <%s>/n",		parentr->lr_res_errno,		parentr->lr_res_error ?  parentr->lr_res_error : "",		parentr->lr_res_matched ?  parentr->lr_res_matched : "" );}

NpcResponse *ChatManager::CheckNPCEvent(Client *client,csString& triggerText,gemNPC * &target){    gemNPC *npc = target;    if (npc && npc->IsAlive())    {        csString trigger(triggerText);        trigger.Downcase();        psNPCDialog *npcdlg = npc->GetNPCDialogPtr();        if (npcdlg)  // if NULL, then NPC never speaks        {            float dist = npc->RangeTo( client->GetActor() );            if (dist > MAX_NPC_DIALOG_DIST)                return NULL;            Debug3(LOG_NPC, client->GetClientNum(),"%s checking trigger %s./n",target->GetName(),trigger.GetData() );            return npcdlg->Respond(trigger,client);        }        else        {            // Admins and GMs can see a better error on the client            if (client->GetSecurityLevel() > 20)                psserver->SendSystemError(client->GetClientNum(),"%s cannot speak.",npc->GetName() );            Debug2(LOG_NPC, client->GetClientNum(),"NPC %s cannot speak./n",npc->GetName() );        }    }    return NULL;}

int sycSSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type) {   int result;   Debug3("SSL_CTX_use_PrivateKey_file(%p, /"%s/", %d)", ctx, file, type);   result = SSL_CTX_use_PrivateKey_file(ctx, file, type);   Debug1("SSL_CTX_use_PrivateKey_file() -> %d", result);   return result;}

int Sigaction(int signum, const struct sigaction *act,	      struct sigaction *oldact) {   int retval;   Debug3("sigaction(%d, %p, %p)", signum, act, oldact);   retval = sigaction(signum, act, oldact);   Debug1("sigaction() -> %d", retval);   return retval;}

int Chown(const char *path, uid_t owner, gid_t group) {   int retval, _errno;   Debug3("chown(/"%s/", "F_uid", "F_gid")", path, owner, group);   retval = chown(path, owner, group);   _errno = errno;   Debug1("chown()  -> %d", retval);   errno = _errno;   return retval;}

int Readlink(const char *path, char *buf, size_t bufsiz) {   int retval, _errno;   Debug3("readlink(/"%s/", %p, "F_Zu")", path, buf, bufsiz);   retval = readlink(path, buf, bufsiz);   _errno = errno;   Debug1("readlink() -> %d", retval);   errno = _errno;   return retval;}

int Fchown(int fd, uid_t owner, gid_t group) {   int retval, _errno;   Debug3("fchown(%d, "F_uid", "F_gid")", fd, owner, group);   retval = fchown(fd, owner, group);   _errno = errno;   Debug1("fchown() -> %d", retval);   errno = _errno;   return retval;}

int Ioctl_int(int d, int request, int arg) {   int retval, _errno;   Debug3("ioctl(%d, 0x%x, %d)", d, request, arg);   retval = ioctl(d, request, arg);   _errno = errno;   Debug1("ioctl() -> %d", retval);   errno = _errno;   return retval;}

int Fcntl_l(int fd, int cmd, long arg) {   int result, _errno;   Debug3("fcntl(%d, %d, %ld)", fd, cmd, arg);   result = fcntl(fd, cmd, arg);   _errno = errno;   Debug1("fcntl() -> %d", result);   errno = _errno;   return result;}

int Socket(int domain, int type, int protocol) {   int result, _errno;   Debug3("socket(%d, %d, %d)", domain, type, protocol);   result = socket(domain, type, protocol);   _errno = errno;   Info4("socket(%d, %d, %d) -> %d", domain, type, protocol, result);   errno = _errno;   return result;}

int Open(const char *pathname, int flags, mode_t mode) {   int result, _errno;   Debug3("open(/"%s/", 0%o, 0%03o)", pathname, flags, mode);   result = open(pathname, flags, mode);   _errno = errno;   Info4("open(/"%s/", 0%o, 0%03o) -> %d", pathname, flags, mode, result);   errno = _errno;   return result;}

int Mknod(const char *pathname, mode_t mode, dev_t dev) {   int result, _errno;   Debug3("mknod(/"%s/", 0%o, %d)", pathname, mode, dev);   result = mknod(pathname, mode, dev);   _errno = errno;   Debug1("mknod() -> %d", result);   errno = _errno;   return result;}

void EntityManager::HandleAllRequest(MsgEntry* me, Client *client){    // This is not available to regular clients!    if ( client->IsSuperClient() )    {        // Now send every single entity in the world to him        psPersistAllEntities *allEntMsg = new psPersistAllEntities(me->clientnum);        csHash<gemObject*, EID>& gems = gem->GetAllGEMS();        csHash<gemObject*, EID>::GlobalIterator i(gems.GetIterator());        gemObject* obj;          int count=0;        while ( i.HasNext() )        {            count++;            obj = i.Next();            if (allEntMsg->msg->current > allEntMsg->msg->GetSize() - 1000)            {                // the current message is full of entities, so send it and make another one                allEntMsg->msg->ClipToCurrentSize();                Debug3(LOG_NET, client->GetClientNum(), "Sending %d entities in %zu bytes.", count-1, allEntMsg->msg->GetSize() );                allEntMsg->SendMessage();                delete allEntMsg;                count = 1;                allEntMsg = new psPersistAllEntities(me->clientnum); // here is the new one to continue with            }            // The 0 in param 1 and the false in param 3 suppresses the immediate send to superclient, since we are appending now            obj->Send(0, false,  false, allEntMsg ); // this doesn't actually send but just appends to allEntMsg        }        allEntMsg->msg->ClipToCurrentSize();        Debug3(LOG_NET, client->GetClientNum(), "Final send is %d entities in %zu bytes.", count, allEntMsg->msg->GetSize() );        allEntMsg->SendMessage(); // This handles the final message with whatever entities are left.        // Tell superclient which entities he is managing this time        psserver->npcmanager->SendNPCList(client);        }    else    {        Debug2(LOG_CHEAT, client->GetClientNum(),"Player %s trying to cheat by requesting all objects.", client->GetName());    }}

ssize_t Write(int fd, const void *buf, size_t count) {   ssize_t result;   int _errno;   Debug3("write(%d, %p, "F_Zu")", fd, buf, count);   result = write(fd, buf, count);   _errno = errno;   Debug1("write -> "F_Zd, result);   errno = _errno;   return result;}

off64_t Lseek64(int fildes, off64_t offset, int whence) {   int _errno;   off64_t result;   Debug3("lseek64(%d, "F_off64", %d)", fildes, offset, whence);   result = lseek64(fildes, offset, whence);   _errno = errno;   Debug1("lseek64() -> "F_off64, result);   errno = _errno;   return result;}

pid_t Waitpid(pid_t pid, int *status, int options) {   int _errno;   pid_t retval;   Debug3("waitpid("F_pid", %p, %d)", pid, status, options);   retval = waitpid(pid, status, options);   _errno = errno;   Debug2("waitpid(, {%d}, ) -> "F_pid, *status, retval);   errno = _errno;   return retval;}

ssize_t Read(int fd, void *buf, size_t count) {   ssize_t result;   int _errno;   Debug3("read(%d, %p, "F_Zu")", fd, buf, count);   result = read(fd, buf, count);   _errno = errno;   Debug1("read -> "F_Zd, result);   errno = _errno;   return result;}

int Getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) {   int result, _errno;   Debug5("getsockopt(%d, %d, %d, %p, {"F_Zd"})",	  s, level, optname, optval, *optlen);   result = getsockopt(s, level, optname, optval, optlen);   _errno = errno;   Debug3("getsockopt() -> (,,, 0x%08x, %d), %d",	  *(int *)optval, *optlen, result);   errno = _errno;   return result;}

int Bind(int sockfd, struct sockaddr *my_addr, int addrlen) {   int result, _errno;   char infobuff[256];   sockaddr_info(my_addr, addrlen, infobuff, sizeof(infobuff));   Debug3("bind(%d, %s, "F_Zd")", sockfd, infobuff, addrlen);   result = bind(sockfd, my_addr, addrlen);   _errno = errno;   Debug1("bind() -> %d", result);   errno = _errno;   return result;}

int Getpeername(int s, struct sockaddr *name, socklen_t *namelen) {   int result, _errno;   char infobuff[256];   Debug4("getpeername(%d, %p, %p{"F_socklen"})", s, name, namelen, *namelen);   result = getpeername(s, name, namelen);   _errno = errno;   sockaddr_info(name, *namelen, infobuff, sizeof(infobuff));   Debug3("getpeername(, {%s}, {"F_socklen"}) -> %d",	  infobuff, *namelen, result);   errno = _errno;   return result;}