caskd
/
uIRC
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Merge allocator and free functions

This commit is contained in:
Alex D. 2021-03-11 22:33:08 +00:00
parent 7b7cd1b7cc
commit b8f3d13e9c
Signed by: caskd
GPG Key ID: F92BA85F61F4C173
15 changed files with 270 additions and 509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
CMakeLists.txt
View File

@ -23,9 +23,8 @@ set(UIRC_SOURCE
src/assemblers/user.c
src/tokenizers/message.c
src/tokenizers/user.c
src/memory/allocators.c
src/memory/free.c
src/memory/listmgrs.c
src/memory/struct.c
src/memory/list.c
)
set(UIRC_HEADERS
@ -90,11 +89,6 @@ if (BUILD_TESTS)
message(STATUS "Tests are going to be built.")
add_subdirectory(tests)
enable_testing()
add_test(NAME "FullLoop" COMMAND "fullloop")
add_test(NAME "EarlyTrail" COMMAND "earlytrail")
add_test(NAME "OptCRLF" COMMAND "optcrlf")
add_test(NAME "ManualAssemblers" COMMAND "manassm")
add_test(NAME "Allocators" COMMAND "allocs")
endif()
add_library(uirc ${UIRC_SOURCE})

34
include/memory.h
View File

@ -18,38 +18,16 @@
/*! \file */
#include "types.h" // IRC_Tag IRC_User IRC_Message
#include "types.h" // IRC_*
#include <stddef.h> // ptrdiff_t
#ifndef UIRC_GUARD_PUBLIC_MEMORY
#define UIRC_GUARD_PUBLIC_MEMORY
#ifdef UIRC_FEATURE_IRCV3
IRC_Tag* uirc_malloc_tag(const char* key, const char* value);
IRC_Capability* uirc_malloc_capability(const char* name);
#endif /* UIRC_FEATURE_IRCV3 */
IRC_User* uirc_malloc_user(const char* nick, const char* user, const char* real, const char* host);
IRC_Message* uirc_malloc_message(const char* command, int argc, ...);
IRC_Buffer* uirc_malloc_buffer(const char* name, const char* topic, const char* key);
IRC_Network* uirc_malloc_network(const char* addr, const char* svc, const char* pass);
bool uirc_list_add_buffer(IRC_Network* net, IRC_Buffer* buf);
bool uirc_list_add_user(IRC_Buffer* buf, IRC_User* usr);
bool uirc_list_add_message(IRC_Buffer* buf, IRC_Message* msg);
bool uirc_list_add_tag(IRC_Message* msg, IRC_Tag* tag);
bool uirc_list_remove_buffer(IRC_Network* net, IRC_Buffer* buf);
bool uirc_list_remove_user(IRC_Buffer* buf, IRC_User* usr);
bool uirc_list_remove_message(IRC_Buffer* buf, IRC_Message* msg);
bool uirc_list_remove_tag(IRC_Message* msg, IRC_Tag* tag);
#ifdef UIRC_FEATURE_IRCV3
void uirc_free_tag(IRC_Tag* t);
void uirc_free_capability(IRC_Capability* c);
#endif /* UIRC_FEATURE_IRCV3 */
void uirc_free_user(IRC_User* u);
void uirc_free_message(IRC_Message* m);
void uirc_free_buffer(IRC_Buffer* b);
void uirc_free_network(IRC_Network* n);
void* uirc_struct_malloc(const void* src, IRC_Struct_Type type);
void uirc_struct_free(void* obj, IRC_Struct_Type type);
ptrdiff_t uirc_list_free(llist_t* list, IRC_Struct_Type type);
#endif /* UIRC_GUARD_PUBLIC_MEMORY */

24
include/types.h
View File

@ -25,8 +25,6 @@
#ifndef UIRC_GUARD_PUBLIC_TYPES
#define UIRC_GUARD_PUBLIC_TYPES
enum IRC_Buffer_Types { IRC_DIRECT, IRC_CHANNEL, IRC_GLOBAL };
typedef unsigned short IRC_Modes;
typedef uintmax_t IRC_Counter;
@ -60,12 +58,13 @@ typedef struct {
#endif /* UIRC_FEATURE_IRCV3 */
} IRC_Message;
typedef enum { IRC_DIRECT, IRC_CHANNEL, IRC_GLOBAL } IRC_Buffer_Type;
typedef struct {
enum IRC_Buffer_Types type;
char * name, *topic, *key;
bool subscribed;
IRC_Modes modes;
llist_t * user_list, *message_list;
IRC_Buffer_Type type;
char * name, *topic, *key;
bool subscribed;
IRC_Modes modes;
llist_t * user_list, *message_list;
} IRC_Buffer;
typedef struct {
@ -77,5 +76,16 @@ typedef struct {
#endif /* UIRC_FEATURE_IRCV3 */
} IRC_Network;
typedef enum {
#ifdef UIRC_FEATURE_IRCV3
IRC_STRUCT_TAG,
IRC_STRUCT_CAPABILITY,
#endif /* UIRC_FEATURE_IRCV3 */
IRC_STRUCT_USER,
IRC_STRUCT_MESSAGE,
IRC_STRUCT_BUFFER,
IRC_STRUCT_NETWORK
} IRC_Struct_Type;
#endif /* UIRC_GUARD_PUBLIC_TYPES */

182
src/memory/allocators.c
View File

@ -1,182 +0,0 @@
/*
* This file is part of uIRC. (https://git.redxen.eu/caskd/uIRC)
* Copyright (c) 2019, 2020 Alex-David Denes
*
* uIRC is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* uIRC is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with uIRC. If not, see <https://www.gnu.org/licenses/>.
*/
#include "memory.h"
#include "types.h" // IRC_*
#include <assert.h> // assert()
#include <corelibs/stringext.h> // malloc_string()
#include <stdarg.h> // va_*() va_list
#include <stdlib.h> // free()
#include <string.h> // strcpy()
IRC_Tag*
uirc_malloc_tag(const char* key, const char* value)
{
IRC_Tag* ret;
assert(key != NULL);
if ((ret = malloc(sizeof(IRC_Tag))) != NULL) {
memset(ret, 0, sizeof(IRC_Tag));
if ((ret->key = malloc_string(key, strlen(key))) == NULL) {
uirc_free_tag(ret);
return NULL;
}
if (value != NULL) {
if ((ret->value = malloc_string(value, strlen(value))) == NULL) {
uirc_free_tag(ret);
return NULL;
}
}
return ret;
}
return NULL;
}
IRC_Capability*
uirc_malloc_capability(const char* name)
{
IRC_Capability* ret;
assert(name != NULL);
if ((ret = malloc(sizeof(IRC_Capability))) != NULL) {
memset(ret, 0, sizeof(IRC_Capability));
if ((ret->name = malloc_string(name, strlen(name))) == NULL) {
uirc_free_capability(ret);
return NULL;
}
return ret;
}
return NULL;
}
IRC_User*
uirc_malloc_user(const char* nick, const char* user, const char* real, const char* host)
{
IRC_User* ret;
if ((ret = malloc(sizeof(IRC_User))) != NULL) {
memset(ret, 0, sizeof(IRC_User));
if (nick != NULL) {
if ((ret->nick = malloc_string(nick, strlen(nick))) == NULL) {
uirc_free_user(ret);
return NULL;
}
}
if (user != NULL) {
if ((ret->user = malloc_string(user, strlen(user))) == NULL) {
uirc_free_user(ret);
return NULL;
}
}
if (real != NULL) {
if ((ret->real = malloc_string(real, strlen(real))) == NULL) {
uirc_free_user(ret);
return NULL;
}
}
if (host != NULL) {
if ((ret->host = malloc_string(host, strlen(host))) == NULL) {
uirc_free_user(ret);
return NULL;
}
}
return ret;
}
return NULL;
}
IRC_Message*
uirc_malloc_message(const char* command, int argc, ...)
{
IRC_Message* ret;
assert(command != NULL);
if ((ret = malloc(sizeof(IRC_Message))) != NULL) {
memset(ret, 0, sizeof(IRC_Message));
if ((ret->command = malloc_string(command, strlen(command))) == NULL) {
uirc_free_message(ret);
return NULL;
}
} else
return NULL;
va_list ap;
va_start(ap, argc);
for (unsigned short i = 0; i < IRC_MAXARGS && i < argc; i++) {
const char* carg = va_arg(ap, const char*);
if ((ret->args[i] = malloc_string(carg, strlen(carg))) == NULL) {
uirc_free_message(ret);
ret = NULL;
}
}
va_end(ap);
return ret;
}
IRC_Buffer*
uirc_malloc_buffer(const char* name, const char* topic, const char* key)
{
IRC_Buffer* ret;
assert(name != NULL);
if ((ret = malloc(sizeof(IRC_Buffer))) != NULL) {
memset(ret, 0, sizeof(IRC_Buffer));
if ((ret->name = malloc_string(name, strlen(name))) == NULL) {
uirc_free_buffer(ret);
return NULL;
}
if (topic != NULL) {
if ((ret->topic = malloc_string(topic, strlen(topic))) == NULL) {
uirc_free_buffer(ret);
return NULL;
}
}
if (key != NULL) {
if ((ret->key = malloc_string(key, strlen(key))) == NULL) {
uirc_free_buffer(ret);
return NULL;
}
}
return ret;
}
return NULL;
}
IRC_Network*
uirc_malloc_network(const char* addr, const char* svc, const char* pass)
{
IRC_Network* ret;
assert(addr != NULL);
assert(svc != NULL);
if ((ret = malloc(sizeof(IRC_Network))) != NULL) {
memset(ret, 0, sizeof(IRC_Network));
if ((ret->addr = malloc_string(addr, strlen(addr))) == NULL) {
uirc_free_network(ret);
return NULL;
}
if ((ret->svc = malloc_string(svc, strlen(svc))) == NULL) {
uirc_free_network(ret);
return NULL;
}
if (pass != NULL) {
if ((ret->pass = malloc_string(pass, strlen(svc))) == NULL) {
uirc_free_network(ret);
return NULL;
}
}
return ret;
}
return NULL;
}

122
src/memory/free.c
View File

@ -1,122 +0,0 @@
/*
* This file is part of uIRC. (https://git.redxen.eu/caskd/uIRC)
* Copyright (c) 2019, 2020 Alex-David Denes
*
* uIRC is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* uIRC is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with uIRC. If not, see <https://www.gnu.org/licenses/>.
*/
#include "memory.h"
#include "types.h" // IRC_*
#include <assert.h> // assert()
#include <corelibs/llist.h> // llist_t remove_linked_list_elem()
#include <corelibs/stringext.h> // malloc_string()
#include <stdlib.h> // free()
#include <string.h> // strcpy()
#ifdef UIRC_FEATURE_IRCV3
void
uirc_free_tag(IRC_Tag* t)
{
assert(t != NULL);
free(t->key);
free(t->value);
}
void
uirc_free_capability(IRC_Capability* c)
{
assert(c != NULL);
free(c->name);
}
#endif /* UIRC_FEATURE_IRCV3 */
void
uirc_free_user(IRC_User* u)
{
assert(u != NULL);
free(u->user);
free(u->nick);
free(u->host);
free(u->real);
}
void
uirc_free_message(IRC_Message* m)
{
assert(m != NULL);
if (m->source != NULL) {
uirc_free_user(m->source);
free(m->source);
}
free(m->command);
for (unsigned short i = 0; i < IRC_MAXARGS && m->args[i] != NULL; i++) free(m->args[i]);
#ifdef UIRC_FEATURE_IRCV3
for (llist_t* t = m->tag_list; t != NULL; t = t->next) {
uirc_free_tag(t->content);
remove_linked_list_elem(t);
}
#endif /* UIRC_FEATURE_IRCV3 */
}
void
uirc_free_buffer(IRC_Buffer* b)
{
assert(b != NULL);
free(b->name);
free(b->topic);
free(b->key);
for (llist_t* t = b->user_list; t != NULL; t = t->next) {
uirc_free_user(t->content);
remove_linked_list_elem(t);
}
for (llist_t* t = b->message_list; t != NULL; t = t->next) {
uirc_free_message(t->content);
remove_linked_list_elem(t);
}
}
void
uirc_free_network(IRC_Network* n)
{
assert(n != NULL);
free(n->addr);
free(n->svc);
free(n->pass);
if (n->user != NULL) {
uirc_free_user(n->user);
free(n->user);
}
for (llist_t* t = n->buf_list; t != NULL; t = t->next) {
uirc_free_buffer(t->content);
remove_linked_list_elem(t);
}
#ifdef UIRC_FEATURE_IRCV3
for (llist_t* t = n->cap_list; t != NULL; t = t->next) {
uirc_free_capability(t->content);
remove_linked_list_elem(t);
}
#endif /* UIRC_FEATURE_IRCV3 */
}

38
src/memory/list.c Normal file
View File

@ -0,0 +1,38 @@
/*
* This file is part of uIRC. (https://git.redxen.eu/caskd/uIRC)
* Copyright (c) 2019, 2020 Alex-David Denes
*
* uIRC is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* uIRC is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with uIRC. If not, see <https://www.gnu.org/licenses/>.
*/
#include "memory.h"
#include "types.h" // IRC_*
#include <assert.h> // assert()
#include <stddef.h> // ptrdiff_t
#include <stdlib.h> // free()
ptrdiff_t
uirc_list_free(llist_t* list, IRC_Struct_Type type)
{
assert(list != NULL);
ptrdiff_t cnt = 0;
for (; list != NULL; cnt++) {
llist_t* const save = list;
list = list->next;
uirc_struct_free(save->content, type);
remove_linked_list_elem(save);
}
return cnt;
}

151
src/memory/listmgrs.c
View File

@ -1,151 +0,0 @@
/*
* This file is part of uIRC. (https://git.redxen.eu/caskd/uIRC)
* Copyright (c) 2019, 2020 Alex-David Denes
*
* uIRC is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* uIRC is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with uIRC. If not, see <https://www.gnu.org/licenses/>.
*/
#include "memory.h"
#include "types.h" // IRC_*
#include <assert.h> // assert()
#include <corelibs/llist.h> // llist_t remove_linked_list_elem()
#include <stdbool.h> // bool
#include <stdlib.h> // free()
// NOTE: yes, i know these repeat a FUCKTON, need to find a way to use the preprocessor to merge them or create a generalized function
bool
uirc_list_add_message(IRC_Buffer* buf, IRC_Message* msg)
{
assert(buf != NULL);
if (msg == NULL) return 0;
llist_t* tmp = NULL;
if ((tmp = allocate_linked_list_elem(0)) == NULL) return 0;
if (buf->message_list != NULL) connect_linked_list_elem(buf->message_list, tmp);
else
buf->message_list = tmp;
tmp->content = buf;
return 1;
}
bool
uirc_list_add_buffer(IRC_Network* net, IRC_Buffer* buf)
{
assert(net != NULL);
if (buf == NULL) return 0;
llist_t* tmp = NULL;
if ((tmp = allocate_linked_list_elem(0)) == NULL) return 0;
if (net->buf_list != NULL) connect_linked_list_elem(net->buf_list, tmp);
else
net->buf_list = tmp;
tmp->content = buf;
return 1;
}
bool
uirc_list_add_user(IRC_Buffer* buf, IRC_User* usr)
{
assert(buf != NULL);
if (usr == NULL) return 0;
llist_t* tmp = NULL;
if ((tmp = allocate_linked_list_elem(0)) == NULL) return 0;
if (buf->user_list != NULL) connect_linked_list_elem(buf->user_list, tmp);
else
buf->user_list = tmp;
tmp->content = usr;
return 1;
}
bool
uirc_list_add_tag(IRC_Message* msg, IRC_Tag* tag)
{
assert(msg != NULL);
if (tag == NULL) return 0;
llist_t* tmp = NULL;
if ((tmp = allocate_linked_list_elem(0)) == NULL) return 0;
if (msg->tag_list != NULL) connect_linked_list_elem(msg->tag_list, tmp);
else
msg->tag_list = tmp;
tmp->content = tag;
return 1;
}
bool
uirc_list_remove_buffer(IRC_Network* net, IRC_Buffer* buf)
{
assert(net != NULL);
assert(buf != NULL);
for (llist_t* cur = net->buf_list; cur != NULL;) {
if (cur->content == buf) {
if (cur == net->buf_list) net->buf_list = (cur->prev != NULL) ? cur->prev : cur->next;
uirc_free_buffer(buf);
remove_linked_list_elem(cur);
break;
}
if ((cur = cur->next) == NULL) return 0;
}
return 1;
}
bool
uirc_list_remove_user(IRC_Buffer* buf, IRC_User* usr)
{
assert(buf != NULL);
assert(usr != NULL);
for (llist_t* cur = buf->user_list; cur != NULL;) {
if (cur->content == usr) {
if (cur == buf->user_list) buf->user_list = (cur->prev != NULL) ? cur->prev : cur->next;
uirc_free_user(usr);
remove_linked_list_elem(cur);
break;
}
if ((cur = cur->next) == NULL) return 0;
}
return 1;
}
bool
uirc_list_remove_message(IRC_Buffer* buf, IRC_Message* msg)
{
assert(buf != NULL);
assert(msg != NULL);
for (llist_t* cur = buf->user_list; cur != NULL;) {
if (cur->content == msg) {
if (cur == buf->user_list) buf->user_list = (cur->prev != NULL) ? cur->prev : cur->next;
uirc_free_message(msg);
remove_linked_list_elem(cur);
break;
}
if ((cur = cur->next) == NULL) return 0;
}
return 1;
}
bool
uirc_list_remove_tag(IRC_Message* msg, IRC_Tag* tag)
{
assert(msg != NULL);
assert(tag != NULL);
for (llist_t* cur = msg->tag_list; cur != NULL;) {
if (cur->content == tag) {
if (cur == msg->tag_list) msg->tag_list = (cur->prev != NULL) ? cur->prev : cur->next;
uirc_free_tag(tag);
remove_linked_list_elem(cur);
break;
}
if ((cur = cur->next) == NULL) return 0;
}
return 1;
}

191
src/memory/struct.c Normal file
View File

@ -0,0 +1,191 @@
/*
* This file is part of uIRC. (https://git.redxen.eu/caskd/uIRC)
* Copyright (c) 2019, 2020 Alex-David Denes
*
* uIRC is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* uIRC is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with uIRC. If not, see <https://www.gnu.org/licenses/>.
*/
#include "memory.h"
#include "types.h" // IRC_*
#include <assert.h> // assert()
#include <corelibs/stringext.h> // malloc_string()
#include <stdlib.h> // free()
#include <string.h> // strlen()
void*
uirc_struct_malloc(const void* src, IRC_Struct_Type type)
{
assert(src != NULL);
void* ret = NULL;
size_t structsize = 0;
switch (type) {
#ifdef UIRC_FEATURE_IRCV3
case IRC_STRUCT_TAG: structsize = sizeof(IRC_Tag); break;
case IRC_STRUCT_CAPABILITY: structsize = sizeof(IRC_Capability); break;
#endif /* UIRC_FEATURE_IRCV3 */
case IRC_STRUCT_USER: structsize = sizeof(IRC_User); break;
case IRC_STRUCT_MESSAGE: structsize = sizeof(IRC_Message); break;
case IRC_STRUCT_BUFFER: structsize = sizeof(IRC_Buffer); break;
case IRC_STRUCT_NETWORK: structsize = sizeof(IRC_Network); break;
}
if ((ret = malloc(structsize)) == NULL) return NULL;
memset(ret, 0, structsize);
switch (type) {
#ifdef UIRC_FEATURE_IRCV3
case IRC_STRUCT_TAG: {
IRC_Tag* c_ret = ret;
const IRC_Tag* c_src = src;
c_ret->clientbound = c_src->clientbound;
if (((c_ret->key = malloc_string(c_src->key, strlen(c_src->key))) == NULL)
|| (c_src->value != NULL && (c_ret->value = malloc_string(c_src->value, strlen(c_src->value))) == NULL))
break;
return ret;
}
case IRC_STRUCT_CAPABILITY: {
IRC_Capability* c_ret = ret;
const IRC_Capability* c_src = src;
c_ret->active = c_src->active;
if ((c_ret->name = malloc_string(c_src->name, strlen(c_src->name))) == NULL) break;
return ret;
}
#endif /* UIRC_FEATURE_IRCV3 */
case IRC_STRUCT_USER: {
IRC_User* c_ret = ret;
const IRC_User* c_src = src;
c_ret->modes = c_src->modes;
c_ret->is_service = c_src->is_service;
if ((c_src->nick != NULL && (c_ret->nick = malloc_string(c_src->nick, strlen(c_src->nick))) == NULL)
|| (c_src->user != NULL && (c_ret->user = malloc_string(c_src->user, strlen(c_src->user))) == NULL)
|| (c_src->real != NULL && (c_ret->real = malloc_string(c_src->real, strlen(c_src->real))) == NULL)
|| (c_src->host != NULL && (c_ret->host = malloc_string(c_src->host, strlen(c_src->host))) == NULL))
break;
return ret;
}
case IRC_STRUCT_MESSAGE: {
IRC_Message* c_ret = ret;
const IRC_Message* c_src = src;
c_ret->trailing = c_src->trailing;
if ((c_ret->command = malloc_string(c_src->command, strlen(c_src->command))) == NULL) break;
for (unsigned short i = 0; i < IRC_MAXARGS && c_src->args[i] != NULL; i++)
if ((c_ret->args[i] = malloc_string(c_src->args[i], strlen(c_src->args[i]))) == NULL) break;
return ret;
}
case IRC_STRUCT_BUFFER: {
IRC_Buffer* c_ret = ret;
const IRC_Buffer* c_src = src;
c_ret->modes = c_src->modes;
c_ret->subscribed = c_src->subscribed;
if ((c_ret->name = malloc_string(c_src->name, strlen(c_src->name))) == NULL
|| (c_src->topic != NULL && (c_ret->topic = malloc_string(c_src->topic, strlen(c_src->topic))) == NULL)
|| (c_src->key != NULL && (c_ret->key = malloc_string(c_src->key, strlen(c_src->key))) == NULL))
break;
return ret;
}
case IRC_STRUCT_NETWORK: {
IRC_Network* c_ret = ret;
const IRC_Network* c_src = src;
if ((c_ret->addr = malloc_string(c_src->addr, strlen(c_src->addr))) == NULL
|| (c_src->svc != NULL && (c_ret->svc = malloc_string(c_src->svc, strlen(c_src->svc))) == NULL)
|| (c_src->pass != NULL && (c_ret->pass = malloc_string(c_src->pass, strlen(c_src->pass))) == NULL))
break;
return ret;
}
}
uirc_struct_free(ret, type);
free(ret);
return NULL;
}
void
uirc_struct_free(void* obj, IRC_Struct_Type type)
{
assert(obj != NULL);
switch (type) {
#ifdef UIRC_FEATURE_IRCV3
case IRC_STRUCT_TAG: {
IRC_Tag* tmpob = obj;
free(tmpob->key);
free(tmpob->value);
break;
}
case IRC_STRUCT_CAPABILITY: {
IRC_Capability* tmpob = obj;
free(tmpob->name);
break;
}
#endif /* UIRC_FEATURE_IRCV3 */
case IRC_STRUCT_USER: {
IRC_User* tmpob = obj;
free(tmpob->nick);
free(tmpob->user);
free(tmpob->real);
free(tmpob->host);
break;
}
case IRC_STRUCT_MESSAGE: {
IRC_Message* tmpob = obj;
free(tmpob->command);
if (tmpob->source != NULL) {
uirc_struct_free(tmpob->source, IRC_STRUCT_USER);
free(tmpob->source);
}
#ifdef UIRC_FEATURE_IRCV3
if (tmpob->tag_list != NULL) uirc_list_free(tmpob->tag_list, IRC_STRUCT_TAG);
#endif /* UIRC_FEATURE_IRCV3 */
for (unsigned short i = 0; i < IRC_MAXARGS && tmpob->args[i] != NULL; i++) free(tmpob->args[i]);
break;
}
case IRC_STRUCT_BUFFER: {
IRC_Buffer* tmpob = obj;
free(tmpob->name);
free(tmpob->key);
free(tmpob->topic);
if (tmpob->message_list != NULL) uirc_list_free(tmpob->message_list, IRC_STRUCT_MESSAGE);
if (tmpob->user_list != NULL) uirc_list_free(tmpob->user_list, IRC_STRUCT_USER);
break;
}
case IRC_STRUCT_NETWORK: {
IRC_Network* tmpob = obj;
free(tmpob->addr);
free(tmpob->svc);
free(tmpob->pass);
if (tmpob->user != NULL) {
uirc_struct_free(tmpob->user, IRC_STRUCT_USER);
free(tmpob->user);
}
#ifdef UIRC_FEATURE_IRCV3
if (tmpob->cap_list != NULL) uirc_list_free(tmpob->cap_list, IRC_STRUCT_CAPABILITY);
#endif /* UIRC_FEATURE_IRCV3 */
if (tmpob->buf_list != NULL) uirc_list_free(tmpob->buf_list, IRC_STRUCT_BUFFER);
break;
}
}
}

2
src/tokenizers/message.c
View File

@ -122,7 +122,7 @@ uirc_tokenizer_message(const char* str)
static void
free_ctx(IRC_Message* msg, char* str)
{
uirc_free_message(msg);
uirc_struct_free(msg, IRC_STRUCT_MESSAGE);
free(msg);
free(str);
}

4
src/tokenizers/tag.c
View File

@ -104,10 +104,10 @@ free_ctx(llist_t* list, IRC_Tag* t, char* s)
for (llist_t* c = list; c != NULL;) {
llist_t* l = c;
c = c->next;
if (l->content != NULL) uirc_free_tag(l->content);
if (l->content != NULL) uirc_struct_free(l->content, IRC_STRUCT_TAG);
remove_linked_list_elem(l);
}
uirc_free_tag(t);
uirc_struct_free(t, IRC_STRUCT_TAG);
free(t);
free(s);
}

2
src/tokenizers/user.c
View File

@ -71,7 +71,7 @@ uirc_tokenizer_user(const char* str)
static void
free_ctx(IRC_User* u, char* s)
{
uirc_free_user(u);
uirc_struct_free(u, IRC_STRUCT_USER);
free(u);
free(s);
}

13
tests/CMakeLists.txt
View File

@ -4,15 +4,20 @@ include_directories(${uIRC_SOURCE_DIR}/include)
add_executable(fullloop fullloop.c common.c)
target_link_libraries(fullloop uirc)
add_test(NAME "FullLoop" COMMAND "fullloop")
add_executable(earlytrail earlytrail.c common.c)
target_link_libraries(earlytrail uirc)
add_test(NAME "EarlyTrail" COMMAND "earlytrail")
add_executable(optcrlf optcrlf.c common.c)
target_link_libraries(optcrlf uirc)
add_test(NAME "OptCRLF" COMMAND "optcrlf")
add_executable(manassm manassm.c common.c)
target_link_libraries(manassm uirc)
#add_executable(manassm manassm.c common.c)
#target_link_libraries(manassm uirc)
#add_test(NAME "ManualAssemblers" COMMAND "manassm")
add_executable(allocs allocs.c common.c)
target_link_libraries(allocs uirc)
#add_executable(allocs allocs.c common.c)
#target_link_libraries(allocs uirc)
#add_test(NAME "Allocators" COMMAND "allocs")

2
tests/earlytrail.c
View File

@ -39,7 +39,7 @@ main(void)
fprintf(stderr, "Trailing was parsed incorrectly, got %s instead of %s\n", m->args[IRC_MAXARGS - 1], TRAILING);
return EXIT_FAILURE;
}
uirc_free_message(m);
uirc_struct_free(m, IRC_STRUCT_MESSAGE);
free(m);
return EXIT_SUCCESS;

2
tests/fullloop.c
View File

@ -53,7 +53,7 @@ main(void)
return EXIT_FAILURE;
}
expect(buf, str[i]);
uirc_free_message(m);
uirc_struct_free(m, IRC_STRUCT_MESSAGE);
free(m);
}

2
tests/optcrlf.c
View File

@ -37,7 +37,7 @@ main(void)
return EXIT_FAILURE;
}
print_irc_message(m);
uirc_free_message(m);
uirc_struct_free(m, IRC_STRUCT_MESSAGE);
free(m);
return EXIT_SUCCESS;