C++ DebugEnd函数代码示例

T_hash32Item Hash32Find(T_hash32 hash, T_word32 key)
{
    T_hash32Struct *p_hash ;
    T_hash32ItemStruct *p_item = HASH32_ITEM_BAD ;
    T_doubleLinkListElement element ;
    T_doubleLinkList list ;
    T_hash32ItemStruct *p_itemSearch ;

    DebugRoutine("Hash32Find") ;

    /* Make sure this is a valid hash table type. */
    DebugCheck(hash != HASH32_BAD) ;
    if (hash != HASH32_BAD)  {
        /* Get a quick pointer to the header. */
        p_hash = (T_hash32Struct *)hash ;

        /* Make sure this is a pointer to a not already dead */
        /* hash table. */
        DebugCheck(p_hash->tag == HASH32_TAG) ;
        if (p_hash->tag == HASH32_TAG)  {
            /* Find the list that the element is definitely in. */
            list = p_hash->p_index[key & p_hash->keyMask] ;

            /* Search the list for a matching key. */
            element = DoubleLinkListGetFirst(list) ;
            while (element != DOUBLE_LINK_LIST_ELEMENT_BAD)  {
                /* Get the item in this list. */
                p_itemSearch = (T_hash32ItemStruct *)
                    DoubleLinkListElementGetData(element) ;

                /* See if the keys match */
                if (p_itemSearch->key == key)  {
                    /* Grab it and break out of this linear search. */
                    p_item = p_itemSearch ;
                    break ;
                }

                /* Find the next element. */
                element = DoubleLinkListElementGetNext(element) ;
            }
        }
    }

    DebugEnd() ;

    /* Return what we found. */
    return ((T_hash32Item)p_item) ;
}

T_void HardFormStartTest(T_word32 formNum)
{
    DebugRoutine("HardFormStartTest");
    DebugCheck(formNum < HARD_FORM_UNKNOWN);

    SpellsInitSpells();

    GrDrawRectangle(
            4,
            4,
            100,
            100,
            32);

    DebugEnd();
}

static T_void BankUIReorderSavedCoins()
{
    T_word16 i;

    DebugRoutine ("BankUIReorderSavedCoins");
    for (i=COIN_TYPE_COPPER;i<=COIN_TYPE_GOLD;i++)
    {
        StatsSetPlayerSavedCoins(i+1,StatsGetPlayerSavedCoins(i+1)+(StatsGetPlayerSavedCoins(i)/10));
        StatsSetPlayerSavedCoins(i,StatsGetPlayerSavedCoins(i)%10);
    }

    /* update graphics */
    BankUIUpdateGraphics();

    DebugEnd();
}

/*----------------------------------------------------------------------
            Parameters:
              map -   the map to write
              fname - the name of the file to write to.

           Description:
              write a map out to a file in hips format
----------------------------------------------------------------------*/
void
MapIShowImage(IMAP *map, char *name) {
  IMAGE    image ;
#if USE_XWIN
  xwindow_type *xwin ;
#endif

  ImageInitHeader(&image, map->cols, map->rows,  PFINT, 1) ;
  image.image = (unsigned char *)map->image ;

#if USE_XWIN
  xwin = DebugShowImage(&image, NULL, 1, name, 1) ;
  readKeyboard(&image, xwin, 1) ;
  DebugEnd(xwin) ;
#endif
}

E_Boolean SliderIsAt (T_sliderID sliderID, T_word16 lx, T_word16 ly)
{
	T_sliderStruct *p_slider;
   T_graphicID graphicID;
	E_Boolean retvalue=FALSE;

	DebugRoutine ("SliderIsAt");
	DebugCheck (sliderID!=NULL);

	p_slider = (T_sliderStruct *)sliderID ;

    retvalue=GraphicIsAt(p_slider->knobgraphic,lx,ly);

	DebugEnd();
	return (retvalue);
}

static T_void BankUIDeposit (T_buttonID buttonID)
{
    E_equipCoinTypes coin;
    DebugRoutine ("BankUIDeposit");
    DebugCheck (buttonID != NULL);

    /* get coin type */
    coin=ButtonGetData(buttonID);
    DebugCheck (coin < COIN_TYPE_FIVE);

    StatsSetPlayerSavedCoins (coin,StatsGetPlayerCoins(coin)+StatsGetPlayerSavedCoins(coin));
    StatsSetPlayerCoins(coin,0);
    BankUIReorderSavedCoins();

    DebugEnd();
}

/* open games to be sent */
static T_void GuildUIRequestGameList (T_void)
{
    DebugRoutine ("GuildUIRequestGameList");

/*
    GuildUIAddGame (1000,1);
    GuildUIAddGame (1000,2);
    GuildUIAddGame (1003,1);
    GuildUIAddGame (1001,1);
    GuildUIAddGame (1000,3);
*/

    GuildDisplayGameInfo (G_displayBoxes[GUILD_GAME_LIST]);

    DebugEnd();
}

