From ed78539978b2b76657c71a28b6378c2bfee53cec Mon Sep 17 00:00:00 2001 From: Marko Lindqvist Date: Mon, 13 Feb 2023 03:06:51 +0200 Subject: [PATCH 34/34] Rename freeciv mutex functions to use fc_mutex_ -namespace See osdn #45995 Signed-off-by: Marko Lindqvist --- ai/tex/texaiplayer.c | 20 ++++++++-------- client/chatline_common.c | 8 +++---- client/gui-gtk-3.22/pages.c | 9 ++++---- client/gui-gtk-4.0/pages.c | 8 +++---- client/gui-qt/pages.cpp | 8 +++---- client/gui-sdl2/connectdlg.c | 6 ++--- client/servers.c | 44 ++++++++++++++++++------------------ server/citytools.c | 10 ++++---- server/srv_main.c | 12 +++++----- utility/fcthread.c | 24 ++++++++++---------- utility/fcthread.h | 8 +++---- utility/genlist.c | 8 +++---- utility/log.c | 26 ++++++++++----------- utility/support.c | 35 ++++++++++++++-------------- 14 files changed, 114 insertions(+), 112 deletions(-) diff --git a/ai/tex/texaiplayer.c b/ai/tex/texaiplayer.c index 4135756e29..cb967f3a5e 100644 --- a/ai/tex/texaiplayer.c +++ b/ai/tex/texaiplayer.c @@ -93,7 +93,7 @@ static void texai_thread_start(void *arg) } /* Just wait until we are signaled to shutdown */ - fc_allocate_mutex(&exthrai.msgs_to.mutex); + fc_mutex_allocate(&exthrai.msgs_to.mutex); while (!finished) { fc_thread_cond_wait(&exthrai.msgs_to.thr_cond, &exthrai.msgs_to.mutex); @@ -101,7 +101,7 @@ static void texai_thread_start(void *arg) finished = TRUE; } } - fc_release_mutex(&exthrai.msgs_to.mutex); + fc_mutex_release(&exthrai.msgs_to.mutex); texai_world_close(); @@ -180,7 +180,7 @@ static enum texai_abort_msg_class texai_check_messages(struct ai_type *ait) switch (msg->type) { case TEXAI_MSG_FIRST_ACTIVITIES: - fc_allocate_mutex(&game.server.mutexes.city_list); + fc_mutex_allocate(&game.server.mutexes.city_list); initialize_infrastructure_cache(msg->plr); @@ -206,16 +206,16 @@ static enum texai_abort_msg_class texai_check_messages(struct ai_type *ait) /* Release mutex for a second in case main thread * wants to do something to city list. */ - fc_release_mutex(&game.server.mutexes.city_list); + fc_mutex_release(&game.server.mutexes.city_list); /* Recursive message check in case phase is finished. */ new_abort = texai_check_messages(ait); - fc_allocate_mutex(&game.server.mutexes.city_list); + fc_mutex_allocate(&game.server.mutexes.city_list); if (new_abort < TEXAI_ABORT_NONE) { break; } } city_list_iterate_safe_end; - fc_release_mutex(&game.server.mutexes.city_list); + fc_mutex_release(&game.server.mutexes.city_list); texai_send_req(TEXAI_REQ_TURN_DONE, msg->plr, NULL); @@ -320,7 +320,7 @@ void texai_control_gained(struct ai_type *ait, struct player *pplayer) exthrai.thread_running = TRUE; fc_thread_cond_init(&exthrai.msgs_to.thr_cond); - fc_init_mutex(&exthrai.msgs_to.mutex); + fc_mutex_init(&exthrai.msgs_to.mutex); fc_thread_start(&exthrai.ait, texai_thread_start, ait); players_iterate(oplayer) { @@ -351,7 +351,7 @@ void texai_control_lost(struct ai_type *ait, struct player *pplayer) exthrai.thread_running = FALSE; fc_thread_cond_destroy(&exthrai.msgs_to.thr_cond); - fc_destroy_mutex(&exthrai.msgs_to.mutex); + fc_mutex_destroy(&exthrai.msgs_to.mutex); texaimsg_list_destroy(exthrai.msgs_to.msglist); texaireq_list_destroy(exthrai.reqs_from.reqlist); } @@ -410,10 +410,10 @@ void texai_refresh(struct ai_type *ait, struct player *pplayer) **************************************************************************/ void texai_msg_to_thr(struct texai_msg *msg) { - fc_allocate_mutex(&exthrai.msgs_to.mutex); + fc_mutex_allocate(&exthrai.msgs_to.mutex); texaimsg_list_append(exthrai.msgs_to.msglist, msg); fc_thread_cond_signal(&exthrai.msgs_to.thr_cond); - fc_release_mutex(&exthrai.msgs_to.mutex); + fc_mutex_release(&exthrai.msgs_to.mutex); } /**********************************************************************//** diff --git a/client/chatline_common.c b/client/chatline_common.c index 8ff5bfe2df..5008175b88 100644 --- a/client/chatline_common.c +++ b/client/chatline_common.c @@ -70,7 +70,7 @@ int send_chat_printf(const char *format, ...) **************************************************************************/ void fc_allocate_ow_mutex(void) { - fc_allocate_mutex(&ow_mutex); + fc_mutex_allocate(&ow_mutex); } /**********************************************************************//** @@ -78,7 +78,7 @@ void fc_allocate_ow_mutex(void) **************************************************************************/ void fc_release_ow_mutex(void) { - fc_release_mutex(&ow_mutex); + fc_mutex_release(&ow_mutex); } /**********************************************************************//** @@ -86,7 +86,7 @@ void fc_release_ow_mutex(void) **************************************************************************/ void fc_init_ow_mutex(void) { - fc_init_mutex(&ow_mutex); + fc_mutex_init(&ow_mutex); } /**********************************************************************//** @@ -94,7 +94,7 @@ void fc_init_ow_mutex(void) **************************************************************************/ void fc_destroy_ow_mutex(void) { - fc_destroy_mutex(&ow_mutex); + fc_mutex_destroy(&ow_mutex); } /**********************************************************************//** diff --git a/client/gui-gtk-3.22/pages.c b/client/gui-gtk-3.22/pages.c index 1e6581c90c..47d7181256 100644 --- a/client/gui-gtk-3.22/pages.c +++ b/client/gui-gtk-3.22/pages.c @@ -786,11 +786,11 @@ static gboolean check_server_scan(gpointer data) type = server_scan_get_type(scan); srvrs = server_scan_get_list(scan); - fc_allocate_mutex(&srvrs->mutex); + fc_mutex_allocate(&srvrs->mutex); holding_srv_list_mutex = TRUE; update_server_list(type, srvrs->servers); holding_srv_list_mutex = FALSE; - fc_release_mutex(&srvrs->mutex); + fc_mutex_release(&srvrs->mutex); } if (stat == SCAN_STATUS_ERROR || stat == SCAN_STATUS_DONE) { @@ -1138,15 +1138,16 @@ static void network_list_callback(GtkTreeSelection *select, gpointer data) path = gtk_tree_model_get_path(model, &it); if (!holding_srv_list_mutex) { /* We are not yet inside mutex protected block */ - fc_allocate_mutex(&srvrs->mutex); + fc_mutex_allocate(&srvrs->mutex); } if (srvrs->servers && path) { gint pos = gtk_tree_path_get_indices(path)[0]; + pserver = server_list_get(srvrs->servers, pos); } if (!holding_srv_list_mutex) { /* We are not yet inside mutex protected block */ - fc_release_mutex(&srvrs->mutex); + fc_mutex_release(&srvrs->mutex); } gtk_tree_path_free(path); } diff --git a/client/gui-gtk-4.0/pages.c b/client/gui-gtk-4.0/pages.c index 30bd8381a6..3dba21a22a 100644 --- a/client/gui-gtk-4.0/pages.c +++ b/client/gui-gtk-4.0/pages.c @@ -805,11 +805,11 @@ static gboolean check_server_scan(gpointer data) type = server_scan_get_type(scan); srvrs = server_scan_get_list(scan); - fc_allocate_mutex(&srvrs->mutex); + fc_mutex_allocate(&srvrs->mutex); holding_srv_list_mutex = TRUE; update_server_list(type, srvrs->servers); holding_srv_list_mutex = FALSE; - fc_release_mutex(&srvrs->mutex); + fc_mutex_release(&srvrs->mutex); } if (stat == SCAN_STATUS_ERROR || stat == SCAN_STATUS_DONE) { @@ -1162,7 +1162,7 @@ static void network_list_callback(GtkTreeSelection *select, gpointer data) path = gtk_tree_model_get_path(model, &it); if (!holding_srv_list_mutex) { /* We are not yet inside mutex protected block */ - fc_allocate_mutex(&srvrs->mutex); + fc_mutex_allocate(&srvrs->mutex); } if (srvrs->servers && path) { gint pos = gtk_tree_path_get_indices(path)[0]; @@ -1171,7 +1171,7 @@ static void network_list_callback(GtkTreeSelection *select, gpointer data) } if (!holding_srv_list_mutex) { /* We are not yet inside mutex protected block */ - fc_release_mutex(&srvrs->mutex); + fc_mutex_release(&srvrs->mutex); } gtk_tree_path_free(path); } diff --git a/client/gui-qt/pages.cpp b/client/gui-qt/pages.cpp index 70c37fde6c..433bf72d5b 100644 --- a/client/gui-qt/pages.cpp +++ b/client/gui-qt/pages.cpp @@ -1046,11 +1046,11 @@ bool fc_client::check_server_scan(server_scan *scan_data) type = server_scan_get_type(scan); srvrs = server_scan_get_list(scan); - fc_allocate_mutex(&srvrs->mutex); + fc_mutex_allocate(&srvrs->mutex); holding_srv_list_mutex = true; update_server_list(type, srvrs->servers); holding_srv_list_mutex = false; - fc_release_mutex(&srvrs->mutex); + fc_mutex_release(&srvrs->mutex); } if (stat == SCAN_STATUS_ERROR || stat == SCAN_STATUS_DONE) { @@ -1172,13 +1172,13 @@ void fc_client::slot_selection_changed(const QItemSelection &selected, srvrs = server_scan_get_list(meta_scan); if (!holding_srv_list_mutex) { - fc_allocate_mutex(&srvrs->mutex); + fc_mutex_allocate(&srvrs->mutex); } if (srvrs->servers) { pserver = server_list_get(srvrs->servers, index.row()); } if (!holding_srv_list_mutex) { - fc_release_mutex(&srvrs->mutex); + fc_mutex_release(&srvrs->mutex); } if (!pserver || !pserver->players) { return; diff --git a/client/gui-sdl2/connectdlg.c b/client/gui-sdl2/connectdlg.c index 6d51add8ab..e7b5259dd8 100644 --- a/client/gui-sdl2/connectdlg.c +++ b/client/gui-sdl2/connectdlg.c @@ -273,13 +273,13 @@ void popup_connection_dialog(bool lan_scan) /* Copy list */ server_list = server_list_new(); - fc_allocate_mutex(&srvrs->mutex); + fc_mutex_allocate(&srvrs->mutex); server_list_iterate(srvrs->servers, pserver) { server_list_append(server_list, pserver); } server_list_iterate_end; - fc_release_mutex(&srvrs->mutex); + fc_mutex_release(&srvrs->mutex); - /* clear label */ + /* Clear label */ popdown_window_group_dialog(new_widget, label_window); meswin_dialog_popup(TRUE); diff --git a/client/servers.c b/client/servers.c index a013c033aa..c425a52f8d 100644 --- a/client/servers.c +++ b/client/servers.c @@ -243,11 +243,11 @@ static bool meta_read_response(struct server_scan *scan) return FALSE; } - /* parse message body */ - fc_allocate_mutex(&scan->srvrs.mutex); + /* Parse message body */ + fc_mutex_allocate(&scan->srvrs.mutex); srvrs = parse_metaserver_data(f); scan->srvrs.servers = srvrs; - fc_release_mutex(&scan->srvrs.mutex); + fc_mutex_release(&scan->srvrs.mutex); /* 'f' (hence 'meta.mem.mem') was closed in parse_metaserver_data(). */ scan->meta.mem.mem = NULL; @@ -273,21 +273,21 @@ static void metaserver_scan(void *arg) struct server_scan *scan = arg; if (!begin_metaserver_scan(scan)) { - fc_allocate_mutex(&scan->meta.mutex); + fc_mutex_allocate(&scan->meta.mutex); scan->meta.status = SCAN_STATUS_ERROR; } else { if (!meta_read_response(scan)) { - fc_allocate_mutex(&scan->meta.mutex); + fc_mutex_allocate(&scan->meta.mutex); scan->meta.status = SCAN_STATUS_ERROR; } else { - fc_allocate_mutex(&scan->meta.mutex); + fc_mutex_allocate(&scan->meta.mutex); if (scan->meta.status == SCAN_STATUS_WAITING) { scan->meta.status = SCAN_STATUS_DONE; } } } - fc_release_mutex(&scan->meta.mutex); + fc_mutex_release(&scan->meta.mutex); } /**********************************************************************//** @@ -577,9 +577,9 @@ static bool begin_lanserver_scan(struct server_scan *scan) fc_closesocket(send_sock); - fc_allocate_mutex(&scan->srvrs.mutex); + fc_mutex_allocate(&scan->srvrs.mutex); scan->srvrs.servers = server_list_new(); - fc_release_mutex(&scan->srvrs.mutex); + fc_mutex_release(&scan->srvrs.mutex); return TRUE; } @@ -677,7 +677,7 @@ get_lan_server_list(struct server_scan *scan) } /* UDP can send duplicate or delayed packets. */ - fc_allocate_mutex(&scan->srvrs.mutex); + fc_mutex_allocate(&scan->srvrs.mutex); server_list_iterate(scan->srvrs.servers, aserver) { if (0 == fc_strcasecmp(aserver->host, servername) && aserver->port == port) { @@ -687,7 +687,7 @@ get_lan_server_list(struct server_scan *scan) } server_list_iterate_end; if (duplicate) { - fc_release_mutex(&scan->srvrs.mutex); + fc_mutex_release(&scan->srvrs.mutex); continue; } @@ -705,7 +705,7 @@ get_lan_server_list(struct server_scan *scan) found_new = TRUE; server_list_prepend(scan->srvrs.servers, pserver); - fc_release_mutex(&scan->srvrs.mutex); + fc_mutex_release(&scan->srvrs.mutex); } if (found_new) { @@ -742,7 +742,7 @@ struct server_scan *server_scan_begin(enum server_scan_type type, scan->type = type; scan->error_func = error_func; scan->sock = -1; - fc_init_mutex(&scan->srvrs.mutex); + fc_mutex_init(&scan->srvrs.mutex); switch (type) { case SERVER_SCAN_GLOBAL: @@ -750,7 +750,7 @@ struct server_scan *server_scan_begin(enum server_scan_type type, #ifdef FREECIV_META_ENABLED int thr_ret; - fc_init_mutex(&scan->meta.mutex); + fc_mutex_init(&scan->meta.mutex); scan->meta.status = SCAN_STATUS_WAITING; thr_ret = fc_thread_start(&scan->meta.thr, metaserver_scan, scan); if (thr_ret) { @@ -815,9 +815,9 @@ enum server_scan_status server_scan_poll(struct server_scan *scan) { enum server_scan_status status; - fc_allocate_mutex(&scan->meta.mutex); + fc_mutex_allocate(&scan->meta.mutex); status = scan->meta.status; - fc_release_mutex(&scan->meta.mutex); + fc_mutex_release(&scan->meta.mutex); return status; } @@ -859,13 +859,13 @@ void server_scan_finish(struct server_scan *scan) if (scan->type == SERVER_SCAN_GLOBAL) { #ifdef FREECIV_META_ENABLED /* Signal metaserver scan thread to stop */ - fc_allocate_mutex(&scan->meta.mutex); + fc_mutex_allocate(&scan->meta.mutex); scan->meta.status = SCAN_STATUS_ABORT; - fc_release_mutex(&scan->meta.mutex); + fc_mutex_release(&scan->meta.mutex); /* Wait thread to stop */ fc_thread_wait(&scan->meta.thr); - fc_destroy_mutex(&scan->meta.mutex); + fc_mutex_destroy(&scan->meta.mutex); /* This mainly duplicates code from below "else" block. * That's intentional, since they will be completely different in future versions. @@ -876,10 +876,10 @@ void server_scan_finish(struct server_scan *scan) } if (scan->srvrs.servers) { - fc_allocate_mutex(&scan->srvrs.mutex); + fc_mutex_allocate(&scan->srvrs.mutex); delete_server_list(scan->srvrs.servers); scan->srvrs.servers = NULL; - fc_release_mutex(&scan->srvrs.mutex); + fc_mutex_release(&scan->srvrs.mutex); } if (scan->meta.mem.mem) { @@ -899,7 +899,7 @@ void server_scan_finish(struct server_scan *scan) } } - fc_destroy_mutex(&scan->srvrs.mutex); + fc_mutex_destroy(&scan->srvrs.mutex); free(scan); } diff --git a/server/citytools.c b/server/citytools.c index 7420930800..28c7506ba4 100644 --- a/server/citytools.c +++ b/server/citytools.c @@ -1520,13 +1520,13 @@ void create_city(struct player *pplayer, struct tile *ptile, adv_city_alloc(pcity); - tile_set_owner(ptile, pplayer, ptile); /* temporarily */ + tile_set_owner(ptile, pplayer, ptile); /* Temporarily */ city_choose_build_default(pcity); pcity->id = identity_number(); - fc_allocate_mutex(&game.server.mutexes.city_list); + fc_mutex_allocate(&game.server.mutexes.city_list); idex_register_city(&wld, pcity); - fc_release_mutex(&game.server.mutexes.city_list); + fc_mutex_release(&game.server.mutexes.city_list); if (city_list_size(pplayer->cities) == 0) { /* Free initial buildings, or at least a palace if they were @@ -1866,9 +1866,9 @@ void remove_city(struct city *pcity) } unit_list_iterate_end; } players_iterate_end; - fc_allocate_mutex(&game.server.mutexes.city_list); + fc_mutex_allocate(&game.server.mutexes.city_list); game_remove_city(&wld, pcity); - fc_release_mutex(&game.server.mutexes.city_list); + fc_mutex_release(&game.server.mutexes.city_list); /* Remove any extras that were only there because the city was there. */ extra_type_iterate(pextra) { diff --git a/server/srv_main.c b/server/srv_main.c index 7fb9eb292e..1ef702435e 100644 --- a/server/srv_main.c +++ b/server/srv_main.c @@ -247,7 +247,7 @@ void srv_init(void) loading additional ai modules from command line. */ ai_init(); - /* init server arguments... */ + /* Init server arguments... */ srvarg.metaserver_no_send = DEFAULT_META_SERVER_NO_SEND; sz_strlcpy(srvarg.metaserver_addr, DEFAULT_META_SERVER_ADDR); @@ -283,10 +283,10 @@ void srv_init(void) srvarg.auth_allow_guests = FALSE; srvarg.auth_allow_newusers = FALSE; - /* mark as initialized */ + /* Mark as initialized */ has_been_srv_init = TRUE; - /* init character encodings. */ + /* Init character encodings. */ init_character_encodings(FC_DEFAULT_DATA_ENCODING, FALSE); #ifdef ENABLE_NLS bind_textdomain_codeset("freeciv-nations", get_internal_encoding()); @@ -296,9 +296,9 @@ void srv_init(void) game.callbacks.unit_deallocate = identity_number_release; /* Initialize global mutexes */ - fc_init_mutex(&game.server.mutexes.city_list); + fc_mutex_init(&game.server.mutexes.city_list); - /* done */ + /* Done */ return; } @@ -1918,7 +1918,7 @@ void fc__noreturn server_quit(void) CALL_FUNC_EACH_AI(module_close); timing_log_free(); registry_module_close(); - fc_destroy_mutex(&game.server.mutexes.city_list); + fc_mutex_destroy(&game.server.mutexes.city_list); libfreeciv_free(); con_log_close(); cmdline_option_values_free(); diff --git a/utility/fcthread.c b/utility/fcthread.c index 17e796234d..7091e34a2c 100644 --- a/utility/fcthread.c +++ b/utility/fcthread.c @@ -76,7 +76,7 @@ void fc_thread_wait(fc_thread *thread) /*******************************************************************//** Initialize mutex ***********************************************************************/ -void fc_init_mutex(fc_mutex *mutex) +void fc_mutex_init(fc_mutex *mutex) { mtx_init(mutex, mtx_plain|mtx_recursive); } @@ -84,7 +84,7 @@ void fc_init_mutex(fc_mutex *mutex) /*******************************************************************//** Destroy mutex ***********************************************************************/ -void fc_destroy_mutex(fc_mutex *mutex) +void fc_mutex_destroy(fc_mutex *mutex) { mtx_destroy(mutex); } @@ -92,7 +92,7 @@ void fc_destroy_mutex(fc_mutex *mutex) /*******************************************************************//** Lock mutex ***********************************************************************/ -void fc_allocate_mutex(fc_mutex *mutex) +void fc_mutex_allocate(fc_mutex *mutex) { mtx_lock(mutex); } @@ -100,7 +100,7 @@ void fc_allocate_mutex(fc_mutex *mutex) /*******************************************************************//** Release mutex ***********************************************************************/ -void fc_release_mutex(fc_mutex *mutex) +void fc_mutex_release(fc_mutex *mutex) { mtx_unlock(mutex); } @@ -199,7 +199,7 @@ void fc_thread_wait(fc_thread *thread) /*******************************************************************//** Initialize mutex ***********************************************************************/ -void fc_init_mutex(fc_mutex *mutex) +void fc_mutex_init(fc_mutex *mutex) { pthread_mutexattr_t attr; @@ -214,7 +214,7 @@ void fc_init_mutex(fc_mutex *mutex) /*******************************************************************//** Destroy mutex ***********************************************************************/ -void fc_destroy_mutex(fc_mutex *mutex) +void fc_mutex_destroy(fc_mutex *mutex) { pthread_mutex_destroy(mutex); } @@ -222,7 +222,7 @@ void fc_destroy_mutex(fc_mutex *mutex) /*******************************************************************//** Lock mutex ***********************************************************************/ -void fc_allocate_mutex(fc_mutex *mutex) +void fc_mutex_allocate(fc_mutex *mutex) { pthread_mutex_lock(mutex); } @@ -230,7 +230,7 @@ void fc_allocate_mutex(fc_mutex *mutex) /*******************************************************************//** Release mutex ***********************************************************************/ -void fc_release_mutex(fc_mutex *mutex) +void fc_mutex_release(fc_mutex *mutex) { pthread_mutex_unlock(mutex); } @@ -329,7 +329,7 @@ void fc_thread_wait(fc_thread *thread) /*******************************************************************//** Initialize mutex ***********************************************************************/ -void fc_init_mutex(fc_mutex *mutex) +void fc_mutex_init(fc_mutex *mutex) { *mutex = CreateMutex(NULL, FALSE, NULL); } @@ -337,7 +337,7 @@ void fc_init_mutex(fc_mutex *mutex) /*******************************************************************//** Destroy mutex ***********************************************************************/ -void fc_destroy_mutex(fc_mutex *mutex) +void fc_mutex_destroy(fc_mutex *mutex) { CloseHandle(*mutex); } @@ -345,7 +345,7 @@ void fc_destroy_mutex(fc_mutex *mutex) /*******************************************************************//** Lock mutex ***********************************************************************/ -void fc_allocate_mutex(fc_mutex *mutex) +void fc_mutex_allocate(fc_mutex *mutex) { WaitForSingleObject(*mutex, INFINITE); } @@ -353,7 +353,7 @@ void fc_allocate_mutex(fc_mutex *mutex) /*******************************************************************//** Release mutex ***********************************************************************/ -void fc_release_mutex(fc_mutex *mutex) +void fc_mutex_release(fc_mutex *mutex) { ReleaseMutex(*mutex); } diff --git a/utility/fcthread.h b/utility/fcthread.h index 42a676f6f0..9394619cf7 100644 --- a/utility/fcthread.h +++ b/utility/fcthread.h @@ -69,10 +69,10 @@ extern "C" { int fc_thread_start(fc_thread *thread, void (*function) (void *arg), void *arg); void fc_thread_wait(fc_thread *thread); -void fc_init_mutex(fc_mutex *mutex); -void fc_destroy_mutex(fc_mutex *mutex); -void fc_allocate_mutex(fc_mutex *mutex); -void fc_release_mutex(fc_mutex *mutex); +void fc_mutex_init(fc_mutex *mutex); +void fc_mutex_destroy(fc_mutex *mutex); +void fc_mutex_allocate(fc_mutex *mutex); +void fc_mutex_release(fc_mutex *mutex); void fc_thread_cond_init(fc_thread_cond *cond); void fc_thread_cond_destroy(fc_thread_cond *cond); diff --git a/utility/genlist.c b/utility/genlist.c index 2cb9c293ed..7b28c3fdc0 100644 --- a/utility/genlist.c +++ b/utility/genlist.c @@ -45,7 +45,7 @@ struct genlist *genlist_new_full(genlist_free_fn_t free_data_func) pgenlist->head_link = NULL; pgenlist->tail_link = NULL; #endif /* ZERO_VARIABLES_FOR_SEARCHING */ - fc_init_mutex(&pgenlist->mutex); + fc_mutex_init(&pgenlist->mutex); pgenlist->free_data_func = free_data_func; return pgenlist; @@ -61,7 +61,7 @@ void genlist_destroy(struct genlist *pgenlist) } genlist_clear(pgenlist); - fc_destroy_mutex(&pgenlist->mutex); + fc_mutex_destroy(&pgenlist->mutex); free(pgenlist); } @@ -682,7 +682,7 @@ void genlist_reverse(struct genlist *pgenlist) ****************************************************************************/ void genlist_allocate_mutex(struct genlist *pgenlist) { - fc_allocate_mutex(&pgenlist->mutex); + fc_mutex_allocate(&pgenlist->mutex); } /************************************************************************//** @@ -690,5 +690,5 @@ void genlist_allocate_mutex(struct genlist *pgenlist) ****************************************************************************/ void genlist_release_mutex(struct genlist *pgenlist) { - fc_release_mutex(&pgenlist->mutex); + fc_mutex_release(&pgenlist->mutex); } diff --git a/utility/log.c b/utility/log.c index 752b60d312..96fa0ce72f 100644 --- a/utility/log.c +++ b/utility/log.c @@ -238,8 +238,8 @@ out: /**********************************************************************//** Initialise the log module. Either 'filename' or 'callback' may be NULL. - If both are NULL, print to stderr. If both are non-NULL, both callback, - and fprintf to file. Pass -1 for fatal_assertions to don't raise any + If both are NULL, print to stderr. If both are non-NULL, both callback, + and fprintf to file. Pass -1 for fatal_assertions to don't raise any signal on failed assertion. **************************************************************************/ void log_init(const char *filename, enum log_level initial_level, @@ -259,17 +259,17 @@ void log_init(const char *filename, enum log_level initial_level, log_callback = callback; log_prefix = prefix; fc_fatal_assertions = fatal_assertions; - fc_init_mutex(&logfile_mutex); + fc_mutex_init(&logfile_mutex); log_verbose("log started"); log_debug("LOG_DEBUG test"); } /**********************************************************************//** - Deinitialize logging module. + Deinitialize logging module. **************************************************************************/ void log_close(void) { - fc_destroy_mutex(&logfile_mutex); + fc_mutex_destroy(&logfile_mutex); } /**********************************************************************//** @@ -425,22 +425,22 @@ void vdo_log(const char *file, const char *function, int line, Really print a log message. For repeat message, may wait and print instead "last message repeated ..." at some later time. - Calls log_callback if non-null, else prints to stderr. + Calls log_callback if not NULL, else prints to stderr. **************************************************************************/ static void log_real(enum log_level level, bool print_from_where, const char *where, const char *msg) { static char last_msg[MAX_LEN_LOG_LINE] = ""; - static unsigned int repeated = 0; /* total times current message repeated */ - static unsigned int next = 2; /* next total to print update */ - static unsigned int prev = 0; /* total on last update */ - /* only count as repeat if same level */ + static unsigned int repeated = 0; /* Total times current message repeated */ + static unsigned int next = 2; /* Next total to print update */ + static unsigned int prev = 0; /* Total on last update */ + /* Only count as repeat if same level */ static enum log_level prev_level = -1; char buf[MAX_LEN_LOG_LINE]; FILE *fs; if (log_filename) { - fc_allocate_mutex(&logfile_mutex); + fc_mutex_allocate(&logfile_mutex); if (!(fs = fc_fopen(log_filename, "a"))) { fc_fprintf(stderr, _("Couldn't open logfile: %s for appending \"%s\".\n"), @@ -500,7 +500,7 @@ static void log_real(enum log_level level, bool print_from_where, fflush(fs); if (log_filename) { fclose(fs); - fc_release_mutex(&logfile_mutex); + fc_mutex_release(&logfile_mutex); } } @@ -509,7 +509,7 @@ static void log_real(enum log_level level, bool print_from_where, by do_log_for(). For repeat message, may wait and print instead "last message repeated ..." at some later time. - Calls log_callback if non-null, else prints to stderr. + Calls log_callback if not NULL, else prints to stderr. **************************************************************************/ void do_log(const char *file, const char *function, int line, bool print_from_where, enum log_level level, diff --git a/utility/support.c b/utility/support.c index a2a86e9e37..f9e673c878 100644 --- a/utility/support.c +++ b/utility/support.c @@ -163,7 +163,7 @@ static void icu_buffers_increase(void) static void fc_strAPI_init(void) { if (icu_buffer_uchars == 0) { - fc_init_mutex(&icu_buffer_mutex); + fc_mutex_init(&icu_buffer_mutex); icu_buffers_initial(); } } @@ -180,7 +180,7 @@ static void fc_strAPI_free(void) icu_buffer2 = NULL; icu_buffer_uchars = 0; } - fc_destroy_mutex(&icu_buffer_mutex); + fc_mutex_destroy(&icu_buffer_mutex); } /************************************************************************//** @@ -205,7 +205,7 @@ int fc_strcasecmp(const char *str0, const char *str1) fc_strAPI_init(); } - fc_allocate_mutex(&icu_buffer_mutex); + fc_mutex_allocate(&icu_buffer_mutex); while (!enough_mem) { UErrorCode err_code0 = U_ZERO_ERROR; @@ -226,7 +226,7 @@ int fc_strcasecmp(const char *str0, const char *str1) ret = u_strCaseCompare(icu_buffer1, -1, icu_buffer2, -1, 0, &err_code); - fc_release_mutex(&icu_buffer_mutex); + fc_mutex_release(&icu_buffer_mutex); return ret; } @@ -254,7 +254,7 @@ int fc_strncasecmp(const char *str0, const char *str1, size_t n) fc_strAPI_init(); } - fc_allocate_mutex(&icu_buffer_mutex); + fc_mutex_allocate(&icu_buffer_mutex); while (!enough_mem) { UErrorCode err_code0 = U_ZERO_ERROR; @@ -282,7 +282,7 @@ int fc_strncasecmp(const char *str0, const char *str1, size_t n) ret = u_strCaseCompare(icu_buffer1, len0, icu_buffer2, len1, 0, &err_code); - fc_release_mutex(&icu_buffer_mutex); + fc_mutex_release(&icu_buffer_mutex); return ret; } @@ -802,7 +802,7 @@ size_t fc_strlcpy(char *dest, const char *src, size_t n) fc_strAPI_init(); } - fc_allocate_mutex(&icu_buffer_mutex); + fc_mutex_allocate(&icu_buffer_mutex); while (!enough_mem) { u_strFromUTF8(icu_buffer1, icu_buffer_uchars, &slen, src, -1, &err_code); @@ -819,7 +819,7 @@ size_t fc_strlcpy(char *dest, const char *src, size_t n) u_strToUTF8(dest, n - 1, &dlen, icu_buffer1, slen, &err_code); - fc_release_mutex(&icu_buffer_mutex); + fc_mutex_release(&icu_buffer_mutex); dest[n - 1] = '\0'; @@ -926,7 +926,7 @@ int fc_vsnprintf(char *str, size_t n, const char *format, va_list ap) exit(EXIT_FAILURE); } - fc_allocate_mutex(&vsnprintf_mutex); + fc_mutex_allocate(&vsnprintf_mutex); if (vsnprintf_buf == NULL) { vsnprintf_buf = malloc(VSNP_BUF_SIZE); @@ -934,7 +934,8 @@ int fc_vsnprintf(char *str, size_t n, const char *format, va_list ap) if (vsnprintf_buf == NULL) { fprintf(stderr, "Could not allocate %i bytes for vsnprintf() " "replacement.", VSNP_BUF_SIZE); - fc_release_mutex(&vsnprintf_mutex); + fc_mutex_release(&vsnprintf_mutex); + exit(EXIT_FAILURE); } } @@ -961,7 +962,7 @@ int fc_vsnprintf(char *str, size_t n, const char *format, va_list ap) str[n - 1] = '\0'; } - fc_release_mutex(&vsnprintf_mutex); + fc_mutex_release(&vsnprintf_mutex); return len; } @@ -1321,9 +1322,9 @@ struct tm *fc_localtime(const time_t *timep, struct tm *result) #ifdef HAVE_LOCALTIME_R return localtime_r(timep, result); #else /* HAVE_LOCALTIME_R */ - fc_allocate_mutex(&localtime_mutex); + fc_mutex_allocate(&localtime_mutex); memcpy(result, localtime(timep), sizeof(struct tm)); - fc_release_mutex(&localtime_mutex); + fc_mutex_release(&localtime_mutex); return result; #endif /* HAVE_LOCALTIME_R */ @@ -1349,11 +1350,11 @@ void fc_support_init(void) fc_strAPI_init(); #ifndef HAVE_WORKING_VSNPRINTF - fc_init_mutex(&vsnprintf_mutex); + fc_mutex_init(&vsnprintf_mutex); #endif /* HAVE_WORKING_VSNPRINTF */ #ifndef HAVE_LOCALTIME_R - fc_init_mutex(&localtime_mutex); + fc_mutex_init(&localtime_mutex); #endif /* HAVE_LOCALTIME_R */ support_initialized = TRUE; @@ -1371,11 +1372,11 @@ void fc_support_free(void) free(vsnprintf_buf); vsnprintf_buf = NULL; } - fc_destroy_mutex(&vsnprintf_mutex); + fc_mutex_destroy(&vsnprintf_mutex); #endif /* HAVE_WORKING_VSNPRINTF */ #ifndef HAVE_LOCALTIME_R - fc_destroy_mutex(&localtime_mutex); + fc_mutex_destroy(&localtime_mutex); #endif /* HAVE_LOCALTIME_R */ fc_strAPI_free(); -- 2.39.1