Пример #1
0
void Menu_Game_Exit(void *info)
{
    Base_State *gState = info;
    struct menu_Game *menu = gState->info;

    while(menu->nameList != NULL)
    {
        mem_Free(menu->nameList->data);
        list_Pop(&menu->nameList);
    }

    while(menu->campaignNameList != NULL)
    {
        mem_Free(menu->campaignNameList->data);
        list_Pop(&menu->campaignNameList);
    }

    /*Clear up ui*/
    uiSpine_Clean(&menu->spine);

    /*Remove any graphics that should not be drawn*/
    gKer_FlushGraphics();

    mem_Free(menu);

    return;
}
Пример #2
0
void
lex_FreeBuffer(SLexerBuffer* buffer) {
    if (buffer) {
        if (buffer->buffer) {
            mem_Free(buffer->buffer);
        } else {
            internalerror("buf->pBufferStart not initialized");
        }
        mem_Free(buffer);
    } else {
        internalerror("Argument must not be NULL");
    }
}
Пример #3
0
void vLevel_LoadCustomSurface_0(Vent_Level *l, Level_Tag *tag, FILE *levelFile)
{
    const int version = 0;

    char surfacePathLimit[255];

    int ID = 0;

    int numRotated = 0;
    int rotationDeg = 0;

    int x = 0;
    int y = 0;

    char *directory = NULL;
    char *name = NULL;

    /*Load the custom surfaces*/
    for(x = 0; x < tag->amount; x++)
    {
        fscanf(levelFile, "%s%d%d", surfacePathLimit, &ID, &numRotated);

        /*update for version 1 of load custom surface*/
        string_Split(surfacePathLimit, &directory, &name, '/');


        file_Log(ker_Log(), P_OUT, "Loading custom surface(%d) from: %s --> [%s] [%s]\n", ID, surfacePathLimit, directory, name);

        vLevel_SurfaceInsert(&l->surfacesLoaded, directory, name, ID);
        mem_Free(directory);
        mem_Free(name);
        if(numRotated > 0)
        {
            //file_Log(ker_Log(), 1, "Creating %d rotations of surface(%d)\n", numRotated, ID);

            for(y = 0; y < numRotated; y++)
            {
                fscanf(levelFile, "%d", &rotationDeg);
                vLevel_SurfaceInsertRotation(l->surfacesLoaded, ID, rotationDeg);

                //file_Log(ker_Log(), 1, "\t%d rotation\n", rotationDeg);
            }
        }

        fscanf(levelFile, "\n");
    }

    return;
}
Пример #4
0
void *mem_Realloc(void *pOld, uint_t nSize)
#endif
{
	void *p;

	if (pOld == NULL)
#if DEBUG_MEMORY_ENABLE
		return _mem_Malloc(nSize, fn, line);
#else
		return mem_Malloc(nSize);
#endif
	if (nSize == 0) {
#if DEBUG_MEMORY_ENABLE
		_mem_Free(pOld, fn, line);
#else
		mem_Free(pOld);
#endif
		return NULL;
	}
	mem_Lock();
#if DEBUG_MEMORY_ENABLE
	p = _rt_realloc(pOld, nSize);
#else
	p = rt_realloc(pOld, nSize);
#endif
	mem_Unlock();
#if DEBUG_MEMORY_ENABLE
	mem_DebugRealloc(p, pOld, fn, line);
#endif
	return p;
}
Пример #5
0
int surf_Quit(void)
{
    surf_Free_All();
    mem_Free(surf_C.surfacesDIR);

    return 0;
}
Пример #6
0
void list_Delete_Node(struct list **head, struct list *dList)
{
    if(dList == *head)
    {
        if((*head)->next != NULL)
            (*head)->next->previous = (*head)->previous; /*Set the previous to point to the end of the list*/
        *head = (*head)->next;
    }
    else
    {
        dList->previous->next = dList->next;
        if(dList->next != NULL)
            dList->next->previous = dList->previous;

        if(dList == (*head)->previous) /*If dList is at the end*/
        {
            if(dList->previous != *head)
                (*head)->previous = dList->previous;
            else
                (*head)->previous = NULL;
        }
    }

    #ifdef MEM_TRACK
    mem_Free(dList);
    #else
	free(dList);
	#endif

    return;
}
Пример #7
0
void drawManager_AddType(Draw_Manager *dM, Draw_Type *dT)
{
    int x = 0;
    Draw_Type **newArray = NULL;

    dM->numTypes ++;

    /*Create the new array to hold the draw types*/
    newArray = (Draw_Type **)mem_Alloc(dM->numTypes * sizeof(Draw_Type *));

    for(x = 0; x < (dM->numTypes - 1); x++)
    {
        newArray[x] = dM->drawTypes[x];
    }

    newArray[x] = dT;

    /*Release the array in the draw manager and replace it with the new one*/
    if(dM->drawTypes != NULL)
    {
        mem_Free(dM->drawTypes);
    }

    dM->drawTypes = newArray;

    return;
}
Пример #8
0
/*
    Function: drawType_ReleaseExcess

    Description -
    If there are any unused nodes with a specific type then it will delete them.
    The maximum total layers that will be deleted is specified by 'amount'.
    Returns the amount of nodes that have been deleted.

    2 arguments:
    Draw_Layer *dT - The type of unused nodes to remove.
    int amount - The maximum amount of unused nodes to remove, if < 0 then all will be removed.
*/
int drawType_ReleaseExcess(Draw_Type *dT, int amount)
{
    int x = 0;

    if(amount < 0)
        amount = dT->totalFree;

    if(dT->totalFree > 0)
    {
        for(x = 0; x < amount; x++)
        {
            /*Delete all the unused nodes*/
            drawObject_Clean(dT->unusedObjectList->data);
            mem_Free(dT->unusedObjectList->data);

            list_Pop(&dT->unusedObjectList);

            dT->totalFree --;

            if(dT->totalFree == 0)
            {
                x ++;

                break;
            }
        }

        *dT->totalObjectLocations = *dT->totalObjectLocations - x;

        return x;
    }

    return 0;
}
Пример #9
0
/*
    Function: drawObject_Clean

    Description -
    Cleans up a draw object.

    1 argument:
    Draw_Object *drawObject - The draw object to clean up.
*/
void drawObject_Clean(Draw_Object *drawObject)
{
    mem_Free(drawObject->object);
    drawObject->type = NULL;

    return;
}
Пример #10
0
/*
    Function: drawLayer_Release

    Description -
    This function either removes or sets a node in the list as inactive.
    Inactive nodes can be reused later to save there being another call to malloc.

    3 arguments:
    Draw_Layer *dL - The layer that the node to remove is located.
    struct list *node - The node that is to be removed/set inactive.
    int remove - If 1 then the node will be deleted, otherwise it can be reused.
*/
void drawLayer_Release(Draw_Layer *dL, struct list *node, int remove)
{
    Draw_Object *drawObj = node->data;

   //printf("Layer(REM): %d, Total %d, Used %d, Free %d\n", dL->layer, dL->totalNodes, dL->totalUsed, dL->totalFree);

    if(remove == 1)
    {
        drawObject_Clean(node->data);
        mem_Free(node->data);
        list_Delete_Node(&dL->objectList, node);

        dL->totalNodes --;

        *dL->totalObjectLocations = *dL->totalObjectLocations - 1;
    }
    else
    {
        /*Remove the node from the list*/
        list_Unlink_Node(&dL->objectList, node);

        /*Place it at the head of the unused list*/
        list_Push_Node(&drawObj->type->unusedObjectList, node, node->data, node->info);

        drawObj->type->totalFree ++;
    }

    return;
}
Пример #11
0
void SOCKETFIFO_Flush (void) {
    SocketFifoElement_t element;
    while (SOCKETFIFO_Pop(&element)) {
        if (element.freedata) {
            mem_Free(element.data);
        }
    }
}
Пример #12
0
SLexerBuffer*
lex_CreateFileBuffer(FILE* fileHandle) {
    char strterm = 0;
    char* pFile;
    bool bWasSpace = true;

    SLexerBuffer* pBuffer = (SLexerBuffer*) mem_Alloc(sizeof(SLexerBuffer));
    memset(pBuffer, 0, sizeof(SLexerBuffer));

    size_t size = fsize(fileHandle);

    pFile = (char*) mem_Alloc(size);
    size = fread(pFile, sizeof(uint8_t), size, fileHandle);

    pBuffer->buffer = (char*) mem_Alloc(size + 1);
    char* dest = pBuffer->buffer;

    char* mem = pFile;

    while (mem < pFile + size) {
        if (*mem == '"' || *mem == '\'') {
            strterm = *mem;
            *dest++ = *mem++;
            while (*mem && *mem != strterm) {
                if (*mem == '\\')
                    *dest++ = *mem++;

                *dest++ = *mem++;
            }
            *dest++ = *mem++;
            bWasSpace = false;
        } else if ((mem[0] == 10 && mem[1] == 13) || (mem[0] == 13 && mem[1] == 10)) {
            *dest++ = '\n';
            mem += 2;
            bWasSpace = true;
        } else if (mem[0] == 10 || mem[0] == 13) {
            *dest++ = '\n';
            mem += 1;
            bWasSpace = true;
        } else if (*mem == ';' || (bWasSpace && mem[0] == '*')) {
            ++mem;
            while (*mem && *mem != 13 && *mem != 10)
                ++mem;
            bWasSpace = false;
        } else {
            bWasSpace = isspace((uint8_t) *mem) ? true : false;
            *dest++ = *mem++;
        }
    }


    *dest++ = '\n';
    pBuffer->bufferSize = dest - pBuffer->buffer;
    pBuffer->atLineStart = true;

    mem_Free(pFile);
    return pBuffer;
}
Пример #13
0
//-------------------------------------------------------------------------
//
//-------------------------------------------------------------------------
static void regloader_Close(p_reg_loader p, uint_t nType)
{

	if (p->ste == REGLOADER_S_NEED_SYNC)
		regloader_Save(p, nType);
 	mem_Free(p->data);
	p->size = 0;
	p->hit = 0;
}
Пример #14
0
//-------------------------------------------------------------------------
//
//-------------------------------------------------------------------------
int reg_ArithmeticCopy(uint_t nDestDa, uint_t nDestReg, uint_t nSrcDa, uint_t nSrcReg, uint_t nType, uint32_t nParam, uint_t nSave)
{
	int nLen;
	uint64_t nTemp;
	void *pBuf;
	
	nLen = reg_GetRegSize(nSrcReg);
	if (nLen < 0)
		return 0;
	if (nType == REG_O_COPY) {
		pBuf = mem_Malloc(nLen);
		if (pBuf == NULL)
			return 0;
		reg_Get(nSrcDa, nSrcReg, pBuf);
		reg_Set(nDestDa, nDestReg, pBuf, nSave);
		mem_Free(pBuf);
	} else {
		if (nLen > 8)
			return 0;
		nTemp = 0;
		reg_Get(nSrcDa, nSrcReg, &nTemp);
		switch (nType) {
		case REG_O_ADD:
			nTemp += nParam;
			break;
		case REG_O_SUB:
			nTemp -= nParam;
			break;
		case REG_O_MUL:
			nTemp *= nParam;
			break;
		case REG_O_DIV:
			nTemp /= nParam;
			break;
		case REG_O_OR:
			//或
			nTemp |= nParam;
			break;
		case REG_O_AND:
			//与
			nTemp &= nParam;
			break;
		case REG_O_SETBIT:
			//置位
			SETBIT(nTemp, nParam);
			break;
		case REG_O_CLRBIT:
			//清位
			CLRBIT(nTemp, nParam);
			break;
		default:
			break; 
		}
		reg_Set(nDestDa, nDestReg, &nTemp, nSave);
	}
	return nLen; 
}
Пример #15
0
/*
    Function: drawManager_Clean

    Description -
    Deletes all the layers in the draw manager. Also removes any remaining draw objects in the manager.

    1 argument:
    Draw_Manager *dM - The draw manager to clean.
*/
void drawManager_Clean(Draw_Manager *dM)
{
    /*Delete all the layers and the objects inside of them*/
    drawManager_CleanLayers(dM);

    /*Delete all the draw types*/
    for(dM->numTypes = dM->numTypes; dM->numTypes > 0; dM->numTypes --)
    {
        drawType_Clean(dM->drawTypes[dM->numTypes - 1]);
        mem_Free(dM->drawTypes[dM->numTypes - 1]);
    }

    if(dM->drawTypes != NULL)
    {
        mem_Free(dM->drawTypes);
    }

    return;
}
Пример #16
0
/*
    Function: vLevel_LoadHeader

    Description -
    Loads a level header from a file.

    3 arguments:
    Vent_Level_Header *header - The level header to be loaded into.
    char *directory - The directory name of the level to load.
    char *name - The file name of the level to load.
*/
void vLevel_LoadHeader(Vent_Level_Header *header, char *directory, char *name)
{
    char *loadFolder = directory;
    char *loadName = (char *)mem_Malloc(strlen(loadFolder) + strlen(name) + 1, __LINE__, __FILE__);

    int finishedLoading = 0;

    FILE *load = NULL;
    Level_Tag tag;

    /*Setup the default values of the header*/
    vLevel_SetupHeader(header, NULL, 0, 0);

    /*Find the level file*/
    strcpy(loadName, loadFolder);
    strcat(loadName, name);

    load = fopen(loadName, "r");

    if(load == NULL)
    {
        file_Log(ker_Log(), 1, "Error: Could not load level file for header. (%s)\n", loadName);

        return;
    }

    while(vLevel_TagVerify(&tag, load) == 1 && finishedLoading == 0)
    {
        switch(tag.type)
        {
            case TAG_HEADER:

            if(tag.version < HEADER_VERSIONS)
            {
                vLevel_LoadHeaderVer[tag.version](header, &tag, load);
                finishedLoading = 1;
            }

            break;

            default:

            file_Log(ker_Log(), 1, "Error unknown tag type (while searching for header) %s -> %d\n", tag.name, tag.type);

            break;
        }
    }

    fclose(load);

    mem_Free(loadName);

    return;
}
Пример #17
0
void control_CleanKeys(Control_Keys *keys)
{
    if(keys->keys != NULL)
    {
        mem_Free(keys->keys);
        keys->keys = NULL;
    }

    keys->numKeys = 0;

    return;
}
Пример #18
0
void drawManager_CleanLayers(Draw_Manager *dM)
{
    while(dM->layers != NULL)
    {
        drawLayer_Clean(dM->layers->data);
        mem_Free(dM->layers->data);

        list_Pop(&dM->layers);
    }

    return;
}
Пример #19
0
/*
    Function: uiTextInput_Clean

    Description -

    Clean up any allocated memory created by the text input structure.

    1 argument:
    Ui_TextInput *textInput - The text input structure to clean up
*/
void uiTextInput_Clean(Ui_TextInput *textInput)
{
    uiButton_Clean(&textInput->button);

    mem_Free(textInput->inputText);

    sprite_Clean(&textInput->sMarker);

    depWatcher_Clean(&textInput->dW);

    return;
}
Пример #20
0
void aiModule_Clean(Ai_Module *aiMod)
{
    while(aiMod->globalList != NULL)
    {
        aiState_Clean(aiMod->globalList->data);
        mem_Free(aiMod->globalList->data);

        list_Pop(&aiMod->globalList);
    }

    while(aiMod->localList != NULL)
    {
        aiState_Clean(aiMod->localList->data);
        mem_Free(aiMod->localList->data);

        list_Pop(&aiMod->localList);
    }

    aiMod->highestPriority = aiMod->lowestPriority = NULL;

    return;
}
Пример #21
0
void uiButtonChain_Clean(Ui_ButtonChain *bChain)
{
    bChain->currentList = NULL;
    bChain->currentButton = NULL;

    while(bChain->bList != NULL)
    {
        uiButton_Clean(bChain->bList->data);
        mem_Free(bChain->bList->data);

        list_Pop(&bChain->bList);
    }

    return;
}
Пример #22
0
/*
    Function: vLevel_Save

    Description -
    Function that saves a level in the /Level/ folder.

    3 arguments:
    Vent_Level *l - the level to save
	char *directory - the name of the directory to save the level in
    char *name - the name to save the level as, .map will be appended to this
*/
void vLevel_Save(Vent_Level *l, char *directory, char *name)
{
    char *saveFolder = directory;
    char *saveName = (char *)mem_Malloc(strlen(saveFolder) + strlen(name) + strlen(".map") + 1, __LINE__, __FILE__);

    int x = 0;

    FILE *save = NULL;

    strcpy(saveName, saveFolder);
    strcat(saveName, name);
    strcat(saveName, ".map");

    save = fopen(saveName, "w");

    if(save == NULL)
    {
        printf("Error could not save level %s\n", saveName);

        return;
    }

    l->header.numCustomSurfaces = vLevel_GetCustomSurfaces(l);

    /*Structure of the level in a file -
    First write the object tag - [TAGNAME] objectAmount tagVersion
    Then below that write all the object data.
    */
    vLevel_SaveHeader(&l->header, save);

    vLevel_SaveCustomSurface(l, save);

    vLevel_SaveTile(l, save);

    vLevel_SaveSupply(l, save);

    vLevel_SaveNode(l, save);

    vLevel_SaveEdge(l, save);

    vLevel_SaveTag(save, 0, TAG_END);

    fclose(save);

    mem_Free(saveName);

    return;
}
Пример #23
0
/**
 * Put an element back into its pool.
 *
 * @param type the pool where to put mem
 * @param mem the memp element to free
 */