/*--------------------------------------------------------------------------*/
T_void DirectTalkSendData(T_void *p_data, T_byte8 size)
{
    T_void *p_storeddata ;

    DebugRoutine("DirectTalkSendData");

    if (G_numPackets < DITALK_MAX_PACKETS)  {
        p_storeddata = (void *)MemAlloc((T_word32)size) ;
        memcpy(p_storeddata, p_data, size) ;
        G_packets[G_numPackets].p_data = p_storeddata ;
        G_packets[G_numPackets].size = size ;
        G_numPackets++ ;
    }

    DebugEnd();
}

/**
 *  Someone is requesting to join our game that we are creating!  Do
 *  we have room?  Are they requesting the right group and adventure id?
 *
 *  @param unqiueAddress -- unique address of person requesting to join
 *  @param groupID -- ID of group being requested to join
 *  @param adventure -- Number of adventure being requested to join
 *
 *  @return Current 16-bit adventure id.
 *
 *<!-----------------------------------------------------------------------*/
T_void PeopleHereRequestJoin(
        T_directTalkUniqueAddress uniqueAddress,
        T_gameGroupID groupID,
        T_word16 adventure)
{
    T_word16 i;
    T_gameGroupID ourGroupID;

    DebugRoutine("PeopleHereRequestJoin");

    ourGroupID = ClientSyncGetGameGroupID();

    /* In order to process this packet, we must be the */
    /* creator of the game and THIS particular group. */
    if ((CompareGameGroupIDs(groupID, ourGroupID))) {
        if ((PeopleHereGetOurState() == PLAYER_ID_STATE_CREATING_GAME)
                && (adventure == PeopleHereGetOurAdventure())
                && (IGetOurLocation() == PLAYER_ID_LOCATION_GUILD)) {
            if (G_numPeopleInGame < MAX_PLAYERS_PER_GAME) {
                /* Add this person to the list (if not already) */
                for (i = 0; i < G_numPeopleInGame; i++) {
                    /* Stop if we have seen this one before. */
                    if (memcmp(&uniqueAddress, &G_peopleNetworkIDInGame[i],
                            sizeof(uniqueAddress)) == 0)
                        break;
                }

                /* Are we at the end?  Then add the name. */
                if (i == G_numPeopleInGame) {
                    G_peopleNetworkIDInGame[i] = uniqueAddress;
                    G_numPeopleInGame++;
                }

                ClientSendRespondToJoinPacket(uniqueAddress, groupID, adventure,
                GAME_RESPOND_JOIN_OK);
            } else {
                ClientSendRespondToJoinPacket(uniqueAddress, groupID, adventure,
                GAME_RESPOND_JOIN_FULL);
            }
        } else {
            ClientSendRespondToJoinPacket(uniqueAddress, groupID, adventure,
            GAME_RESPOND_JOIN_CANCELED);
        }
    }

    DebugEnd();
}

T_sword32 FileRead(T_file file, T_void *p_buffer, T_word32 size)
{
    T_sword32 result ;

    DebugRoutine("FileRead") ;
    DebugCheck(file != FILE_BAD) ;
//    DebugCheck(size > 0) ;
    DebugCheck(p_buffer != NULL) ;

    SoundUpdateOften() ;
    result = read(file, p_buffer, size) ;
    SoundUpdateOften() ;

    DebugEnd() ;

    return result ;
}

T_void StoreCloseInventory (T_void)
{
    DebugRoutine ("StoreCloseInventory");

    G_storeOpen=FALSE;
    InventoryCloseStoreInventory();

    /* set banner back to normal mode */
//   BannerUIModeOff();

    G_houseMode=FALSE;

    /* clear control callback */
    StoreSetControlCallback (NULL);

    DebugEnd();
}

/**
 *  ICreateNode is used to create a new node structure item and clean it
 *  up before processing.  All fields are set to zero.
 *
 *  @return Newly create node.
 *
 *<!-----------------------------------------------------------------------*/
static T_doubleLinkListStruct *ICreateNode(T_void)
{
    T_doubleLinkListStruct *p_node ;
    T_word16 newNode ;

    DebugRoutine("ICreateNode") ;

#if 1      /* List method */
        if (G_firstFreeNode == 0xFFFF)  {
            DebugCheck(G_numAllocatedNodes < MAX_ALLOCATED_NODES) ;
            if (G_numAllocatedNodes >= MAX_ALLOCATED_NODES)  {
                GrGraphicsOff() ;
                fprintf(stderr, "Out of node memory!\n") ;
                exit(1001) ;
            }
            newNode = G_numAllocatedNodes++ ;
        } else {
            newNode = G_firstFreeNode ;
            G_firstFreeNode = G_nodes[newNode].countOrData.count ;
        }
        p_node = G_nodes + newNode ;
        memset(p_node, 0, sizeof(T_doubleLinkListStruct)) ;
#ifndef NDEBUG
        p_node->tag = DOUBLE_LINK_LIST_TAG ;
#endif
        G_numNodes++ ;
        if (G_numNodes > G_maxNodes)
            G_maxNodes = G_numNodes ;
#else
    p_node = MemAlloc(sizeof(T_doubleLinkListStruct)) ;
    DebugCheck(p_node != NULL) ;
    if (p_node)  {
        memset(p_node, 0, sizeof(T_doubleLinkListStruct)) ;
#ifndef NDEBUG
        p_node->tag = DOUBLE_LINK_LIST_TAG ;
#endif
        G_numNodes++ ;
        if (G_numNodes > G_maxNodes)
            G_maxNodes = G_numNodes ;
    }
#endif

    DebugEnd() ;

    return p_node ;
}

