From e757da99ffe8c54793d3cc60e9716c95e583097c Mon Sep 17 00:00:00 2001 From: Walter Julius Hennecke Date: Sat, 6 Apr 2013 22:27:08 +0200 Subject: [PATCH] Revert "Modified list module and sublicensed it" This reverts commit f54a709f00f3e1fad4abad5fa1106e054be41232. --- README-RPG-X2.txt | 52 +----------- code/game/g_active.c | 4 +- code/game/g_cmds.c | 10 +-- code/game/g_main.c | 2 +- code/game/list.c | 190 +++++++++++++++---------------------------- code/game/list.h | 65 +++++---------- 6 files changed, 94 insertions(+), 229 deletions(-) diff --git a/README-RPG-X2.txt b/README-RPG-X2.txt index 4918416..394e118 100644 --- a/README-RPG-X2.txt +++ b/README-RPG-X2.txt @@ -71,57 +71,7 @@ creators is not allowed. Feel free to use the source code included in this file and/or git repository for your own mod as long as you give full credit to UberGamesi for our modification/code and as long as this does not conflict with the original license of the STVEF HM -gamecode. The Ubergames and other conributers to the RPG-X Mod cannot +gamecode.. The Ubergames and other conributers to the RPG-X Mod cannot be held accountable for any damage that may have been caused by playing the game. -Lua License: ------------- -/**************************************************************************** -* Copyright (C) 1994-2013 Lua.org, PUC-Rio. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining -* a copy of this software and associated documentation files (the -* "Software"), to deal in the Software without restriction, including -* without limitation the rights to use, copy, modify, merge, publish, -* distribute, sublicense, and/or sell copies of the Software, and to -* permit persons to whom the Software is furnished to do so, subject to -* the following conditions: -* -* The above copyright notice and this permission notice shall be -* included in all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -******************************************************************************/ - -Original List Module License (list.h, list.c): ----------------------------------------------- -/* -Copyright (c) 2011 Zhehao Mao - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - - - diff --git a/code/game/g_active.c b/code/game/g_active.c index 4135f1c..102c344 100644 --- a/code/game/g_active.c +++ b/code/game/g_active.c @@ -519,13 +519,13 @@ static char *TimedMessage( void ){ } if(iterTimedMessages == NULL) { - iterTimedMessages = list_iterator(level.timedMessages, LIST_FRONT); + iterTimedMessages = list_iterator(level.timedMessages, FRONT); if(iterTimedMessages == NULL) { // something went wrong return "^1RPG-X ERROR: No messages to display"; } } - msg = (timedMessage_t *)list_cycl_next(iterTimedMessages)->data; + msg = (timedMessage_t *)list_cycl_next(iterTimedMessages); message = msg->message; return message; diff --git a/code/game/g_cmds.c b/code/game/g_cmds.c index beedfa5..849d5e2 100644 --- a/code/game/g_cmds.c +++ b/code/game/g_cmds.c @@ -7450,20 +7450,20 @@ void addShaderToList(list_p list, char *shader) { return; } - i = list_iterator(list, LIST_FRONT); + i = list_iterator(list, FRONT); if(i == NULL) { free(s->s); free(s); return; } - for(t = (rShader_s *)list_next(i)->data; t != NULL; t = (rShader_s *)list_next(i)->data) { + for(t = (rShader_s *)list_next(i); t != NULL; t = (rShader_s *)list_next(i)) { if(!strcmp(shader, t->s)) { return; } } - list_add(list, s, LT_DATA, sizeof(rShader_s)); + list_add(list, s, sizeof(rShader_s)); } extern target_alert_Shaders_s alertShaders; @@ -7519,14 +7519,14 @@ void Cmd_GeneratePrecacheFile(gentity_t *ent) { } } - iter = list_iterator(shaders, LIST_FRONT); + iter = list_iterator(shaders, FRONT); if(iter == NULL) { trap_FS_FCloseFile(f); destroy_list(shaders); return; } - for(s = (rShader_s *)list_next(iter)->data; s != NULL; s = (rShader_s *)list_next(iter)->data) { + for(s = (rShader_s *)list_next(iter); s != NULL; s = (rShader_s *)list_next(iter)) { G_Printf("\t%s\n", s->s); if(first) { trap_FS_Write("\"", 1, f); diff --git a/code/game/g_main.c b/code/game/g_main.c index 5008fc3..552fde7 100644 --- a/code/game/g_main.c +++ b/code/game/g_main.c @@ -968,7 +968,7 @@ static void G_LoadTimedMessages(void) { } msg->message = strdup(token); - list_add(level.timedMessages, msg, LT_DATA, sizeof(timedMessage_s)); + list_add(level.timedMessages, msg, sizeof(timedMessage_s)); } else { if(token[0] == '}') { break; diff --git a/code/game/list.c b/code/game/list.c index 0b12dd2..9b358e1 100644 --- a/code/game/list.c +++ b/code/game/list.c @@ -1,5 +1,5 @@ /* -Copyright (c) 2013 Ubergames +Copyright (c) 2011 Zhehao Mao Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in @@ -20,102 +20,80 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include "list.h" +#include #include -list_p create_list() { - list_p list = (list_p)malloc(sizeof(struct list)); - - if(list == NULL) { - return NULL; - } - +list_p create_list(){ + list_p list = (list_p) malloc(sizeof(struct list)); list->length = 0; list->first = NULL; list->last = NULL; list->destructor = free; - return list; } -list_iter_p list_iterator(list_p list, char init) { +list_iter_p list_iterator(list_p list, char init){ list_iter_p iter = (list_iter_p)malloc(sizeof(struct list_iter)); - - if(iter == NULL) { + if(init==FRONT){ + iter->current = list->first; + } + else if(init==BACK){ + iter->current = list->last; + } + else { + if(iter != NULL) + free(iter); return NULL; } - - if(init == LIST_FRONT) { - iter->current = list->first; - } else if(init == LIST_BACK) { - iter->current = list->last; - } else { // asume front - iter->current = list->first; - } - iter->list = list; iter->started = 0; - return iter; } -int list_add(list_p list, void* data, dataType_t type, int size) { +void list_add(list_p list, void* data, int size){ lnode_p node = (lnode_p)malloc(sizeof(struct linked_node)); + node->data = malloc(size); + memcpy(node->data, data, size); - node->cont = (container_p)(sizeof(container)); - if(node->cont == NULL) { - return 0; - } - - node->cont->data = malloc(size); - if(node->cont->data == NULL) { - return 0; - } - memcpy(node->cont->data, data, size); - - if(list->first == NULL) { + if(list->first==NULL){ node->prev = NULL; node->next = NULL; list->first = node; list->last = node; - } else { + } + else{ list->last->next = node; node->prev = list->last; node->next = NULL; list->last = node; } list->length++; - - return list->length; } -container_p list_current(list_iter_p iter){ - if(iter->started && iter->current != NULL) { - return iter->current->cont; - } - +void* list_current(list_iter_p iter){ + if(iter->started&&iter->current!=NULL) + return iter->current->data; return NULL; } -container_p list_next(list_iter_p iter) { - if(!iter->started && iter->current != NULL) { - iter->started = 1; - return iter->current->cont; +void* list_next(list_iter_p iter){ + if(!iter->started&&iter->current!=NULL){ + iter->started=1; + return iter->current->data; } - - if(iter->current != NULL) { + if(iter->current!=NULL){ iter->current = iter->current->next; return list_current(iter); } - return NULL; } -container_p list_cycl_next(list_iter_p iter) { - if(!iter->started && iter->current != NULL) { - iter->started = 1; - return iter->current->cont; +void* list_cycl_next(list_iter_p iter){ + if(!iter->started&&iter->current!=NULL){ + iter->started=1; + return iter->current->data; } - if(iter->current != NULL) { + if(iter->current!=NULL){ iter->current = iter->current->next; if(iter->current == NULL) { iter->current = iter->list->first; @@ -125,123 +103,90 @@ container_p list_cycl_next(list_iter_p iter) { return NULL; } -container_p list_prev(list_iter_p iter) { - if(!iter->started&&iter->current!=NULL) { - iter->started = 1; - return iter->current->cont; +void* list_prev(list_iter_p iter){ + if(!iter->started&&iter->current!=NULL){ + iter->started=1; + return iter->current->data; } - if(iter->current!=NULL) { + if(iter->current!=NULL){ iter->current = iter->current->prev; return list_current(iter); } return NULL; } -container_p list_cycl_prev(list_iter_p iter){ - if(!iter->started && iter->current != NULL) { - iter->started =1 ; - return iter->current->cont; +void* list_cycl_prev(list_iter_p iter){ + if(!iter->started&&iter->current!=NULL){ + iter->started=1; + return iter->current->data; } - - if(iter->current!=NULL) { + if(iter->current!=NULL){ iter->current = iter->current->prev; if(iter->current == NULL) { iter->current = iter->list->last; } return list_current(iter); } - return NULL; } -container_p list_first(list_p list) { - return list->first->cont; +void* list_first(list_p list){ + return list->first->data; } -container_p list_last(list_p list) { - return list->last->cont; +void* list_last(list_p list){ + return list->last->data; } -container_p list_pop(list_p list) { - container_p cont; +void* list_pop(list_p list){ lnode_p last = list->last; - - if(last == NULL) { - return NULL; - } - + if(last == NULL) return NULL; list->last = last->prev; - cont = last->cont; - + void* data = last->data; if(last->prev != NULL) { last->prev->next = NULL; } - free(last); list->length--; - if(list->length == 0) { list->last = list->first = NULL; } - - return cont; + return data; } -container_p list_poll(list_p list){ - container_p cont; +void* list_poll(list_p list){ lnode_p first = list->first; - - if(first == NULL) { - return NULL; - } - + if(first == NULL) return NULL; list->first = first->next; - cont = first->cont; - + void* data = first->data; if(first->next != NULL) { first->next->prev = NULL; } - free(first); list->length--; - if(list->length == 0) { list->last = list->first = NULL; } - - return cont; + return data; } -void list_remove(list_p list, char end) { - container_p cont; - void (*destructor)(void*) = list->destructor; - - if(end == LIST_FRONT) { - cont = list_poll(list); - } else if (end == LIST_BACK) { - cont = list_pop(list); - } else { - return; - } - - if(cont != NULL) { - if(cont->data != NULL) { - destructor(cont->data); - } - - free(cont); - } +void list_remove(list_p list, char end){ + void * data; + if(end == FRONT) + data = list_poll(list); + else if (end == BACK) + data = list_pop(list); + else return; + list->destructor(data); } -void destroy_list(list_p list) { +void destroy_list(list_p list){ lnode_p cur = list->first; lnode_p next; - while(cur!=NULL){ next = cur->next; if(list->destructor != NULL) { // only destroy data if there is a destructor set - list->destructor(cur->cont->data); - free(cur->cont); + list->destructor(cur->data); } free(cur); cur = next; @@ -250,10 +195,7 @@ void destroy_list(list_p list) { } void destroy_iterator(list_iter_p iter) { - if(iter == NULL) { - return; - } + if(iter == NULL) return; free(iter); } - diff --git a/code/game/list.h b/code/game/list.h index 54884a2..e055bfa 100644 --- a/code/game/list.h +++ b/code/game/list.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2013 Ubergames +Copyright (c) 2011 Zhehao Mao Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in @@ -25,37 +25,11 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* A C implementation of a doubly-linked list. Contains void pointer values. Can be used as a LIFO stack of FIFO queue. */ -#include +#define FRONT 0 +#define BACK 1 -#define LIST_FRONT 0 -#define LIST_BACK 1 - -typedef enum { - LT_BOOLEAN, - LT_CHAR, - LT_UNSIGNED_CHAR, - LT_SHORT, - LT_UNSIGNED_SHORT, - LT_INT, - LT_UNSIGNED_INT, - LT_LONG, - LT_UNSIGNED_LONG, - LT_DOUBLE, - LT_STRING, - LT_DATA, - LT_MAX -} dataType_t; - -struct container { - void* data; - size_t size; - dataType_t type; -} container; - -typedef struct container* container_p; - -struct linked_node { - container_p cont; +struct linked_node{ + void* data; struct linked_node* next; struct linked_node* prev; }; @@ -87,42 +61,41 @@ list_p create_list(void); /** * Create a list_iter object for the linked_list list. The flag init can be - * either LIST_FRONT or LIST_BACK and indicates whether to start the iterator from the first + * either FRONT or BACK and indicates whether to start the iterator from the first * or last item in the list */ list_iter_p list_iterator(list_p list, char init); /** - * Add an item with the given value, type, and size to the back of the list. + * Add an item with the given value and size to the back of the list. * The data is copied by value, so the original pointer must be freed if it * was allocated on the heap. - * Returns the length of the list if succesfull else returns 0. */ -int list_add(list_p list, void* data, dataType_t type, int size); +void list_add(list_p list, void* data, int size); /** * Gets the data stored in the first item of the list or NULL if the list is empty */ -container_p list_first(list_p list); +void* list_first(list_p list); /** * Gets the data stored in the last item of the list or NULL if the list is empty */ -container_p list_last(list_p list); +void* list_last(list_p list); /** * Removes the last item in the list (LIFO order) and returns the data stored * there. The data returned must be freed later in order to remain memory safe. */ -container_p list_pop(list_p list); +void* list_pop(list_p list); /** * Removes the first item in the list (FIFO order) and returns the data stored * there. The data return must be freed later in order to remain memory safe. */ -container_p list_poll(list_p list); +void* list_poll(list_p list); /** * Convenience function for completely destroying an item in the list. If the end - * flag is LIST_FRONT, an item will be polled from the front of the list and its data - * freed. If the end flag is set to LIST_BACK, an item will be popped off the end of + * flag is FRONT, an item will be polled from the front of the list and its data + * freed. If the end flag is set to BACK, an item will be popped off the end of * the list and the data freed. */ void list_remove(list_p list, char end); @@ -140,28 +113,28 @@ void destroy_iterator(list_iter_p iter); /** * Return the data held by the current item pointed to by the iterator */ -container_p list_current(list_iter_p list); +void* list_current(list_iter_p list); /** * Advances the iterator to the next item in the list and returns the data * stored there. */ -container_p list_next(list_iter_p list); +void* list_next(list_iter_p list); /** * Advances the iterator to the previous item in the list and returns the data * stored there. */ -container_p list_prev(list_iter_p list); +void* list_prev(list_iter_p list); /** * Advances the iterator to the next item in the list and returns the data * stored there. If the end of the list is reached it continues with the first * element of the list. */ -container_p list_cycl_next(list_iter_p list); +void* list_cycl_next(list_iter_p list); /** * Advances the iterator to the previous item in the list and returns the data * stored there. If the start of the list is reached it continues with the last * element of the list. */ -container_p list_cycl_prev(list_iter_p list); +void* list_cycl_prev(list_iter_p list); #endif \ No newline at end of file