void
memp_free(memp_t type, void *mem)
{
	rt_uint32_t level;

	level = rt_hw_interrupt_disable();
	if (type == MEMP_TCP_PCB && mem)
	{
		tcp_pcbs --;
	}
	rt_hw_interrupt_enable(level);

    LWIP_DEBUGF(MEMP_DEBUG, ("memp free %s, mem 0x%x\n", memp_desc[type], mem));
    /* release this memory */
    mem_Free(mem);
}
Пример #24
0
void list_Pop(struct list **head)
{
	struct list *listStart = *head;

    if((*head)->next != NULL)
        (*head)->next->previous = (*head)->previous; /*Set the previous to point to the end of the list*/

    *head = (*head)->next;

    #ifdef MEM_TRACK
    mem_Free(listStart);
    #else
	free(listStart);
	#endif

	return;
}
Пример #25
0
static void MM_QuitCampaign(Ui_Button *button)
{
    Base_State *gState = button->info->dataArray[0];
    int accepted = (int)button->info->dataArray[1];

    struct menu_Game *menu = gState->info;

    char *campaignName = (char *)mem_Malloc(strlen(menu->selectedCampaign) + 1, __LINE__, __FILE__);

    strcpy(campaignName, menu->selectedCampaign);

    /*Fix the campaign name*/
    string_RemoveExt(campaignName);

    /*Revert to the main ui section*/
    uiSpine_Close(uiSpine_GetEntity(&menu->spine, "Spine:Campaign"));

    /*If the campaign chosen was accepted*/
    if(accepted == 1)
    {
        vPlayer_LoadCampaign(menu->player, campaignName);

        if(menu->player->playCampaign == 1 && menu->player->campaign != NULL)
        {
            menu->selectedCampaign = menu->player->campaign->name;
            menu->player->levelDirectory = kernel_GetPath("PTH_VentLevels");
        }
        else
        {
            menu->player->levelDirectory = kernel_GetPath("PTH_VentCustomLevels");
        }

        /*Repopulate the level scroll*/
        MM_RepopulateLevels(gState);
    }

    timer_StopSkip(&menu->spine.sTimer, 0, 1);
    control_Pause(500);

    mem_Free(campaignName);

    return;
}
Пример #26
0
void list_ClearAll(struct list **listHead)
{
    struct list *dataFetch;

    while(*listHead != NULL)
    {
        dataFetch = *listHead;

        #ifdef MEM_TRACK
        mem_Free(dataFetch->data);
        #else
        free(dataFetch->data);
        #endif

        list_Pop(listHead);
    }

    return;
}
Пример #27
0
int aiModule_DestroyState(Ai_Module *aiMod, struct list **headList, struct list *currentNode, Ai_State *a)
{
    list_Delete_Node(headList, currentNode);/*Remove the state from the list*/

    /*Make sure the state is not in the lowest/highest priority tracking in the ai module*/
    if(a == aiMod->highestPriority)
    {
        aiMod->highestPriority = NULL;
    }

    if(a == aiMod->lowestPriority)
    {
        aiMod->lowestPriority = NULL;
    }


    /*Release any memory allocated for the state*/
    aiState_Clean(a);
    mem_Free(a); /*and delete the state*/

    return 0;
}
Пример #28
0
/*
	Function: control_Clear

	Description -
	Removes all keys in an event. Returns the number of keys removed.

	1 argument:
	Control_Event *c - should point to the event that needs the keys removed.
*/
int control_Clear(Control_Event *c)
{
    Control_Keys *keys = NULL;
	int numRemoved = 0;

    while(c->eventKeys != NULL)
    {
        keys = c->eventKeys->data;

        if(keys != NULL)
        {
            control_CleanKeys(keys);
            mem_Free(keys);
        }

        list_Pop(&c->eventKeys);

		numRemoved ++;
    }

    return numRemoved;
}
Пример #29
0
/*
    Function: drawLayer_Clean

    Description -
    Removes and cleans up all objects in the layer.

    1 argument:
    Draw_Layer *layer - The layer to clean up.
*/
void drawLayer_Clean(Draw_Layer *layer)
{
    Draw_Object *drawObj = NULL;

    while(layer->objectList != NULL)
    {
        drawObj = layer->objectList->data;

        if(drawObj->type->cleanFunction != NULL)
        {
            drawObj->type->cleanFunction(drawObj);
        }

        drawObject_Clean(drawObj);
        mem_Free(drawObj);

        *layer->totalObjectLocations = *layer->totalObjectLocations - 1;

        list_Pop(&layer->objectList);
    }

    return;
}
Пример #30
0
void MM_RepopulateLevels(Base_State *gState)
{
    struct menu_Game *menu = gState->info;

    Ui_ButtonScroll *scroll = NULL;

    /*Clean up the current level scroll*/
    scroll = uiSpine_RemoveEntity(&menu->spine, "Scroll:Levels");

    uiButtonScroll_Clean(scroll);
    mem_Free(scroll);

    /*Add in the new one*/
    scroll =  MM_CreateLevelScroll(gState);

    uiSpine_AddScroll(&menu->spine, scroll, "Scroll:Levels");

    menu->player->levelChosen = "None";
    vLevel_SetupHeader(&menu->levelHeader, "None", 0, 0);

    uiSpine_MapEntity(&menu->spine);
    return;
}