/* Copyright (c) 2013-2014 Gustav Hartvigsson 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. */ #include "Error.h" #include #include #include #include #include "utils.h" #include "LinkedList.h" #include "DynamicArray.h" /* ************************************************************************** *********************** INTERNALS ****************************************** **************************************************************************** */ typedef struct SErrorItem { schar * message; SErrorDomain error_domain; sint error_type; } SErrorItem; struct SError { SLinkedList * error_list; /* SLinkedList */ }; typedef struct SErrorDomainItem { SErrorDomain domain; SErrorDomainToString to_string_func; schar * domain_name; } SErrorDomainItem; static SDynamicArray * _internal_s_error_domain_list = NULL; /* */ void _internal_s_error_domain_item_free (SErrorDomainItem * self); void _internal_s_error_item_free (SErrorItem * self); void _internal_s_error_list_for_each_item (SDynamicArray * in_array, SErrorItem * item, SDynamicArray * out_array); schar * s_default_error_domain_to_string (sint error_id, schar * msg) { schar * ret_val = s_string_new_fmt ("Error %d (%s): %s", error_id, s_default_error_get_name (error_id), msg); return ret_val; } schar * s_default_error_get_name (SDefaultErrorType k) { return SDefaultErrorTypeName[k]; } /* ************************************************************************** ************************** SError ****************************************** **************************************************************************** */ SError * s_error_new (void) { SError * self = s_malloc (sizeof (SError)); self->error_list = s_linked_list_new (FREEFUNC (_internal_s_error_item_free)); return self; } void s_error_append (SError * self , sint error, const char * message, SErrorDomain error_domain) { assert (self != NULL); if (error_domain < 0) { s_err_print ("Invalid ErrorDomain"); print_backtrace (); return; } SErrorItem * item = s_malloc (sizeof (SErrorItem)); item->message = s_string_new (message); item->error_type = error; item->error_domain = error_domain; s_linked_list_append (self->error_list, item); } sboolean s_error_has_error (SError * self) { if (self != NULL) { if (s_linked_list_get_current (self->error_list)) { return TRUE; } } return FALSE; } SDynamicArray * s_error_to_string_array (SError * self) { assert (self != NULL); size_t out_arr_len = s_linked_list_len (self->error_list); SDynamicArray * ret_val = s_dynamic_array_new (out_arr_len, NULL); s_linked_list_for_each (self->error_list, FOREACHFUNC(_internal_s_error_list_for_each_item), ret_val); return ret_val; } void s_error_free (SError * self) { s_linked_list_free (self->error_list, TRUE); s_free (self); } void s_error_teardown () { s_dbg_print ("Taring down error system...."); if (_internal_s_error_domain_list) { s_dynamic_array_free (_internal_s_error_domain_list, TRUE); } s_dbg_print ("Done tearing down error system."); } /* ************************************************************************** *********************** SErrorDomain *************************************** **************************************************************************** */ SErrorDomain s_error_get_domain (const schar * name, SErrorDomainToString to_string_func) { SErrorDomainItem * item = NULL; if (strlen (name) == 0 || to_string_func == NULL) { s_err_print ("Domain name or to_string_func not set.\n"); return -2; } if (!(_internal_s_error_domain_list)) { s_dbg_print ("Array does not exist, lets create it!"); _internal_s_error_domain_list = s_dynamic_array_new (S_ERROR_DOMAIN_RANGE_MAX, FREEFUNC (_internal_s_error_domain_item_free)); // The default key is always 0 item = s_malloc (sizeof (SErrorDomainItem)); item->domain = 0; item->to_string_func = s_default_error_domain_to_string; item->domain_name = s_string_new ("default"); s_dynamic_array_set (_internal_s_error_domain_list, 0, item); } if (s_string_is_equal (name, "default")) { if (to_string_func != s_default_error_domain_to_string) { s_err_print ("Trying to override the default error domain to string " "callback.\n" "This is not allowed! \n"); return -1; } return 0; } /* We hash the domain name and see it the domain exists. */ SErrorDomain domain = s_hash (name) % S_ERROR_DOMAIN_RANGE_MAX; SErrorDomainItem * item_2 = (SErrorDomainItem *) s_dynamic_array_get (_internal_s_error_domain_list, domain); if ((item_2) == NULL) { /* * The item dose not exist in the array, lets just add it. */ item = s_malloc (sizeof (SErrorDomainItem)); item->domain = domain; item->to_string_func = to_string_func; item->domain_name = s_string_new (name); s_dynamic_array_set (_internal_s_error_domain_list ,domain, item); return domain; } else { /* We got something. See it it is correct */ if (s_string_is_equal(item_2->domain_name, name)) { if (item_2->to_string_func != to_string_func) { s_err_print ("Trying to overwrite the to string handler" "for error domain %s, this is not allowd.", name); return -1; } return domain; } /* * We must now check each item untill we reach a NULL. */ for (sint i = domain; i <= s_dynamic_array_size (_internal_s_error_domain_list); i++) { item_2 = (SErrorDomainItem *) s_dynamic_array_get (_internal_s_error_domain_list, i); if ((item_2) == NULL) { break; // This jumps out of the loop and to the for-loop below. } else { if (s_string_is_equal (item_2->domain_name, name)) { if (item_2->to_string_func != to_string_func) { s_err_print ("Trying to override to string function for error " "domain %s.\nThis is not allowed!\n", name); return -1; } else { return i; } } } } } /* * The error domain does not exist. */ for (/* domain */; domain <= s_dynamic_array_size (_internal_s_error_domain_list) + 1; domain++) { if (!(s_dynamic_array_get(_internal_s_error_domain_list ,domain))) { item = s_malloc (sizeof (SErrorDomainItem)); item->domain = domain; item->domain_name = s_string_new (name); item->to_string_func = to_string_func; return domain; } } s_err_print ("Reaching a place where it should not reach. This is a sign " "that the devil has been messing with time and space.\n"); print_backtrace (); return -666; } /* ************************************************************************** *********************** INTERNALS ****************************************** **************************************************************************** */ void _internal_s_error_domain_item_free (SErrorDomainItem * self) { s_dbg_print ("(SErrorDomainItem) Freeing: %d, %s", self->domain, self->domain_name); s_free (self->domain_name); s_free (self); } void _internal_s_error_list_for_each_item (SDynamicArray * in_array, SErrorItem * item, SDynamicArray * out_array) { SErrorDomainItem * domain_item = s_dynamic_array_get ( _internal_s_error_domain_list, item->error_domain); SErrorDomainToString to_string_func = domain_item->to_string_func; s_dynamic_array_append (out_array, to_string_func (item->error_type, item->message)); } void _internal_s_error_item_free (SErrorItem * self) { s_dbg_print ("Running free on errori item!"); s_free (self->message); s_free (self); }