T_void HardFormUpdate(T_void)
{
    DebugRoutine("HardFormUpdate");
    if (G_currentForm < HARD_FORM_UNKNOWN) {
        GrScreenSet(GRAPHICS_ACTUAL_SCREEN);
        BannerUpdate();
        StatsUpdatePlayerStatistics();
        GraphicUpdateAllGraphics();
        ScheduleUpdateEvents();
        KeyboardUpdateEvents();
        MouseUpdateEvents();
        if (G_callbackGroups[G_currentForm].update != NULL )
            G_callbackGroups[G_currentForm].update();
    }

    DebugEnd();
}

T_void FormPush(T_void)
{
    T_formObjectID *p_formObjs;
    T_void *p_state;
    T_formVariousValues *p_values;

    DebugRoutine("FormPush");

    /* Make sure we have a list. */
    if (G_formStack == DOUBLE_LINK_LIST_BAD)
        G_formStack = DoubleLinkListCreate();

    /* Create a list of form objects to put on the stack. */
    p_formObjs = MemAlloc(sizeof(G_formObjectArray));
    DebugCheck(p_formObjs != NULL);
    memcpy(p_formObjs, G_formObjectArray, sizeof(G_formObjectArray));
    DoubleLinkListAddElementAtFront(G_formStack, p_formObjs);

    /* Clear the list of form objects */
    memset(G_formObjectArray, 0, sizeof(G_formObjectArray));

    /* Put the buttons on the list. */
    p_state = ButtonGetStateBlock();
    DoubleLinkListAddElementAtFront(G_formStack, p_state);

    /* Put the graphics on the list. */
    p_state = GraphicGetStateBlock();
    DoubleLinkListAddElementAtFront(G_formStack, p_state);

    /* Put the sliders on the list. */
    p_state = SliderGetStateBlock();
    DoubleLinkListAddElementAtFront(G_formStack, p_state);

    /* Put the text boxes on the list. */
    p_state = TxtboxGetStateBlock();
    DoubleLinkListAddElementAtFront(G_formStack, p_state);

    /* Put the callback and other flags in the list */
    p_values = MemAlloc(sizeof(T_formVariousValues));
    p_values->callback = formcallback;
    p_values->hasText = G_formHasTextBoxes;
    p_values->hasButtons = G_formHasButtons;
    DoubleLinkListAddElementAtFront(G_formStack, p_values);

    DebugEnd();
}

T_formObjectID FormAddTextBox(
        T_word16 x1,
        T_word16 y1,
        T_word16 x2,
        T_word16 y2,
        T_byte8 *fontname,
        T_word32 maxlength,
        T_byte8 hotkey,
        E_Boolean numericonly,
        E_TxtboxJustify justify,
        E_TxtboxMode boxmode,
        T_word32 idnum)
{
    T_word16 i;
    T_TxtboxID TxtboxID;

    DebugRoutine("FormAddTextBox");
    DebugCheck(fontname != NULL);
    DebugCheck(maxlength > 0);
    DebugCheck(justify < Txtbox_JUSTIFY_UNKNOWN);
    DebugCheck(boxmode < Txtbox_MODE_UNKNOWN);

    G_formHasTextBoxes = TRUE;

    for (i = 0; i < MAX_FORM_OBJECTS; i++) {
        /* find an empty slot */
        if (G_formObjectArray[i] == NULL ) {
            /* found one, create a new textform */
            TxtboxID = TxtboxCreate(x1, y1, x2, y2, fontname, maxlength, hotkey,
                    numericonly, justify, boxmode, FormReportTextBox);

            TxtboxSetCallback(TxtboxID, FormReportTextBox);
            /* now that a textform has been created, make an objstruct for it */
            G_formObjectArray[i] = FormCreateObject(FORM_OBJECT_TEXTBOX,
                    (T_formObjectID)TxtboxID, idnum);
            /* we made a new object struct, break from the loop */
            break;
        }
    }

    /* make sure we haven't exceeded any limits */
    DebugCheck(i!=MAX_FORM_OBJECTS);
    DebugEnd();
    /* return the ID for the object created */
    return (G_formObjectArray[i]);
}