diff options
Diffstat (limited to 'src/plugins')
20 files changed, 23107 insertions, 247 deletions
diff --git a/src/plugins/HPMHooking.c b/src/plugins/HPMHooking.c index e15cc363d..19d7ae2c5 100644 --- a/src/plugins/HPMHooking.c +++ b/src/plugins/HPMHooking.c @@ -2,7 +2,7 @@ // See the LICENSE file // Sample Hercules Plugin -#include "common/HPMi.h" +#include "common/hercules.h" #include "common/db.h" #include "common/malloc.h" #include "common/mmo.h" @@ -11,7 +11,6 @@ #if defined (HPMHOOKING_LOGIN) #define HPM_SERVER_TYPE SERVER_TYPE_LOGIN #define HPM_CORE_INCLUDE "HPMHooking/HPMHooking_login.HPMHooksCore.inc" -#define HPM_SYMBOL_INCLUDE "HPMHooking/HPMHooking_login.GetSymbol.inc" #define HPM_HOOKS_INCLUDE "HPMHooking/HPMHooking_login.Hooks.inc" #define HPM_POINTS_INCLUDE "HPMHooking/HPMHooking_login.HookingPoints.inc" #define HPM_SOURCES_INCLUDE "HPMHooking/HPMHooking_login.sources.inc" @@ -19,7 +18,6 @@ #elif defined (HPMHOOKING_CHAR) #define HPM_SERVER_TYPE SERVER_TYPE_CHAR #define HPM_CORE_INCLUDE "HPMHooking/HPMHooking_char.HPMHooksCore.inc" -#define HPM_SYMBOL_INCLUDE "HPMHooking/HPMHooking_char.GetSymbol.inc" #define HPM_HOOKS_INCLUDE "HPMHooking/HPMHooking_char.Hooks.inc" #define HPM_POINTS_INCLUDE "HPMHooking/HPMHooking_char.HookingPoints.inc" #define HPM_SOURCES_INCLUDE "HPMHooking/HPMHooking_char.sources.inc" @@ -39,10 +37,10 @@ #include "char/loginif.h" #include "char/mapif.h" #include "char/pincode.h" +#include "common/mapindex.h" #elif defined (HPMHOOKING_MAP) #define HPM_SERVER_TYPE SERVER_TYPE_MAP #define HPM_CORE_INCLUDE "HPMHooking/HPMHooking_map.HPMHooksCore.inc" -#define HPM_SYMBOL_INCLUDE "HPMHooking/HPMHooking_map.GetSymbol.inc" #define HPM_HOOKS_INCLUDE "HPMHooking/HPMHooking_map.Hooks.inc" #define HPM_POINTS_INCLUDE "HPMHooking/HPMHooking_map.HookingPoints.inc" #define HPM_SOURCES_INCLUDE "HPMHooking/HPMHooking_map.sources.inc" @@ -68,7 +66,6 @@ #include "map/mercenary.h" #include "map/mob.h" #include "map/npc.h" -#include "map/npc.h" #include "map/party.h" #include "map/path.h" #include "map/pc.h" @@ -80,15 +77,27 @@ #include "map/storage.h" #include "map/trade.h" #include "map/unit.h" +#include "common/mapindex.h" #else #define HPM_SERVER_TYPE SERVER_TYPE_UNKNOWN #define HPM_CORE_INCLUDE "HPMHooking/HPMHooking.HPMHooksCore.inc" -#define HPM_SYMBOL_INCLUDE "HPMHooking/HPMHooking.GetSymbol.inc" #define HPM_HOOKS_INCLUDE "HPMHooking/HPMHooking.Hooks.inc" #define HPM_POINTS_INCLUDE "HPMHooking/HPMHooking.HookingPoints.inc" #define HPM_SOURCES_INCLUDE "HPMHooking/HPMHooking.sources.inc" #error HPMHooking plugin needs to be compiled for a specific server type. Please make sure your Makefiles are up to date. #endif +#include "common/conf.h" +#include "common/console.h" +#include "common/db.h" +#include "common/malloc.h" +#include "common/nullpo.h" +#include "common/showmsg.h" +#include "common/socket.h" +#include "common/sql.h" +#include "common/strlib.h" +#include "common/sysinfo.h" +#include "common/timer.h" +#include "common/utils.h" #include "common/HPMDataCheck.h" @@ -135,10 +144,10 @@ HPExport void server_post_final (void) { } HPExport const char *Hooked (bool *fr) { + const char *ret = HPM_shared_symbols(HPM_SERVER_TYPE); + if (ret) + return ret; HPMforce_return = fr; - if (!(DB = GET_SYMBOL("DB"))) return "DB"; - if (!(iMalloc = GET_SYMBOL("iMalloc"))) return "iMalloc"; -#include HPM_SYMBOL_INCLUDE HPM_HP_load(); return NULL; } diff --git a/src/plugins/HPMHooking/HPMHooking_char.GetSymbol.inc b/src/plugins/HPMHooking/HPMHooking_char.GetSymbol.inc deleted file mode 100644 index af7df2980..000000000 --- a/src/plugins/HPMHooking/HPMHooking_char.GetSymbol.inc +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright (c) Hercules Dev Team, licensed under GNU GPL. -// See the LICENSE file -// -// NOTE: This file was auto-generated and should never be manually edited, -// as it will get overwritten. - -if( !(chr = GET_SYMBOL("chr") ) ) return "chr"; -if( !(geoip = GET_SYMBOL("geoip") ) ) return "geoip"; -if( !(inter_auction = GET_SYMBOL("inter_auction") ) ) return "inter_auction"; -if( !(inter_elemental = GET_SYMBOL("inter_elemental") ) ) return "inter_elemental"; -if( !(inter_guild = GET_SYMBOL("inter_guild") ) ) return "inter_guild"; -if( !(inter_homunculus = GET_SYMBOL("inter_homunculus") ) ) return "inter_homunculus"; -if( !(inter = GET_SYMBOL("inter") ) ) return "inter"; -if( !(inter_mail = GET_SYMBOL("inter_mail") ) ) return "inter_mail"; -if( !(inter_mercenary = GET_SYMBOL("inter_mercenary") ) ) return "inter_mercenary"; -if( !(inter_party = GET_SYMBOL("inter_party") ) ) return "inter_party"; -if( !(inter_pet = GET_SYMBOL("inter_pet") ) ) return "inter_pet"; -if( !(inter_quest = GET_SYMBOL("inter_quest") ) ) return "inter_quest"; -if( !(inter_storage = GET_SYMBOL("inter_storage") ) ) return "inter_storage"; -if( !(loginif = GET_SYMBOL("loginif") ) ) return "loginif"; -if( !(mapif = GET_SYMBOL("mapif") ) ) return "mapif"; -if( !(pincode = GET_SYMBOL("pincode") ) ) return "pincode"; diff --git a/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc index 09d6ce1b6..c5f135937 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc @@ -5,6 +5,12 @@ // as it will get overwritten. struct { + struct HPMHookPoint *HP_HCache_init_pre; + struct HPMHookPoint *HP_HCache_init_post; + struct HPMHookPoint *HP_HCache_check_pre; + struct HPMHookPoint *HP_HCache_check_post; + struct HPMHookPoint *HP_HCache_open_pre; + struct HPMHookPoint *HP_HCache_open_post; struct HPMHookPoint *HP_chr_waiting_disconnect_pre; struct HPMHookPoint *HP_chr_waiting_disconnect_post; struct HPMHookPoint *HP_chr_delete_char_sql_pre; @@ -219,8 +225,8 @@ struct { struct HPMHookPoint *HP_chr_search_mapserver_post; struct HPMHookPoint *HP_chr_mapif_init_pre; struct HPMHookPoint *HP_chr_mapif_init_post; - struct HPMHookPoint *HP_chr_lan_subnetcheck_pre; - struct HPMHookPoint *HP_chr_lan_subnetcheck_post; + struct HPMHookPoint *HP_chr_lan_subnet_check_pre; + struct HPMHookPoint *HP_chr_lan_subnet_check_post; struct HPMHookPoint *HP_chr_delete2_ack_pre; struct HPMHookPoint *HP_chr_delete2_ack_post; struct HPMHookPoint *HP_chr_delete2_accept_actual_ack_pre; @@ -317,14 +323,70 @@ struct { struct HPMHookPoint *HP_chr_online_data_cleanup_sub_post; struct HPMHookPoint *HP_chr_online_data_cleanup_pre; struct HPMHookPoint *HP_chr_online_data_cleanup_post; - struct HPMHookPoint *HP_chr_lan_config_read_pre; - struct HPMHookPoint *HP_chr_lan_config_read_post; struct HPMHookPoint *HP_chr_sql_config_read_pre; struct HPMHookPoint *HP_chr_sql_config_read_post; struct HPMHookPoint *HP_chr_config_dispatch_pre; struct HPMHookPoint *HP_chr_config_dispatch_post; struct HPMHookPoint *HP_chr_config_read_pre; struct HPMHookPoint *HP_chr_config_read_post; + struct HPMHookPoint *HP_cmdline_init_pre; + struct HPMHookPoint *HP_cmdline_init_post; + struct HPMHookPoint *HP_cmdline_final_pre; + struct HPMHookPoint *HP_cmdline_final_post; + struct HPMHookPoint *HP_cmdline_arg_add_pre; + struct HPMHookPoint *HP_cmdline_arg_add_post; + struct HPMHookPoint *HP_cmdline_exec_pre; + struct HPMHookPoint *HP_cmdline_exec_post; + struct HPMHookPoint *HP_cmdline_arg_next_value_pre; + struct HPMHookPoint *HP_cmdline_arg_next_value_post; + struct HPMHookPoint *HP_cmdline_arg_source_pre; + struct HPMHookPoint *HP_cmdline_arg_source_post; + struct HPMHookPoint *HP_console_init_pre; + struct HPMHookPoint *HP_console_init_post; + struct HPMHookPoint *HP_console_final_pre; + struct HPMHookPoint *HP_console_final_post; + struct HPMHookPoint *HP_console_display_title_pre; + struct HPMHookPoint *HP_console_display_title_post; + struct HPMHookPoint *HP_core_shutdown_callback_pre; + struct HPMHookPoint *HP_core_shutdown_callback_post; + struct HPMHookPoint *HP_DB_fix_options_pre; + struct HPMHookPoint *HP_DB_fix_options_post; + struct HPMHookPoint *HP_DB_default_cmp_pre; + struct HPMHookPoint *HP_DB_default_cmp_post; + struct HPMHookPoint *HP_DB_default_hash_pre; + struct HPMHookPoint *HP_DB_default_hash_post; + struct HPMHookPoint *HP_DB_default_release_pre; + struct HPMHookPoint *HP_DB_default_release_post; + struct HPMHookPoint *HP_DB_custom_release_pre; + struct HPMHookPoint *HP_DB_custom_release_post; + struct HPMHookPoint *HP_DB_alloc_pre; + struct HPMHookPoint *HP_DB_alloc_post; + struct HPMHookPoint *HP_DB_i2key_pre; + struct HPMHookPoint *HP_DB_i2key_post; + struct HPMHookPoint *HP_DB_ui2key_pre; + struct HPMHookPoint *HP_DB_ui2key_post; + struct HPMHookPoint *HP_DB_str2key_pre; + struct HPMHookPoint *HP_DB_str2key_post; + struct HPMHookPoint *HP_DB_i642key_pre; + struct HPMHookPoint *HP_DB_i642key_post; + struct HPMHookPoint *HP_DB_ui642key_pre; + struct HPMHookPoint *HP_DB_ui642key_post; + struct HPMHookPoint *HP_DB_i2data_pre; + struct HPMHookPoint *HP_DB_i2data_post; + struct HPMHookPoint *HP_DB_ui2data_pre; + struct HPMHookPoint *HP_DB_ui2data_post; + struct HPMHookPoint *HP_DB_ptr2data_pre; + struct HPMHookPoint *HP_DB_ptr2data_post; + struct HPMHookPoint *HP_DB_data2i_pre; + struct HPMHookPoint *HP_DB_data2i_post; + struct HPMHookPoint *HP_DB_data2ui_pre; + struct HPMHookPoint *HP_DB_data2ui_post; + struct HPMHookPoint *HP_DB_data2ptr_pre; + struct HPMHookPoint *HP_DB_data2ptr_post; + struct HPMHookPoint *HP_DB_init_pre; + struct HPMHookPoint *HP_DB_init_post; + struct HPMHookPoint *HP_DB_final_pre; + struct HPMHookPoint *HP_DB_final_post; struct HPMHookPoint *HP_geoip_getcountry_pre; struct HPMHookPoint *HP_geoip_getcountry_post; struct HPMHookPoint *HP_geoip_final_pre; @@ -523,6 +585,122 @@ struct { struct HPMHookPoint *HP_inter_storage_guild_storage_delete_post; struct HPMHookPoint *HP_inter_storage_parse_frommap_pre; struct HPMHookPoint *HP_inter_storage_parse_frommap_post; + struct HPMHookPoint *HP_libconfig_read_pre; + struct HPMHookPoint *HP_libconfig_read_post; + struct HPMHookPoint *HP_libconfig_write_pre; + struct HPMHookPoint *HP_libconfig_write_post; + struct HPMHookPoint *HP_libconfig_set_auto_convert_pre; + struct HPMHookPoint *HP_libconfig_set_auto_convert_post; + struct HPMHookPoint *HP_libconfig_get_auto_convert_pre; + struct HPMHookPoint *HP_libconfig_get_auto_convert_post; + struct HPMHookPoint *HP_libconfig_read_string_pre; + struct HPMHookPoint *HP_libconfig_read_string_post; + struct HPMHookPoint *HP_libconfig_read_file_src_pre; + struct HPMHookPoint *HP_libconfig_read_file_src_post; + struct HPMHookPoint *HP_libconfig_write_file_pre; + struct HPMHookPoint *HP_libconfig_write_file_post; + struct HPMHookPoint *HP_libconfig_set_destructor_pre; + struct HPMHookPoint *HP_libconfig_set_destructor_post; + struct HPMHookPoint *HP_libconfig_set_include_dir_pre; + struct HPMHookPoint *HP_libconfig_set_include_dir_post; + struct HPMHookPoint *HP_libconfig_init_pre; + struct HPMHookPoint *HP_libconfig_init_post; + struct HPMHookPoint *HP_libconfig_destroy_pre; + struct HPMHookPoint *HP_libconfig_destroy_post; + struct HPMHookPoint *HP_libconfig_setting_get_int_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int_post; + struct HPMHookPoint *HP_libconfig_setting_get_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int64_post; + struct HPMHookPoint *HP_libconfig_setting_get_float_pre; + struct HPMHookPoint *HP_libconfig_setting_get_float_post; + struct HPMHookPoint *HP_libconfig_setting_get_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_get_bool_post; + struct HPMHookPoint *HP_libconfig_setting_get_string_pre; + struct HPMHookPoint *HP_libconfig_setting_get_string_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_int_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_int_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_int64_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_float_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_float_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_bool_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_string_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_string_post; + struct HPMHookPoint *HP_libconfig_setting_set_int_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int_post; + struct HPMHookPoint *HP_libconfig_setting_set_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int64_post; + struct HPMHookPoint *HP_libconfig_setting_set_float_pre; + struct HPMHookPoint *HP_libconfig_setting_set_float_post; + struct HPMHookPoint *HP_libconfig_setting_set_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_set_bool_post; + struct HPMHookPoint *HP_libconfig_setting_set_string_pre; + struct HPMHookPoint *HP_libconfig_setting_set_string_post; + struct HPMHookPoint *HP_libconfig_setting_set_format_pre; + struct HPMHookPoint *HP_libconfig_setting_set_format_post; + struct HPMHookPoint *HP_libconfig_setting_get_format_pre; + struct HPMHookPoint *HP_libconfig_setting_get_format_post; + struct HPMHookPoint *HP_libconfig_setting_get_int_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_int64_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int64_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_float_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_float_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_bool_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_bool_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_string_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_string_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_int_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_int64_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int64_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_float_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_float_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_bool_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_bool_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_string_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_string_elem_post; + struct HPMHookPoint *HP_libconfig_setting_index_pre; + struct HPMHookPoint *HP_libconfig_setting_index_post; + struct HPMHookPoint *HP_libconfig_setting_length_pre; + struct HPMHookPoint *HP_libconfig_setting_length_post; + struct HPMHookPoint *HP_libconfig_setting_get_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_member_pre; + struct HPMHookPoint *HP_libconfig_setting_get_member_post; + struct HPMHookPoint *HP_libconfig_setting_add_pre; + struct HPMHookPoint *HP_libconfig_setting_add_post; + struct HPMHookPoint *HP_libconfig_setting_remove_pre; + struct HPMHookPoint *HP_libconfig_setting_remove_post; + struct HPMHookPoint *HP_libconfig_setting_remove_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_remove_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_hook_pre; + struct HPMHookPoint *HP_libconfig_setting_set_hook_post; + struct HPMHookPoint *HP_libconfig_lookup_pre; + struct HPMHookPoint *HP_libconfig_lookup_post; + struct HPMHookPoint *HP_libconfig_lookup_from_pre; + struct HPMHookPoint *HP_libconfig_lookup_from_post; + struct HPMHookPoint *HP_libconfig_lookup_int_pre; + struct HPMHookPoint *HP_libconfig_lookup_int_post; + struct HPMHookPoint *HP_libconfig_lookup_int64_pre; + struct HPMHookPoint *HP_libconfig_lookup_int64_post; + struct HPMHookPoint *HP_libconfig_lookup_float_pre; + struct HPMHookPoint *HP_libconfig_lookup_float_post; + struct HPMHookPoint *HP_libconfig_lookup_bool_pre; + struct HPMHookPoint *HP_libconfig_lookup_bool_post; + struct HPMHookPoint *HP_libconfig_lookup_string_pre; + struct HPMHookPoint *HP_libconfig_lookup_string_post; + struct HPMHookPoint *HP_libconfig_read_file_pre; + struct HPMHookPoint *HP_libconfig_read_file_post; + struct HPMHookPoint *HP_libconfig_setting_copy_simple_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_simple_post; + struct HPMHookPoint *HP_libconfig_setting_copy_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_elem_post; + struct HPMHookPoint *HP_libconfig_setting_copy_aggregate_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_aggregate_post; + struct HPMHookPoint *HP_libconfig_setting_copy_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_post; struct HPMHookPoint *HP_loginif_init_pre; struct HPMHookPoint *HP_loginif_init_post; struct HPMHookPoint *HP_loginif_final_pre; @@ -549,6 +727,32 @@ struct { struct HPMHookPoint *HP_loginif_send_users_count_post; struct HPMHookPoint *HP_loginif_connect_to_server_pre; struct HPMHookPoint *HP_loginif_connect_to_server_post; + struct HPMHookPoint *HP_iMalloc_init_pre; + struct HPMHookPoint *HP_iMalloc_init_post; + struct HPMHookPoint *HP_iMalloc_final_pre; + struct HPMHookPoint *HP_iMalloc_final_post; + struct HPMHookPoint *HP_iMalloc_malloc_pre; + struct HPMHookPoint *HP_iMalloc_malloc_post; + struct HPMHookPoint *HP_iMalloc_calloc_pre; + struct HPMHookPoint *HP_iMalloc_calloc_post; + struct HPMHookPoint *HP_iMalloc_realloc_pre; + struct HPMHookPoint *HP_iMalloc_realloc_post; + struct HPMHookPoint *HP_iMalloc_reallocz_pre; + struct HPMHookPoint *HP_iMalloc_reallocz_post; + struct HPMHookPoint *HP_iMalloc_astrdup_pre; + struct HPMHookPoint *HP_iMalloc_astrdup_post; + struct HPMHookPoint *HP_iMalloc_free_pre; + struct HPMHookPoint *HP_iMalloc_free_post; + struct HPMHookPoint *HP_iMalloc_memory_check_pre; + struct HPMHookPoint *HP_iMalloc_memory_check_post; + struct HPMHookPoint *HP_iMalloc_verify_ptr_pre; + struct HPMHookPoint *HP_iMalloc_verify_ptr_post; + struct HPMHookPoint *HP_iMalloc_usage_pre; + struct HPMHookPoint *HP_iMalloc_usage_post; + struct HPMHookPoint *HP_iMalloc_post_shutdown_pre; + struct HPMHookPoint *HP_iMalloc_post_shutdown_post; + struct HPMHookPoint *HP_iMalloc_init_messages_pre; + struct HPMHookPoint *HP_iMalloc_init_messages_post; struct HPMHookPoint *HP_mapif_ban_pre; struct HPMHookPoint *HP_mapif_ban_post; struct HPMHookPoint *HP_mapif_server_init_pre; @@ -881,6 +1085,26 @@ struct { struct HPMHookPoint *HP_mapif_namechange_ack_post; struct HPMHookPoint *HP_mapif_parse_NameChangeRequest_pre; struct HPMHookPoint *HP_mapif_parse_NameChangeRequest_post; + struct HPMHookPoint *HP_mapindex_init_pre; + struct HPMHookPoint *HP_mapindex_init_post; + struct HPMHookPoint *HP_mapindex_final_pre; + struct HPMHookPoint *HP_mapindex_final_post; + struct HPMHookPoint *HP_mapindex_addmap_pre; + struct HPMHookPoint *HP_mapindex_addmap_post; + struct HPMHookPoint *HP_mapindex_removemap_pre; + struct HPMHookPoint *HP_mapindex_removemap_post; + struct HPMHookPoint *HP_mapindex_getmapname_pre; + struct HPMHookPoint *HP_mapindex_getmapname_post; + struct HPMHookPoint *HP_mapindex_getmapname_ext_pre; + struct HPMHookPoint *HP_mapindex_getmapname_ext_post; + struct HPMHookPoint *HP_mapindex_name2id_pre; + struct HPMHookPoint *HP_mapindex_name2id_post; + struct HPMHookPoint *HP_mapindex_id2name_pre; + struct HPMHookPoint *HP_mapindex_id2name_post; + struct HPMHookPoint *HP_mapindex_check_default_pre; + struct HPMHookPoint *HP_mapindex_check_default_post; + struct HPMHookPoint *HP_nullpo_assert_report_pre; + struct HPMHookPoint *HP_nullpo_assert_report_post; struct HPMHookPoint *HP_pincode_handle_pre; struct HPMHookPoint *HP_pincode_handle_post; struct HPMHookPoint *HP_pincode_decrypt_pre; @@ -901,9 +1125,267 @@ struct { struct HPMHookPoint *HP_pincode_check_post; struct HPMHookPoint *HP_pincode_config_read_pre; struct HPMHookPoint *HP_pincode_config_read_post; + struct HPMHookPoint *HP_showmsg_init_pre; + struct HPMHookPoint *HP_showmsg_init_post; + struct HPMHookPoint *HP_showmsg_final_pre; + struct HPMHookPoint *HP_showmsg_final_post; + struct HPMHookPoint *HP_showmsg_clearScreen_pre; + struct HPMHookPoint *HP_showmsg_clearScreen_post; + struct HPMHookPoint *HP_showmsg_showMessageV_pre; + struct HPMHookPoint *HP_showmsg_showMessageV_post; + struct HPMHookPoint *HP_sockt_init_pre; + struct HPMHookPoint *HP_sockt_init_post; + struct HPMHookPoint *HP_sockt_final_pre; + struct HPMHookPoint *HP_sockt_final_post; + struct HPMHookPoint *HP_sockt_perform_pre; + struct HPMHookPoint *HP_sockt_perform_post; + struct HPMHookPoint *HP_sockt_datasync_pre; + struct HPMHookPoint *HP_sockt_datasync_post; + struct HPMHookPoint *HP_sockt_make_listen_bind_pre; + struct HPMHookPoint *HP_sockt_make_listen_bind_post; + struct HPMHookPoint *HP_sockt_make_connection_pre; + struct HPMHookPoint *HP_sockt_make_connection_post; + struct HPMHookPoint *HP_sockt_realloc_fifo_pre; + struct HPMHookPoint *HP_sockt_realloc_fifo_post; + struct HPMHookPoint *HP_sockt_realloc_writefifo_pre; + struct HPMHookPoint *HP_sockt_realloc_writefifo_post; + struct HPMHookPoint *HP_sockt_wfifoset_pre; + struct HPMHookPoint *HP_sockt_wfifoset_post; + struct HPMHookPoint *HP_sockt_rfifoskip_pre; + struct HPMHookPoint *HP_sockt_rfifoskip_post; + struct HPMHookPoint *HP_sockt_close_pre; + struct HPMHookPoint *HP_sockt_close_post; + struct HPMHookPoint *HP_sockt_session_is_valid_pre; + struct HPMHookPoint *HP_sockt_session_is_valid_post; + struct HPMHookPoint *HP_sockt_session_is_active_pre; + struct HPMHookPoint *HP_sockt_session_is_active_post; + struct HPMHookPoint *HP_sockt_flush_pre; + struct HPMHookPoint *HP_sockt_flush_post; + struct HPMHookPoint *HP_sockt_flush_fifos_pre; + struct HPMHookPoint *HP_sockt_flush_fifos_post; + struct HPMHookPoint *HP_sockt_set_nonblocking_pre; + struct HPMHookPoint *HP_sockt_set_nonblocking_post; + struct HPMHookPoint *HP_sockt_set_defaultparse_pre; + struct HPMHookPoint *HP_sockt_set_defaultparse_post; + struct HPMHookPoint *HP_sockt_host2ip_pre; + struct HPMHookPoint *HP_sockt_host2ip_post; + struct HPMHookPoint *HP_sockt_ip2str_pre; + struct HPMHookPoint *HP_sockt_ip2str_post; + struct HPMHookPoint *HP_sockt_str2ip_pre; + struct HPMHookPoint *HP_sockt_str2ip_post; + struct HPMHookPoint *HP_sockt_ntows_pre; + struct HPMHookPoint *HP_sockt_ntows_post; + struct HPMHookPoint *HP_sockt_getips_pre; + struct HPMHookPoint *HP_sockt_getips_post; + struct HPMHookPoint *HP_sockt_eof_pre; + struct HPMHookPoint *HP_sockt_eof_post; + struct HPMHookPoint *HP_sockt_lan_subnet_check_pre; + struct HPMHookPoint *HP_sockt_lan_subnet_check_post; + struct HPMHookPoint *HP_sockt_allowed_ip_check_pre; + struct HPMHookPoint *HP_sockt_allowed_ip_check_post; + struct HPMHookPoint *HP_sockt_trusted_ip_check_pre; + struct HPMHookPoint *HP_sockt_trusted_ip_check_post; + struct HPMHookPoint *HP_sockt_net_config_read_sub_pre; + struct HPMHookPoint *HP_sockt_net_config_read_sub_post; + struct HPMHookPoint *HP_sockt_net_config_read_pre; + struct HPMHookPoint *HP_sockt_net_config_read_post; + struct HPMHookPoint *HP_SQL_Connect_pre; + struct HPMHookPoint *HP_SQL_Connect_post; + struct HPMHookPoint *HP_SQL_GetTimeout_pre; + struct HPMHookPoint *HP_SQL_GetTimeout_post; + struct HPMHookPoint *HP_SQL_GetColumnNames_pre; + struct HPMHookPoint *HP_SQL_GetColumnNames_post; + struct HPMHookPoint *HP_SQL_SetEncoding_pre; + struct HPMHookPoint *HP_SQL_SetEncoding_post; + struct HPMHookPoint *HP_SQL_Ping_pre; + struct HPMHookPoint *HP_SQL_Ping_post; + struct HPMHookPoint *HP_SQL_EscapeString_pre; + struct HPMHookPoint *HP_SQL_EscapeString_post; + struct HPMHookPoint *HP_SQL_EscapeStringLen_pre; + struct HPMHookPoint *HP_SQL_EscapeStringLen_post; + struct HPMHookPoint *HP_SQL_QueryV_pre; + struct HPMHookPoint *HP_SQL_QueryV_post; + struct HPMHookPoint *HP_SQL_QueryStr_pre; + struct HPMHookPoint *HP_SQL_QueryStr_post; + struct HPMHookPoint *HP_SQL_LastInsertId_pre; + struct HPMHookPoint *HP_SQL_LastInsertId_post; + struct HPMHookPoint *HP_SQL_NumColumns_pre; + struct HPMHookPoint *HP_SQL_NumColumns_post; + struct HPMHookPoint *HP_SQL_NumRows_pre; + struct HPMHookPoint *HP_SQL_NumRows_post; + struct HPMHookPoint *HP_SQL_NextRow_pre; + struct HPMHookPoint *HP_SQL_NextRow_post; + struct HPMHookPoint *HP_SQL_GetData_pre; + struct HPMHookPoint *HP_SQL_GetData_post; + struct HPMHookPoint *HP_SQL_FreeResult_pre; + struct HPMHookPoint *HP_SQL_FreeResult_post; + struct HPMHookPoint *HP_SQL_ShowDebug__pre; + struct HPMHookPoint *HP_SQL_ShowDebug__post; + struct HPMHookPoint *HP_SQL_Free_pre; + struct HPMHookPoint *HP_SQL_Free_post; + struct HPMHookPoint *HP_SQL_Malloc_pre; + struct HPMHookPoint *HP_SQL_Malloc_post; + struct HPMHookPoint *HP_SQL_StmtMalloc_pre; + struct HPMHookPoint *HP_SQL_StmtMalloc_post; + struct HPMHookPoint *HP_SQL_StmtPrepareV_pre; + struct HPMHookPoint *HP_SQL_StmtPrepareV_post; + struct HPMHookPoint *HP_SQL_StmtPrepareStr_pre; + struct HPMHookPoint *HP_SQL_StmtPrepareStr_post; + struct HPMHookPoint *HP_SQL_StmtNumParams_pre; + struct HPMHookPoint *HP_SQL_StmtNumParams_post; + struct HPMHookPoint *HP_SQL_StmtBindParam_pre; + struct HPMHookPoint *HP_SQL_StmtBindParam_post; + struct HPMHookPoint *HP_SQL_StmtExecute_pre; + struct HPMHookPoint *HP_SQL_StmtExecute_post; + struct HPMHookPoint *HP_SQL_StmtLastInsertId_pre; + struct HPMHookPoint *HP_SQL_StmtLastInsertId_post; + struct HPMHookPoint *HP_SQL_StmtNumColumns_pre; + struct HPMHookPoint *HP_SQL_StmtNumColumns_post; + struct HPMHookPoint *HP_SQL_StmtBindColumn_pre; + struct HPMHookPoint *HP_SQL_StmtBindColumn_post; + struct HPMHookPoint *HP_SQL_StmtNumRows_pre; + struct HPMHookPoint *HP_SQL_StmtNumRows_post; + struct HPMHookPoint *HP_SQL_StmtNextRow_pre; + struct HPMHookPoint *HP_SQL_StmtNextRow_post; + struct HPMHookPoint *HP_SQL_StmtFreeResult_pre; + struct HPMHookPoint *HP_SQL_StmtFreeResult_post; + struct HPMHookPoint *HP_SQL_StmtFree_pre; + struct HPMHookPoint *HP_SQL_StmtFree_post; + struct HPMHookPoint *HP_SQL_StmtShowDebug__pre; + struct HPMHookPoint *HP_SQL_StmtShowDebug__post; + struct HPMHookPoint *HP_StrBuf_Malloc_pre; + struct HPMHookPoint *HP_StrBuf_Malloc_post; + struct HPMHookPoint *HP_StrBuf_Init_pre; + struct HPMHookPoint *HP_StrBuf_Init_post; + struct HPMHookPoint *HP_StrBuf_Vprintf_pre; + struct HPMHookPoint *HP_StrBuf_Vprintf_post; + struct HPMHookPoint *HP_StrBuf_Append_pre; + struct HPMHookPoint *HP_StrBuf_Append_post; + struct HPMHookPoint *HP_StrBuf_AppendStr_pre; + struct HPMHookPoint *HP_StrBuf_AppendStr_post; + struct HPMHookPoint *HP_StrBuf_Length_pre; + struct HPMHookPoint *HP_StrBuf_Length_post; + struct HPMHookPoint *HP_StrBuf_Value_pre; + struct HPMHookPoint *HP_StrBuf_Value_post; + struct HPMHookPoint *HP_StrBuf_Clear_pre; + struct HPMHookPoint *HP_StrBuf_Clear_post; + struct HPMHookPoint *HP_StrBuf_Destroy_pre; + struct HPMHookPoint *HP_StrBuf_Destroy_post; + struct HPMHookPoint *HP_StrBuf_Free_pre; + struct HPMHookPoint *HP_StrBuf_Free_post; + struct HPMHookPoint *HP_strlib_jstrescape_pre; + struct HPMHookPoint *HP_strlib_jstrescape_post; + struct HPMHookPoint *HP_strlib_jstrescapecpy_pre; + struct HPMHookPoint *HP_strlib_jstrescapecpy_post; + struct HPMHookPoint *HP_strlib_jmemescapecpy_pre; + struct HPMHookPoint *HP_strlib_jmemescapecpy_post; + struct HPMHookPoint *HP_strlib_remove_control_chars__pre; + struct HPMHookPoint *HP_strlib_remove_control_chars__post; + struct HPMHookPoint *HP_strlib_trim__pre; + struct HPMHookPoint *HP_strlib_trim__post; + struct HPMHookPoint *HP_strlib_normalize_name__pre; + struct HPMHookPoint *HP_strlib_normalize_name__post; + struct HPMHookPoint *HP_strlib_stristr__pre; + struct HPMHookPoint *HP_strlib_stristr__post; + struct HPMHookPoint *HP_strlib_strnlen__pre; + struct HPMHookPoint *HP_strlib_strnlen__post; + struct HPMHookPoint *HP_strlib_strtok_r__pre; + struct HPMHookPoint *HP_strlib_strtok_r__post; + struct HPMHookPoint *HP_strlib_e_mail_check__pre; + struct HPMHookPoint *HP_strlib_e_mail_check__post; + struct HPMHookPoint *HP_strlib_config_switch__pre; + struct HPMHookPoint *HP_strlib_config_switch__post; + struct HPMHookPoint *HP_strlib_safestrncpy__pre; + struct HPMHookPoint *HP_strlib_safestrncpy__post; + struct HPMHookPoint *HP_strlib_safestrnlen__pre; + struct HPMHookPoint *HP_strlib_safestrnlen__post; + struct HPMHookPoint *HP_strlib_strline__pre; + struct HPMHookPoint *HP_strlib_strline__post; + struct HPMHookPoint *HP_strlib_bin2hex__pre; + struct HPMHookPoint *HP_strlib_bin2hex__post; + struct HPMHookPoint *HP_sv_parse_next_pre; + struct HPMHookPoint *HP_sv_parse_next_post; + struct HPMHookPoint *HP_sv_parse_pre; + struct HPMHookPoint *HP_sv_parse_post; + struct HPMHookPoint *HP_sv_split_pre; + struct HPMHookPoint *HP_sv_split_post; + struct HPMHookPoint *HP_sv_escape_c_pre; + struct HPMHookPoint *HP_sv_escape_c_post; + struct HPMHookPoint *HP_sv_unescape_c_pre; + struct HPMHookPoint *HP_sv_unescape_c_post; + struct HPMHookPoint *HP_sv_skip_escaped_c_pre; + struct HPMHookPoint *HP_sv_skip_escaped_c_post; + struct HPMHookPoint *HP_sv_readdb_pre; + struct HPMHookPoint *HP_sv_readdb_post; + struct HPMHookPoint *HP_sysinfo_getpagesize_pre; + struct HPMHookPoint *HP_sysinfo_getpagesize_post; + struct HPMHookPoint *HP_sysinfo_platform_pre; + struct HPMHookPoint *HP_sysinfo_platform_post; + struct HPMHookPoint *HP_sysinfo_osversion_pre; + struct HPMHookPoint *HP_sysinfo_osversion_post; + struct HPMHookPoint *HP_sysinfo_cpu_pre; + struct HPMHookPoint *HP_sysinfo_cpu_post; + struct HPMHookPoint *HP_sysinfo_cpucores_pre; + struct HPMHookPoint *HP_sysinfo_cpucores_post; + struct HPMHookPoint *HP_sysinfo_arch_pre; + struct HPMHookPoint *HP_sysinfo_arch_post; + struct HPMHookPoint *HP_sysinfo_is64bit_pre; + struct HPMHookPoint *HP_sysinfo_is64bit_post; + struct HPMHookPoint *HP_sysinfo_compiler_pre; + struct HPMHookPoint *HP_sysinfo_compiler_post; + struct HPMHookPoint *HP_sysinfo_cflags_pre; + struct HPMHookPoint *HP_sysinfo_cflags_post; + struct HPMHookPoint *HP_sysinfo_vcstype_pre; + struct HPMHookPoint *HP_sysinfo_vcstype_post; + struct HPMHookPoint *HP_sysinfo_vcstypeid_pre; + struct HPMHookPoint *HP_sysinfo_vcstypeid_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_src_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_src_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_scripts_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_scripts_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_reload_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_reload_post; + struct HPMHookPoint *HP_sysinfo_is_superuser_pre; + struct HPMHookPoint *HP_sysinfo_is_superuser_post; + struct HPMHookPoint *HP_sysinfo_init_pre; + struct HPMHookPoint *HP_sysinfo_init_post; + struct HPMHookPoint *HP_sysinfo_final_pre; + struct HPMHookPoint *HP_sysinfo_final_post; + struct HPMHookPoint *HP_timer_gettick_pre; + struct HPMHookPoint *HP_timer_gettick_post; + struct HPMHookPoint *HP_timer_gettick_nocache_pre; + struct HPMHookPoint *HP_timer_gettick_nocache_post; + struct HPMHookPoint *HP_timer_add_pre; + struct HPMHookPoint *HP_timer_add_post; + struct HPMHookPoint *HP_timer_add_interval_pre; + struct HPMHookPoint *HP_timer_add_interval_post; + struct HPMHookPoint *HP_timer_get_pre; + struct HPMHookPoint *HP_timer_get_post; + struct HPMHookPoint *HP_timer_delete_pre; + struct HPMHookPoint *HP_timer_delete_post; + struct HPMHookPoint *HP_timer_addtick_pre; + struct HPMHookPoint *HP_timer_addtick_post; + struct HPMHookPoint *HP_timer_settick_pre; + struct HPMHookPoint *HP_timer_settick_post; + struct HPMHookPoint *HP_timer_add_func_list_pre; + struct HPMHookPoint *HP_timer_add_func_list_post; + struct HPMHookPoint *HP_timer_get_uptime_pre; + struct HPMHookPoint *HP_timer_get_uptime_post; + struct HPMHookPoint *HP_timer_perform_pre; + struct HPMHookPoint *HP_timer_perform_post; + struct HPMHookPoint *HP_timer_init_pre; + struct HPMHookPoint *HP_timer_init_post; + struct HPMHookPoint *HP_timer_final_pre; + struct HPMHookPoint *HP_timer_final_post; } list; struct { + int HP_HCache_init_pre; + int HP_HCache_init_post; + int HP_HCache_check_pre; + int HP_HCache_check_post; + int HP_HCache_open_pre; + int HP_HCache_open_post; int HP_chr_waiting_disconnect_pre; int HP_chr_waiting_disconnect_post; int HP_chr_delete_char_sql_pre; @@ -1118,8 +1600,8 @@ struct { int HP_chr_search_mapserver_post; int HP_chr_mapif_init_pre; int HP_chr_mapif_init_post; - int HP_chr_lan_subnetcheck_pre; - int HP_chr_lan_subnetcheck_post; + int HP_chr_lan_subnet_check_pre; + int HP_chr_lan_subnet_check_post; int HP_chr_delete2_ack_pre; int HP_chr_delete2_ack_post; int HP_chr_delete2_accept_actual_ack_pre; @@ -1216,14 +1698,70 @@ struct { int HP_chr_online_data_cleanup_sub_post; int HP_chr_online_data_cleanup_pre; int HP_chr_online_data_cleanup_post; - int HP_chr_lan_config_read_pre; - int HP_chr_lan_config_read_post; int HP_chr_sql_config_read_pre; int HP_chr_sql_config_read_post; int HP_chr_config_dispatch_pre; int HP_chr_config_dispatch_post; int HP_chr_config_read_pre; int HP_chr_config_read_post; + int HP_cmdline_init_pre; + int HP_cmdline_init_post; + int HP_cmdline_final_pre; + int HP_cmdline_final_post; + int HP_cmdline_arg_add_pre; + int HP_cmdline_arg_add_post; + int HP_cmdline_exec_pre; + int HP_cmdline_exec_post; + int HP_cmdline_arg_next_value_pre; + int HP_cmdline_arg_next_value_post; + int HP_cmdline_arg_source_pre; + int HP_cmdline_arg_source_post; + int HP_console_init_pre; + int HP_console_init_post; + int HP_console_final_pre; + int HP_console_final_post; + int HP_console_display_title_pre; + int HP_console_display_title_post; + int HP_core_shutdown_callback_pre; + int HP_core_shutdown_callback_post; + int HP_DB_fix_options_pre; + int HP_DB_fix_options_post; + int HP_DB_default_cmp_pre; + int HP_DB_default_cmp_post; + int HP_DB_default_hash_pre; + int HP_DB_default_hash_post; + int HP_DB_default_release_pre; + int HP_DB_default_release_post; + int HP_DB_custom_release_pre; + int HP_DB_custom_release_post; + int HP_DB_alloc_pre; + int HP_DB_alloc_post; + int HP_DB_i2key_pre; + int HP_DB_i2key_post; + int HP_DB_ui2key_pre; + int HP_DB_ui2key_post; + int HP_DB_str2key_pre; + int HP_DB_str2key_post; + int HP_DB_i642key_pre; + int HP_DB_i642key_post; + int HP_DB_ui642key_pre; + int HP_DB_ui642key_post; + int HP_DB_i2data_pre; + int HP_DB_i2data_post; + int HP_DB_ui2data_pre; + int HP_DB_ui2data_post; + int HP_DB_ptr2data_pre; + int HP_DB_ptr2data_post; + int HP_DB_data2i_pre; + int HP_DB_data2i_post; + int HP_DB_data2ui_pre; + int HP_DB_data2ui_post; + int HP_DB_data2ptr_pre; + int HP_DB_data2ptr_post; + int HP_DB_init_pre; + int HP_DB_init_post; + int HP_DB_final_pre; + int HP_DB_final_post; int HP_geoip_getcountry_pre; int HP_geoip_getcountry_post; int HP_geoip_final_pre; @@ -1422,6 +1960,122 @@ struct { int HP_inter_storage_guild_storage_delete_post; int HP_inter_storage_parse_frommap_pre; int HP_inter_storage_parse_frommap_post; + int HP_libconfig_read_pre; + int HP_libconfig_read_post; + int HP_libconfig_write_pre; + int HP_libconfig_write_post; + int HP_libconfig_set_auto_convert_pre; + int HP_libconfig_set_auto_convert_post; + int HP_libconfig_get_auto_convert_pre; + int HP_libconfig_get_auto_convert_post; + int HP_libconfig_read_string_pre; + int HP_libconfig_read_string_post; + int HP_libconfig_read_file_src_pre; + int HP_libconfig_read_file_src_post; + int HP_libconfig_write_file_pre; + int HP_libconfig_write_file_post; + int HP_libconfig_set_destructor_pre; + int HP_libconfig_set_destructor_post; + int HP_libconfig_set_include_dir_pre; + int HP_libconfig_set_include_dir_post; + int HP_libconfig_init_pre; + int HP_libconfig_init_post; + int HP_libconfig_destroy_pre; + int HP_libconfig_destroy_post; + int HP_libconfig_setting_get_int_pre; + int HP_libconfig_setting_get_int_post; + int HP_libconfig_setting_get_int64_pre; + int HP_libconfig_setting_get_int64_post; + int HP_libconfig_setting_get_float_pre; + int HP_libconfig_setting_get_float_post; + int HP_libconfig_setting_get_bool_pre; + int HP_libconfig_setting_get_bool_post; + int HP_libconfig_setting_get_string_pre; + int HP_libconfig_setting_get_string_post; + int HP_libconfig_setting_lookup_int_pre; + int HP_libconfig_setting_lookup_int_post; + int HP_libconfig_setting_lookup_int64_pre; + int HP_libconfig_setting_lookup_int64_post; + int HP_libconfig_setting_lookup_float_pre; + int HP_libconfig_setting_lookup_float_post; + int HP_libconfig_setting_lookup_bool_pre; + int HP_libconfig_setting_lookup_bool_post; + int HP_libconfig_setting_lookup_string_pre; + int HP_libconfig_setting_lookup_string_post; + int HP_libconfig_setting_set_int_pre; + int HP_libconfig_setting_set_int_post; + int HP_libconfig_setting_set_int64_pre; + int HP_libconfig_setting_set_int64_post; + int HP_libconfig_setting_set_float_pre; + int HP_libconfig_setting_set_float_post; + int HP_libconfig_setting_set_bool_pre; + int HP_libconfig_setting_set_bool_post; + int HP_libconfig_setting_set_string_pre; + int HP_libconfig_setting_set_string_post; + int HP_libconfig_setting_set_format_pre; + int HP_libconfig_setting_set_format_post; + int HP_libconfig_setting_get_format_pre; + int HP_libconfig_setting_get_format_post; + int HP_libconfig_setting_get_int_elem_pre; + int HP_libconfig_setting_get_int_elem_post; + int HP_libconfig_setting_get_int64_elem_pre; + int HP_libconfig_setting_get_int64_elem_post; + int HP_libconfig_setting_get_float_elem_pre; + int HP_libconfig_setting_get_float_elem_post; + int HP_libconfig_setting_get_bool_elem_pre; + int HP_libconfig_setting_get_bool_elem_post; + int HP_libconfig_setting_get_string_elem_pre; + int HP_libconfig_setting_get_string_elem_post; + int HP_libconfig_setting_set_int_elem_pre; + int HP_libconfig_setting_set_int_elem_post; + int HP_libconfig_setting_set_int64_elem_pre; + int HP_libconfig_setting_set_int64_elem_post; + int HP_libconfig_setting_set_float_elem_pre; + int HP_libconfig_setting_set_float_elem_post; + int HP_libconfig_setting_set_bool_elem_pre; + int HP_libconfig_setting_set_bool_elem_post; + int HP_libconfig_setting_set_string_elem_pre; + int HP_libconfig_setting_set_string_elem_post; + int HP_libconfig_setting_index_pre; + int HP_libconfig_setting_index_post; + int HP_libconfig_setting_length_pre; + int HP_libconfig_setting_length_post; + int HP_libconfig_setting_get_elem_pre; + int HP_libconfig_setting_get_elem_post; + int HP_libconfig_setting_get_member_pre; + int HP_libconfig_setting_get_member_post; + int HP_libconfig_setting_add_pre; + int HP_libconfig_setting_add_post; + int HP_libconfig_setting_remove_pre; + int HP_libconfig_setting_remove_post; + int HP_libconfig_setting_remove_elem_pre; + int HP_libconfig_setting_remove_elem_post; + int HP_libconfig_setting_set_hook_pre; + int HP_libconfig_setting_set_hook_post; + int HP_libconfig_lookup_pre; + int HP_libconfig_lookup_post; + int HP_libconfig_lookup_from_pre; + int HP_libconfig_lookup_from_post; + int HP_libconfig_lookup_int_pre; + int HP_libconfig_lookup_int_post; + int HP_libconfig_lookup_int64_pre; + int HP_libconfig_lookup_int64_post; + int HP_libconfig_lookup_float_pre; + int HP_libconfig_lookup_float_post; + int HP_libconfig_lookup_bool_pre; + int HP_libconfig_lookup_bool_post; + int HP_libconfig_lookup_string_pre; + int HP_libconfig_lookup_string_post; + int HP_libconfig_read_file_pre; + int HP_libconfig_read_file_post; + int HP_libconfig_setting_copy_simple_pre; + int HP_libconfig_setting_copy_simple_post; + int HP_libconfig_setting_copy_elem_pre; + int HP_libconfig_setting_copy_elem_post; + int HP_libconfig_setting_copy_aggregate_pre; + int HP_libconfig_setting_copy_aggregate_post; + int HP_libconfig_setting_copy_pre; + int HP_libconfig_setting_copy_post; int HP_loginif_init_pre; int HP_loginif_init_post; int HP_loginif_final_pre; @@ -1448,6 +2102,32 @@ struct { int HP_loginif_send_users_count_post; int HP_loginif_connect_to_server_pre; int HP_loginif_connect_to_server_post; + int HP_iMalloc_init_pre; + int HP_iMalloc_init_post; + int HP_iMalloc_final_pre; + int HP_iMalloc_final_post; + int HP_iMalloc_malloc_pre; + int HP_iMalloc_malloc_post; + int HP_iMalloc_calloc_pre; + int HP_iMalloc_calloc_post; + int HP_iMalloc_realloc_pre; + int HP_iMalloc_realloc_post; + int HP_iMalloc_reallocz_pre; + int HP_iMalloc_reallocz_post; + int HP_iMalloc_astrdup_pre; + int HP_iMalloc_astrdup_post; + int HP_iMalloc_free_pre; + int HP_iMalloc_free_post; + int HP_iMalloc_memory_check_pre; + int HP_iMalloc_memory_check_post; + int HP_iMalloc_verify_ptr_pre; + int HP_iMalloc_verify_ptr_post; + int HP_iMalloc_usage_pre; + int HP_iMalloc_usage_post; + int HP_iMalloc_post_shutdown_pre; + int HP_iMalloc_post_shutdown_post; + int HP_iMalloc_init_messages_pre; + int HP_iMalloc_init_messages_post; int HP_mapif_ban_pre; int HP_mapif_ban_post; int HP_mapif_server_init_pre; @@ -1780,6 +2460,26 @@ struct { int HP_mapif_namechange_ack_post; int HP_mapif_parse_NameChangeRequest_pre; int HP_mapif_parse_NameChangeRequest_post; + int HP_mapindex_init_pre; + int HP_mapindex_init_post; + int HP_mapindex_final_pre; + int HP_mapindex_final_post; + int HP_mapindex_addmap_pre; + int HP_mapindex_addmap_post; + int HP_mapindex_removemap_pre; + int HP_mapindex_removemap_post; + int HP_mapindex_getmapname_pre; + int HP_mapindex_getmapname_post; + int HP_mapindex_getmapname_ext_pre; + int HP_mapindex_getmapname_ext_post; + int HP_mapindex_name2id_pre; + int HP_mapindex_name2id_post; + int HP_mapindex_id2name_pre; + int HP_mapindex_id2name_post; + int HP_mapindex_check_default_pre; + int HP_mapindex_check_default_post; + int HP_nullpo_assert_report_pre; + int HP_nullpo_assert_report_post; int HP_pincode_handle_pre; int HP_pincode_handle_post; int HP_pincode_decrypt_pre; @@ -1800,10 +2500,267 @@ struct { int HP_pincode_check_post; int HP_pincode_config_read_pre; int HP_pincode_config_read_post; + int HP_showmsg_init_pre; + int HP_showmsg_init_post; + int HP_showmsg_final_pre; + int HP_showmsg_final_post; + int HP_showmsg_clearScreen_pre; + int HP_showmsg_clearScreen_post; + int HP_showmsg_showMessageV_pre; + int HP_showmsg_showMessageV_post; + int HP_sockt_init_pre; + int HP_sockt_init_post; + int HP_sockt_final_pre; + int HP_sockt_final_post; + int HP_sockt_perform_pre; + int HP_sockt_perform_post; + int HP_sockt_datasync_pre; + int HP_sockt_datasync_post; + int HP_sockt_make_listen_bind_pre; + int HP_sockt_make_listen_bind_post; + int HP_sockt_make_connection_pre; + int HP_sockt_make_connection_post; + int HP_sockt_realloc_fifo_pre; + int HP_sockt_realloc_fifo_post; + int HP_sockt_realloc_writefifo_pre; + int HP_sockt_realloc_writefifo_post; + int HP_sockt_wfifoset_pre; + int HP_sockt_wfifoset_post; + int HP_sockt_rfifoskip_pre; + int HP_sockt_rfifoskip_post; + int HP_sockt_close_pre; + int HP_sockt_close_post; + int HP_sockt_session_is_valid_pre; + int HP_sockt_session_is_valid_post; + int HP_sockt_session_is_active_pre; + int HP_sockt_session_is_active_post; + int HP_sockt_flush_pre; + int HP_sockt_flush_post; + int HP_sockt_flush_fifos_pre; + int HP_sockt_flush_fifos_post; + int HP_sockt_set_nonblocking_pre; + int HP_sockt_set_nonblocking_post; + int HP_sockt_set_defaultparse_pre; + int HP_sockt_set_defaultparse_post; + int HP_sockt_host2ip_pre; + int HP_sockt_host2ip_post; + int HP_sockt_ip2str_pre; + int HP_sockt_ip2str_post; + int HP_sockt_str2ip_pre; + int HP_sockt_str2ip_post; + int HP_sockt_ntows_pre; + int HP_sockt_ntows_post; + int HP_sockt_getips_pre; + int HP_sockt_getips_post; + int HP_sockt_eof_pre; + int HP_sockt_eof_post; + int HP_sockt_lan_subnet_check_pre; + int HP_sockt_lan_subnet_check_post; + int HP_sockt_allowed_ip_check_pre; + int HP_sockt_allowed_ip_check_post; + int HP_sockt_trusted_ip_check_pre; + int HP_sockt_trusted_ip_check_post; + int HP_sockt_net_config_read_sub_pre; + int HP_sockt_net_config_read_sub_post; + int HP_sockt_net_config_read_pre; + int HP_sockt_net_config_read_post; + int HP_SQL_Connect_pre; + int HP_SQL_Connect_post; + int HP_SQL_GetTimeout_pre; + int HP_SQL_GetTimeout_post; + int HP_SQL_GetColumnNames_pre; + int HP_SQL_GetColumnNames_post; + int HP_SQL_SetEncoding_pre; + int HP_SQL_SetEncoding_post; + int HP_SQL_Ping_pre; + int HP_SQL_Ping_post; + int HP_SQL_EscapeString_pre; + int HP_SQL_EscapeString_post; + int HP_SQL_EscapeStringLen_pre; + int HP_SQL_EscapeStringLen_post; + int HP_SQL_QueryV_pre; + int HP_SQL_QueryV_post; + int HP_SQL_QueryStr_pre; + int HP_SQL_QueryStr_post; + int HP_SQL_LastInsertId_pre; + int HP_SQL_LastInsertId_post; + int HP_SQL_NumColumns_pre; + int HP_SQL_NumColumns_post; + int HP_SQL_NumRows_pre; + int HP_SQL_NumRows_post; + int HP_SQL_NextRow_pre; + int HP_SQL_NextRow_post; + int HP_SQL_GetData_pre; + int HP_SQL_GetData_post; + int HP_SQL_FreeResult_pre; + int HP_SQL_FreeResult_post; + int HP_SQL_ShowDebug__pre; + int HP_SQL_ShowDebug__post; + int HP_SQL_Free_pre; + int HP_SQL_Free_post; + int HP_SQL_Malloc_pre; + int HP_SQL_Malloc_post; + int HP_SQL_StmtMalloc_pre; + int HP_SQL_StmtMalloc_post; + int HP_SQL_StmtPrepareV_pre; + int HP_SQL_StmtPrepareV_post; + int HP_SQL_StmtPrepareStr_pre; + int HP_SQL_StmtPrepareStr_post; + int HP_SQL_StmtNumParams_pre; + int HP_SQL_StmtNumParams_post; + int HP_SQL_StmtBindParam_pre; + int HP_SQL_StmtBindParam_post; + int HP_SQL_StmtExecute_pre; + int HP_SQL_StmtExecute_post; + int HP_SQL_StmtLastInsertId_pre; + int HP_SQL_StmtLastInsertId_post; + int HP_SQL_StmtNumColumns_pre; + int HP_SQL_StmtNumColumns_post; + int HP_SQL_StmtBindColumn_pre; + int HP_SQL_StmtBindColumn_post; + int HP_SQL_StmtNumRows_pre; + int HP_SQL_StmtNumRows_post; + int HP_SQL_StmtNextRow_pre; + int HP_SQL_StmtNextRow_post; + int HP_SQL_StmtFreeResult_pre; + int HP_SQL_StmtFreeResult_post; + int HP_SQL_StmtFree_pre; + int HP_SQL_StmtFree_post; + int HP_SQL_StmtShowDebug__pre; + int HP_SQL_StmtShowDebug__post; + int HP_StrBuf_Malloc_pre; + int HP_StrBuf_Malloc_post; + int HP_StrBuf_Init_pre; + int HP_StrBuf_Init_post; + int HP_StrBuf_Vprintf_pre; + int HP_StrBuf_Vprintf_post; + int HP_StrBuf_Append_pre; + int HP_StrBuf_Append_post; + int HP_StrBuf_AppendStr_pre; + int HP_StrBuf_AppendStr_post; + int HP_StrBuf_Length_pre; + int HP_StrBuf_Length_post; + int HP_StrBuf_Value_pre; + int HP_StrBuf_Value_post; + int HP_StrBuf_Clear_pre; + int HP_StrBuf_Clear_post; + int HP_StrBuf_Destroy_pre; + int HP_StrBuf_Destroy_post; + int HP_StrBuf_Free_pre; + int HP_StrBuf_Free_post; + int HP_strlib_jstrescape_pre; + int HP_strlib_jstrescape_post; + int HP_strlib_jstrescapecpy_pre; + int HP_strlib_jstrescapecpy_post; + int HP_strlib_jmemescapecpy_pre; + int HP_strlib_jmemescapecpy_post; + int HP_strlib_remove_control_chars__pre; + int HP_strlib_remove_control_chars__post; + int HP_strlib_trim__pre; + int HP_strlib_trim__post; + int HP_strlib_normalize_name__pre; + int HP_strlib_normalize_name__post; + int HP_strlib_stristr__pre; + int HP_strlib_stristr__post; + int HP_strlib_strnlen__pre; + int HP_strlib_strnlen__post; + int HP_strlib_strtok_r__pre; + int HP_strlib_strtok_r__post; + int HP_strlib_e_mail_check__pre; + int HP_strlib_e_mail_check__post; + int HP_strlib_config_switch__pre; + int HP_strlib_config_switch__post; + int HP_strlib_safestrncpy__pre; + int HP_strlib_safestrncpy__post; + int HP_strlib_safestrnlen__pre; + int HP_strlib_safestrnlen__post; + int HP_strlib_strline__pre; + int HP_strlib_strline__post; + int HP_strlib_bin2hex__pre; + int HP_strlib_bin2hex__post; + int HP_sv_parse_next_pre; + int HP_sv_parse_next_post; + int HP_sv_parse_pre; + int HP_sv_parse_post; + int HP_sv_split_pre; + int HP_sv_split_post; + int HP_sv_escape_c_pre; + int HP_sv_escape_c_post; + int HP_sv_unescape_c_pre; + int HP_sv_unescape_c_post; + int HP_sv_skip_escaped_c_pre; + int HP_sv_skip_escaped_c_post; + int HP_sv_readdb_pre; + int HP_sv_readdb_post; + int HP_sysinfo_getpagesize_pre; + int HP_sysinfo_getpagesize_post; + int HP_sysinfo_platform_pre; + int HP_sysinfo_platform_post; + int HP_sysinfo_osversion_pre; + int HP_sysinfo_osversion_post; + int HP_sysinfo_cpu_pre; + int HP_sysinfo_cpu_post; + int HP_sysinfo_cpucores_pre; + int HP_sysinfo_cpucores_post; + int HP_sysinfo_arch_pre; + int HP_sysinfo_arch_post; + int HP_sysinfo_is64bit_pre; + int HP_sysinfo_is64bit_post; + int HP_sysinfo_compiler_pre; + int HP_sysinfo_compiler_post; + int HP_sysinfo_cflags_pre; + int HP_sysinfo_cflags_post; + int HP_sysinfo_vcstype_pre; + int HP_sysinfo_vcstype_post; + int HP_sysinfo_vcstypeid_pre; + int HP_sysinfo_vcstypeid_post; + int HP_sysinfo_vcsrevision_src_pre; + int HP_sysinfo_vcsrevision_src_post; + int HP_sysinfo_vcsrevision_scripts_pre; + int HP_sysinfo_vcsrevision_scripts_post; + int HP_sysinfo_vcsrevision_reload_pre; + int HP_sysinfo_vcsrevision_reload_post; + int HP_sysinfo_is_superuser_pre; + int HP_sysinfo_is_superuser_post; + int HP_sysinfo_init_pre; + int HP_sysinfo_init_post; + int HP_sysinfo_final_pre; + int HP_sysinfo_final_post; + int HP_timer_gettick_pre; + int HP_timer_gettick_post; + int HP_timer_gettick_nocache_pre; + int HP_timer_gettick_nocache_post; + int HP_timer_add_pre; + int HP_timer_add_post; + int HP_timer_add_interval_pre; + int HP_timer_add_interval_post; + int HP_timer_get_pre; + int HP_timer_get_post; + int HP_timer_delete_pre; + int HP_timer_delete_post; + int HP_timer_addtick_pre; + int HP_timer_addtick_post; + int HP_timer_settick_pre; + int HP_timer_settick_post; + int HP_timer_add_func_list_pre; + int HP_timer_add_func_list_post; + int HP_timer_get_uptime_pre; + int HP_timer_get_uptime_post; + int HP_timer_perform_pre; + int HP_timer_perform_post; + int HP_timer_init_pre; + int HP_timer_init_post; + int HP_timer_final_pre; + int HP_timer_final_post; } count; struct { + struct HCache_interface HCache; struct char_interface chr; + struct cmdline_interface cmdline; + struct console_interface console; + struct core_interface core; + struct db_interface DB; struct geoip_interface geoip; struct inter_auction_interface inter_auction; struct inter_elemental_interface inter_elemental; @@ -1816,7 +2773,19 @@ struct { struct inter_pet_interface inter_pet; struct inter_quest_interface inter_quest; struct inter_storage_interface inter_storage; + struct libconfig_interface libconfig; struct loginif_interface loginif; + struct malloc_interface iMalloc; struct mapif_interface mapif; + struct mapindex_interface mapindex; + struct nullpo_interface nullpo; struct pincode_interface pincode; + struct showmsg_interface showmsg; + struct socket_interface sockt; + struct sql_interface SQL; + struct stringbuf_interface StrBuf; + struct strlib_interface strlib; + struct sv_interface sv; + struct sysinfo_interface sysinfo; + struct timer_interface timer; } source; diff --git a/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc index 631544248..59c82f0e2 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc @@ -5,6 +5,10 @@ // as it will get overwritten. struct HookingPointData HookingPoints[] = { +/* HCache */ + { HP_POP(HCache->init, HP_HCache_init) }, + { HP_POP(HCache->check, HP_HCache_check) }, + { HP_POP(HCache->open, HP_HCache_open) }, /* chr */ { HP_POP(chr->waiting_disconnect, HP_chr_waiting_disconnect) }, { HP_POP(chr->delete_char_sql, HP_chr_delete_char_sql) }, @@ -113,7 +117,7 @@ struct HookingPointData HookingPoints[] = { { HP_POP(chr->parse_frommap, HP_chr_parse_frommap) }, { HP_POP(chr->search_mapserver, HP_chr_search_mapserver) }, { HP_POP(chr->mapif_init, HP_chr_mapif_init) }, - { HP_POP(chr->lan_subnetcheck, HP_chr_lan_subnetcheck) }, + { HP_POP(chr->lan_subnet_check, HP_chr_lan_subnet_check) }, { HP_POP(chr->delete2_ack, HP_chr_delete2_ack) }, { HP_POP(chr->delete2_accept_actual_ack, HP_chr_delete2_accept_actual_ack) }, { HP_POP(chr->delete2_accept_ack, HP_chr_delete2_accept_ack) }, @@ -162,10 +166,42 @@ struct HookingPointData HookingPoints[] = { { HP_POP(chr->check_connect_login_server, HP_chr_check_connect_login_server) }, { HP_POP(chr->online_data_cleanup_sub, HP_chr_online_data_cleanup_sub) }, { HP_POP(chr->online_data_cleanup, HP_chr_online_data_cleanup) }, - { HP_POP(chr->lan_config_read, HP_chr_lan_config_read) }, { HP_POP(chr->sql_config_read, HP_chr_sql_config_read) }, { HP_POP(chr->config_dispatch, HP_chr_config_dispatch) }, { HP_POP(chr->config_read, HP_chr_config_read) }, +/* cmdline */ + { HP_POP(cmdline->init, HP_cmdline_init) }, + { HP_POP(cmdline->final, HP_cmdline_final) }, + { HP_POP(cmdline->arg_add, HP_cmdline_arg_add) }, + { HP_POP(cmdline->exec, HP_cmdline_exec) }, + { HP_POP(cmdline->arg_next_value, HP_cmdline_arg_next_value) }, + { HP_POP(cmdline->arg_source, HP_cmdline_arg_source) }, +/* console */ + { HP_POP(console->init, HP_console_init) }, + { HP_POP(console->final, HP_console_final) }, + { HP_POP(console->display_title, HP_console_display_title) }, +/* core */ + { HP_POP(core->shutdown_callback, HP_core_shutdown_callback) }, +/* DB */ + { HP_POP(DB->fix_options, HP_DB_fix_options) }, + { HP_POP(DB->default_cmp, HP_DB_default_cmp) }, + { HP_POP(DB->default_hash, HP_DB_default_hash) }, + { HP_POP(DB->default_release, HP_DB_default_release) }, + { HP_POP(DB->custom_release, HP_DB_custom_release) }, + { HP_POP(DB->alloc, HP_DB_alloc) }, + { HP_POP(DB->i2key, HP_DB_i2key) }, + { HP_POP(DB->ui2key, HP_DB_ui2key) }, + { HP_POP(DB->str2key, HP_DB_str2key) }, + { HP_POP(DB->i642key, HP_DB_i642key) }, + { HP_POP(DB->ui642key, HP_DB_ui642key) }, + { HP_POP(DB->i2data, HP_DB_i2data) }, + { HP_POP(DB->ui2data, HP_DB_ui2data) }, + { HP_POP(DB->ptr2data, HP_DB_ptr2data) }, + { HP_POP(DB->data2i, HP_DB_data2i) }, + { HP_POP(DB->data2ui, HP_DB_data2ui) }, + { HP_POP(DB->data2ptr, HP_DB_data2ptr) }, + { HP_POP(DB->init, HP_DB_init) }, + { HP_POP(DB->final, HP_DB_final) }, /* geoip */ { HP_POP(geoip->getcountry, HP_geoip_getcountry) }, { HP_POP(geoip->final, HP_geoip_final) }, @@ -277,6 +313,65 @@ struct HookingPointData HookingPoints[] = { { HP_POP(inter_storage->delete_, HP_inter_storage_delete_) }, { HP_POP(inter_storage->guild_storage_delete, HP_inter_storage_guild_storage_delete) }, { HP_POP(inter_storage->parse_frommap, HP_inter_storage_parse_frommap) }, +/* libconfig */ + { HP_POP(libconfig->read, HP_libconfig_read) }, + { HP_POP(libconfig->write, HP_libconfig_write) }, + { HP_POP(libconfig->set_auto_convert, HP_libconfig_set_auto_convert) }, + { HP_POP(libconfig->get_auto_convert, HP_libconfig_get_auto_convert) }, + { HP_POP(libconfig->read_string, HP_libconfig_read_string) }, + { HP_POP(libconfig->read_file_src, HP_libconfig_read_file_src) }, + { HP_POP(libconfig->write_file, HP_libconfig_write_file) }, + { HP_POP(libconfig->set_destructor, HP_libconfig_set_destructor) }, + { HP_POP(libconfig->set_include_dir, HP_libconfig_set_include_dir) }, + { HP_POP(libconfig->init, HP_libconfig_init) }, + { HP_POP(libconfig->destroy, HP_libconfig_destroy) }, + { HP_POP(libconfig->setting_get_int, HP_libconfig_setting_get_int) }, + { HP_POP(libconfig->setting_get_int64, HP_libconfig_setting_get_int64) }, + { HP_POP(libconfig->setting_get_float, HP_libconfig_setting_get_float) }, + { HP_POP(libconfig->setting_get_bool, HP_libconfig_setting_get_bool) }, + { HP_POP(libconfig->setting_get_string, HP_libconfig_setting_get_string) }, + { HP_POP(libconfig->setting_lookup_int, HP_libconfig_setting_lookup_int) }, + { HP_POP(libconfig->setting_lookup_int64, HP_libconfig_setting_lookup_int64) }, + { HP_POP(libconfig->setting_lookup_float, HP_libconfig_setting_lookup_float) }, + { HP_POP(libconfig->setting_lookup_bool, HP_libconfig_setting_lookup_bool) }, + { HP_POP(libconfig->setting_lookup_string, HP_libconfig_setting_lookup_string) }, + { HP_POP(libconfig->setting_set_int, HP_libconfig_setting_set_int) }, + { HP_POP(libconfig->setting_set_int64, HP_libconfig_setting_set_int64) }, + { HP_POP(libconfig->setting_set_float, HP_libconfig_setting_set_float) }, + { HP_POP(libconfig->setting_set_bool, HP_libconfig_setting_set_bool) }, + { HP_POP(libconfig->setting_set_string, HP_libconfig_setting_set_string) }, + { HP_POP(libconfig->setting_set_format, HP_libconfig_setting_set_format) }, + { HP_POP(libconfig->setting_get_format, HP_libconfig_setting_get_format) }, + { HP_POP(libconfig->setting_get_int_elem, HP_libconfig_setting_get_int_elem) }, + { HP_POP(libconfig->setting_get_int64_elem, HP_libconfig_setting_get_int64_elem) }, + { HP_POP(libconfig->setting_get_float_elem, HP_libconfig_setting_get_float_elem) }, + { HP_POP(libconfig->setting_get_bool_elem, HP_libconfig_setting_get_bool_elem) }, + { HP_POP(libconfig->setting_get_string_elem, HP_libconfig_setting_get_string_elem) }, + { HP_POP(libconfig->setting_set_int_elem, HP_libconfig_setting_set_int_elem) }, + { HP_POP(libconfig->setting_set_int64_elem, HP_libconfig_setting_set_int64_elem) }, + { HP_POP(libconfig->setting_set_float_elem, HP_libconfig_setting_set_float_elem) }, + { HP_POP(libconfig->setting_set_bool_elem, HP_libconfig_setting_set_bool_elem) }, + { HP_POP(libconfig->setting_set_string_elem, HP_libconfig_setting_set_string_elem) }, + { HP_POP(libconfig->setting_index, HP_libconfig_setting_index) }, + { HP_POP(libconfig->setting_length, HP_libconfig_setting_length) }, + { HP_POP(libconfig->setting_get_elem, HP_libconfig_setting_get_elem) }, + { HP_POP(libconfig->setting_get_member, HP_libconfig_setting_get_member) }, + { HP_POP(libconfig->setting_add, HP_libconfig_setting_add) }, + { HP_POP(libconfig->setting_remove, HP_libconfig_setting_remove) }, + { HP_POP(libconfig->setting_remove_elem, HP_libconfig_setting_remove_elem) }, + { HP_POP(libconfig->setting_set_hook, HP_libconfig_setting_set_hook) }, + { HP_POP(libconfig->lookup, HP_libconfig_lookup) }, + { HP_POP(libconfig->lookup_from, HP_libconfig_lookup_from) }, + { HP_POP(libconfig->lookup_int, HP_libconfig_lookup_int) }, + { HP_POP(libconfig->lookup_int64, HP_libconfig_lookup_int64) }, + { HP_POP(libconfig->lookup_float, HP_libconfig_lookup_float) }, + { HP_POP(libconfig->lookup_bool, HP_libconfig_lookup_bool) }, + { HP_POP(libconfig->lookup_string, HP_libconfig_lookup_string) }, + { HP_POP(libconfig->read_file, HP_libconfig_read_file) }, + { HP_POP(libconfig->setting_copy_simple, HP_libconfig_setting_copy_simple) }, + { HP_POP(libconfig->setting_copy_elem, HP_libconfig_setting_copy_elem) }, + { HP_POP(libconfig->setting_copy_aggregate, HP_libconfig_setting_copy_aggregate) }, + { HP_POP(libconfig->setting_copy, HP_libconfig_setting_copy) }, /* loginif */ { HP_POP(loginif->init, HP_loginif_init) }, { HP_POP(loginif->final, HP_loginif_final) }, @@ -291,6 +386,20 @@ struct HookingPointData HookingPoints[] = { { HP_POP(loginif->auth, HP_loginif_auth) }, { HP_POP(loginif->send_users_count, HP_loginif_send_users_count) }, { HP_POP(loginif->connect_to_server, HP_loginif_connect_to_server) }, +/* iMalloc */ + { HP_POP(iMalloc->init, HP_iMalloc_init) }, + { HP_POP(iMalloc->final, HP_iMalloc_final) }, + { HP_POP(iMalloc->malloc, HP_iMalloc_malloc) }, + { HP_POP(iMalloc->calloc, HP_iMalloc_calloc) }, + { HP_POP(iMalloc->realloc, HP_iMalloc_realloc) }, + { HP_POP(iMalloc->reallocz, HP_iMalloc_reallocz) }, + { HP_POP(iMalloc->astrdup, HP_iMalloc_astrdup) }, + { HP_POP(iMalloc->free, HP_iMalloc_free) }, + { HP_POP(iMalloc->memory_check, HP_iMalloc_memory_check) }, + { HP_POP(iMalloc->verify_ptr, HP_iMalloc_verify_ptr) }, + { HP_POP(iMalloc->usage, HP_iMalloc_usage) }, + { HP_POP(iMalloc->post_shutdown, HP_iMalloc_post_shutdown) }, + { HP_POP(iMalloc->init_messages, HP_iMalloc_init_messages) }, /* mapif */ { HP_POP(mapif->ban, HP_mapif_ban) }, { HP_POP(mapif->server_init, HP_mapif_server_init) }, @@ -458,6 +567,18 @@ struct HookingPointData HookingPoints[] = { { HP_POP(mapif->parse_RegistryRequest, HP_mapif_parse_RegistryRequest) }, { HP_POP(mapif->namechange_ack, HP_mapif_namechange_ack) }, { HP_POP(mapif->parse_NameChangeRequest, HP_mapif_parse_NameChangeRequest) }, +/* mapindex */ + { HP_POP(mapindex->init, HP_mapindex_init) }, + { HP_POP(mapindex->final, HP_mapindex_final) }, + { HP_POP(mapindex->addmap, HP_mapindex_addmap) }, + { HP_POP(mapindex->removemap, HP_mapindex_removemap) }, + { HP_POP(mapindex->getmapname, HP_mapindex_getmapname) }, + { HP_POP(mapindex->getmapname_ext, HP_mapindex_getmapname_ext) }, + { HP_POP(mapindex->name2id, HP_mapindex_name2id) }, + { HP_POP(mapindex->id2name, HP_mapindex_id2name) }, + { HP_POP(mapindex->check_default, HP_mapindex_check_default) }, +/* nullpo */ + { HP_POP(nullpo->assert_report, HP_nullpo_assert_report) }, /* pincode */ { HP_POP(pincode->handle, HP_pincode_handle) }, { HP_POP(pincode->decrypt, HP_pincode_decrypt) }, @@ -469,6 +590,140 @@ struct HookingPointData HookingPoints[] = { { HP_POP(pincode->compare, HP_pincode_compare) }, { HP_POP(pincode->check, HP_pincode_check) }, { HP_POP(pincode->config_read, HP_pincode_config_read) }, +/* showmsg */ + { HP_POP(showmsg->init, HP_showmsg_init) }, + { HP_POP(showmsg->final, HP_showmsg_final) }, + { HP_POP(showmsg->clearScreen, HP_showmsg_clearScreen) }, + { HP_POP(showmsg->showMessageV, HP_showmsg_showMessageV) }, +/* sockt */ + { HP_POP(sockt->init, HP_sockt_init) }, + { HP_POP(sockt->final, HP_sockt_final) }, + { HP_POP(sockt->perform, HP_sockt_perform) }, + { HP_POP(sockt->datasync, HP_sockt_datasync) }, + { HP_POP(sockt->make_listen_bind, HP_sockt_make_listen_bind) }, + { HP_POP(sockt->make_connection, HP_sockt_make_connection) }, + { HP_POP(sockt->realloc_fifo, HP_sockt_realloc_fifo) }, + { HP_POP(sockt->realloc_writefifo, HP_sockt_realloc_writefifo) }, + { HP_POP(sockt->wfifoset, HP_sockt_wfifoset) }, + { HP_POP(sockt->rfifoskip, HP_sockt_rfifoskip) }, + { HP_POP(sockt->close, HP_sockt_close) }, + { HP_POP(sockt->session_is_valid, HP_sockt_session_is_valid) }, + { HP_POP(sockt->session_is_active, HP_sockt_session_is_active) }, + { HP_POP(sockt->flush, HP_sockt_flush) }, + { HP_POP(sockt->flush_fifos, HP_sockt_flush_fifos) }, + { HP_POP(sockt->set_nonblocking, HP_sockt_set_nonblocking) }, + { HP_POP(sockt->set_defaultparse, HP_sockt_set_defaultparse) }, + { HP_POP(sockt->host2ip, HP_sockt_host2ip) }, + { HP_POP(sockt->ip2str, HP_sockt_ip2str) }, + { HP_POP(sockt->str2ip, HP_sockt_str2ip) }, + { HP_POP(sockt->ntows, HP_sockt_ntows) }, + { HP_POP(sockt->getips, HP_sockt_getips) }, + { HP_POP(sockt->eof, HP_sockt_eof) }, + { HP_POP(sockt->lan_subnet_check, HP_sockt_lan_subnet_check) }, + { HP_POP(sockt->allowed_ip_check, HP_sockt_allowed_ip_check) }, + { HP_POP(sockt->trusted_ip_check, HP_sockt_trusted_ip_check) }, + { HP_POP(sockt->net_config_read_sub, HP_sockt_net_config_read_sub) }, + { HP_POP(sockt->net_config_read, HP_sockt_net_config_read) }, +/* SQL */ + { HP_POP(SQL->Connect, HP_SQL_Connect) }, + { HP_POP(SQL->GetTimeout, HP_SQL_GetTimeout) }, + { HP_POP(SQL->GetColumnNames, HP_SQL_GetColumnNames) }, + { HP_POP(SQL->SetEncoding, HP_SQL_SetEncoding) }, + { HP_POP(SQL->Ping, HP_SQL_Ping) }, + { HP_POP(SQL->EscapeString, HP_SQL_EscapeString) }, + { HP_POP(SQL->EscapeStringLen, HP_SQL_EscapeStringLen) }, + { HP_POP(SQL->QueryV, HP_SQL_QueryV) }, + { HP_POP(SQL->QueryStr, HP_SQL_QueryStr) }, + { HP_POP(SQL->LastInsertId, HP_SQL_LastInsertId) }, + { HP_POP(SQL->NumColumns, HP_SQL_NumColumns) }, + { HP_POP(SQL->NumRows, HP_SQL_NumRows) }, + { HP_POP(SQL->NextRow, HP_SQL_NextRow) }, + { HP_POP(SQL->GetData, HP_SQL_GetData) }, + { HP_POP(SQL->FreeResult, HP_SQL_FreeResult) }, + { HP_POP(SQL->ShowDebug_, HP_SQL_ShowDebug_) }, + { HP_POP(SQL->Free, HP_SQL_Free) }, + { HP_POP(SQL->Malloc, HP_SQL_Malloc) }, + { HP_POP(SQL->StmtMalloc, HP_SQL_StmtMalloc) }, + { HP_POP(SQL->StmtPrepareV, HP_SQL_StmtPrepareV) }, + { HP_POP(SQL->StmtPrepareStr, HP_SQL_StmtPrepareStr) }, + { HP_POP(SQL->StmtNumParams, HP_SQL_StmtNumParams) }, + { HP_POP(SQL->StmtBindParam, HP_SQL_StmtBindParam) }, + { HP_POP(SQL->StmtExecute, HP_SQL_StmtExecute) }, + { HP_POP(SQL->StmtLastInsertId, HP_SQL_StmtLastInsertId) }, + { HP_POP(SQL->StmtNumColumns, HP_SQL_StmtNumColumns) }, + { HP_POP(SQL->StmtBindColumn, HP_SQL_StmtBindColumn) }, + { HP_POP(SQL->StmtNumRows, HP_SQL_StmtNumRows) }, + { HP_POP(SQL->StmtNextRow, HP_SQL_StmtNextRow) }, + { HP_POP(SQL->StmtFreeResult, HP_SQL_StmtFreeResult) }, + { HP_POP(SQL->StmtFree, HP_SQL_StmtFree) }, + { HP_POP(SQL->StmtShowDebug_, HP_SQL_StmtShowDebug_) }, +/* StrBuf */ + { HP_POP(StrBuf->Malloc, HP_StrBuf_Malloc) }, + { HP_POP(StrBuf->Init, HP_StrBuf_Init) }, + { HP_POP(StrBuf->Vprintf, HP_StrBuf_Vprintf) }, + { HP_POP(StrBuf->Append, HP_StrBuf_Append) }, + { HP_POP(StrBuf->AppendStr, HP_StrBuf_AppendStr) }, + { HP_POP(StrBuf->Length, HP_StrBuf_Length) }, + { HP_POP(StrBuf->Value, HP_StrBuf_Value) }, + { HP_POP(StrBuf->Clear, HP_StrBuf_Clear) }, + { HP_POP(StrBuf->Destroy, HP_StrBuf_Destroy) }, + { HP_POP(StrBuf->Free, HP_StrBuf_Free) }, +/* strlib */ + { HP_POP(strlib->jstrescape, HP_strlib_jstrescape) }, + { HP_POP(strlib->jstrescapecpy, HP_strlib_jstrescapecpy) }, + { HP_POP(strlib->jmemescapecpy, HP_strlib_jmemescapecpy) }, + { HP_POP(strlib->remove_control_chars_, HP_strlib_remove_control_chars_) }, + { HP_POP(strlib->trim_, HP_strlib_trim_) }, + { HP_POP(strlib->normalize_name_, HP_strlib_normalize_name_) }, + { HP_POP(strlib->stristr_, HP_strlib_stristr_) }, + { HP_POP(strlib->strnlen_, HP_strlib_strnlen_) }, + { HP_POP(strlib->strtok_r_, HP_strlib_strtok_r_) }, + { HP_POP(strlib->e_mail_check_, HP_strlib_e_mail_check_) }, + { HP_POP(strlib->config_switch_, HP_strlib_config_switch_) }, + { HP_POP(strlib->safestrncpy_, HP_strlib_safestrncpy_) }, + { HP_POP(strlib->safestrnlen_, HP_strlib_safestrnlen_) }, + { HP_POP(strlib->strline_, HP_strlib_strline_) }, + { HP_POP(strlib->bin2hex_, HP_strlib_bin2hex_) }, +/* sv */ + { HP_POP(sv->parse_next, HP_sv_parse_next) }, + { HP_POP(sv->parse, HP_sv_parse) }, + { HP_POP(sv->split, HP_sv_split) }, + { HP_POP(sv->escape_c, HP_sv_escape_c) }, + { HP_POP(sv->unescape_c, HP_sv_unescape_c) }, + { HP_POP(sv->skip_escaped_c, HP_sv_skip_escaped_c) }, + { HP_POP(sv->readdb, HP_sv_readdb) }, +/* sysinfo */ + { HP_POP(sysinfo->getpagesize, HP_sysinfo_getpagesize) }, + { HP_POP(sysinfo->platform, HP_sysinfo_platform) }, + { HP_POP(sysinfo->osversion, HP_sysinfo_osversion) }, + { HP_POP(sysinfo->cpu, HP_sysinfo_cpu) }, + { HP_POP(sysinfo->cpucores, HP_sysinfo_cpucores) }, + { HP_POP(sysinfo->arch, HP_sysinfo_arch) }, + { HP_POP(sysinfo->is64bit, HP_sysinfo_is64bit) }, + { HP_POP(sysinfo->compiler, HP_sysinfo_compiler) }, + { HP_POP(sysinfo->cflags, HP_sysinfo_cflags) }, + { HP_POP(sysinfo->vcstype, HP_sysinfo_vcstype) }, + { HP_POP(sysinfo->vcstypeid, HP_sysinfo_vcstypeid) }, + { HP_POP(sysinfo->vcsrevision_src, HP_sysinfo_vcsrevision_src) }, + { HP_POP(sysinfo->vcsrevision_scripts, HP_sysinfo_vcsrevision_scripts) }, + { HP_POP(sysinfo->vcsrevision_reload, HP_sysinfo_vcsrevision_reload) }, + { HP_POP(sysinfo->is_superuser, HP_sysinfo_is_superuser) }, + { HP_POP(sysinfo->init, HP_sysinfo_init) }, + { HP_POP(sysinfo->final, HP_sysinfo_final) }, +/* timer */ + { HP_POP(timer->gettick, HP_timer_gettick) }, + { HP_POP(timer->gettick_nocache, HP_timer_gettick_nocache) }, + { HP_POP(timer->add, HP_timer_add) }, + { HP_POP(timer->add_interval, HP_timer_add_interval) }, + { HP_POP(timer->get, HP_timer_get) }, + { HP_POP(timer->delete, HP_timer_delete) }, + { HP_POP(timer->addtick, HP_timer_addtick) }, + { HP_POP(timer->settick, HP_timer_settick) }, + { HP_POP(timer->add_func_list, HP_timer_add_func_list) }, + { HP_POP(timer->get_uptime, HP_timer_get_uptime) }, + { HP_POP(timer->perform, HP_timer_perform) }, + { HP_POP(timer->init, HP_timer_init) }, + { HP_POP(timer->final, HP_timer_final) }, }; int HookingPointsLenMax = 42; diff --git a/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc index d1bff9280..2e35992bc 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc @@ -4,6 +4,87 @@ // NOTE: This file was auto-generated and should never be manually edited, // as it will get overwritten. +/* HCache */ +void HP_HCache_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_HCache_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.HCache.init(); + } + if( HPMHooks.count.HP_HCache_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_HCache_check(const char *file) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_HCache_check_pre ) { + bool (*preHookFunc) (const char *file); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_check_pre[hIndex].func; + retVal___ = preHookFunc(file); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.HCache.check(file); + } + if( HPMHooks.count.HP_HCache_check_post ) { + bool (*postHookFunc) (bool retVal___, const char *file); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file); + } + } + return retVal___; +} +FILE* HP_HCache_open(const char *file, const char *opt) { + int hIndex = 0; + FILE* retVal___ = NULL; + if( HPMHooks.count.HP_HCache_open_pre ) { + FILE* (*preHookFunc) (const char *file, const char *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_open_pre[hIndex].func; + retVal___ = preHookFunc(file, opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.HCache.open(file, opt); + } + if( HPMHooks.count.HP_HCache_open_post ) { + FILE* (*postHookFunc) (FILE* retVal___, const char *file, const char *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_open_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file, opt); + } + } + return retVal___; +} /* chr */ int HP_chr_waiting_disconnect(int tid, int64 tick, int id, intptr_t data) { int hIndex = 0; @@ -2847,14 +2928,14 @@ int HP_chr_mapif_init(int fd) { } return retVal___; } -int HP_chr_lan_subnetcheck(uint32 ip) { +uint32 HP_chr_lan_subnet_check(uint32 ip) { int hIndex = 0; - int retVal___ = 0; - if( HPMHooks.count.HP_chr_lan_subnetcheck_pre ) { - int (*preHookFunc) (uint32 *ip); + uint32 retVal___ = 0; + if( HPMHooks.count.HP_chr_lan_subnet_check_pre ) { + uint32 (*preHookFunc) (uint32 *ip); *HPMforce_return = false; - for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_lan_subnetcheck_pre; hIndex++ ) { - preHookFunc = HPMHooks.list.HP_chr_lan_subnetcheck_pre[hIndex].func; + for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_lan_subnet_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_chr_lan_subnet_check_pre[hIndex].func; retVal___ = preHookFunc(&ip); } if( *HPMforce_return ) { @@ -2863,12 +2944,12 @@ int HP_chr_lan_subnetcheck(uint32 ip) { } } { - retVal___ = HPMHooks.source.chr.lan_subnetcheck(ip); + retVal___ = HPMHooks.source.chr.lan_subnet_check(ip); } - if( HPMHooks.count.HP_chr_lan_subnetcheck_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip); - for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_lan_subnetcheck_post; hIndex++ ) { - postHookFunc = HPMHooks.list.HP_chr_lan_subnetcheck_post[hIndex].func; + if( HPMHooks.count.HP_chr_lan_subnet_check_post ) { + uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_lan_subnet_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_chr_lan_subnet_check_post[hIndex].func; retVal___ = postHookFunc(retVal___, &ip); } } @@ -3707,14 +3788,14 @@ void HP_chr_login_map_server_ack(int fd, uint8 flag) { } return; } -void HP_chr_parse_char_login_map_server(int fd) { +void HP_chr_parse_char_login_map_server(int fd, uint32 ipl) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_login_map_server_pre ) { - void (*preHookFunc) (int *fd); + void (*preHookFunc) (int *fd, uint32 *ipl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_login_map_server_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_login_map_server_pre[hIndex].func; - preHookFunc(&fd); + preHookFunc(&fd, &ipl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3722,13 +3803,13 @@ void HP_chr_parse_char_login_map_server(int fd) { } } { - HPMHooks.source.chr.parse_char_login_map_server(fd); + HPMHooks.source.chr.parse_char_login_map_server(fd, ipl); } if( HPMHooks.count.HP_chr_parse_char_login_map_server_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int *fd, uint32 *ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_login_map_server_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_login_map_server_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(&fd, &ipl); } } return; @@ -4143,33 +4224,6 @@ int HP_chr_online_data_cleanup(int tid, int64 tick, int id, intptr_t data) { } return retVal___; } -int HP_chr_lan_config_read(const char *lancfgName) { - int hIndex = 0; - int retVal___ = 0; - if( HPMHooks.count.HP_chr_lan_config_read_pre ) { - int (*preHookFunc) (const char *lancfgName); - *HPMforce_return = false; - for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_lan_config_read_pre; hIndex++ ) { - preHookFunc = HPMHooks.list.HP_chr_lan_config_read_pre[hIndex].func; - retVal___ = preHookFunc(lancfgName); - } - if( *HPMforce_return ) { - *HPMforce_return = false; - return retVal___; - } - } - { - retVal___ = HPMHooks.source.chr.lan_config_read(lancfgName); - } - if( HPMHooks.count.HP_chr_lan_config_read_post ) { - int (*postHookFunc) (int retVal___, const char *lancfgName); - for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_lan_config_read_post; hIndex++ ) { - postHookFunc = HPMHooks.list.HP_chr_lan_config_read_post[hIndex].func; - retVal___ = postHookFunc(retVal___, lancfgName); - } - } - return retVal___; -} void HP_chr_sql_config_read(const char *cfgName) { int hIndex = 0; if( HPMHooks.count.HP_chr_sql_config_read_pre ) { @@ -4249,6 +4303,793 @@ int HP_chr_config_read(const char *cfgName) { } return retVal___; } +/* cmdline */ +void HP_cmdline_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_cmdline_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.cmdline.init(); + } + if( HPMHooks.count.HP_cmdline_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_cmdline_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_cmdline_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.cmdline.final(); + } + if( HPMHooks.count.HP_cmdline_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_cmdline_arg_add_pre ) { + bool (*preHookFunc) (unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_add_pre[hIndex].func; + retVal___ = preHookFunc(&pluginID, name, &shortname, &func, help, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_add(pluginID, name, shortname, func, help, options); + } + if( HPMHooks.count.HP_cmdline_arg_add_post ) { + bool (*postHookFunc) (bool retVal___, unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &pluginID, name, &shortname, &func, help, &options); + } + } + return retVal___; +} +int HP_cmdline_exec(int argc, char **argv, unsigned int options) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_cmdline_exec_pre ) { + int (*preHookFunc) (int *argc, char **argv, unsigned int *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_exec_pre[hIndex].func; + retVal___ = preHookFunc(&argc, argv, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.exec(argc, argv, options); + } + if( HPMHooks.count.HP_cmdline_exec_post ) { + int (*postHookFunc) (int retVal___, int *argc, char **argv, unsigned int *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_exec_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &argc, argv, &options); + } + } + return retVal___; +} +bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_cmdline_arg_next_value_pre ) { + bool (*preHookFunc) (const char *name, int *current_arg, int *argc); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_pre[hIndex].func; + retVal___ = preHookFunc(name, ¤t_arg, &argc); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_next_value(name, current_arg, argc); + } + if( HPMHooks.count.HP_cmdline_arg_next_value_post ) { + bool (*postHookFunc) (bool retVal___, const char *name, int *current_arg, int *argc); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_post[hIndex].func; + retVal___ = postHookFunc(retVal___, name, ¤t_arg, &argc); + } + } + return retVal___; +} +const char* HP_cmdline_arg_source(struct CmdlineArgData *arg) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_cmdline_arg_source_pre ) { + const char* (*preHookFunc) (struct CmdlineArgData *arg); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_source_pre[hIndex].func; + retVal___ = preHookFunc(arg); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_source(arg); + } + if( HPMHooks.count.HP_cmdline_arg_source_post ) { + const char* (*postHookFunc) (const char* retVal___, struct CmdlineArgData *arg); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_source_post[hIndex].func; + retVal___ = postHookFunc(retVal___, arg); + } + } + return retVal___; +} +/* console */ +void HP_console_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.init(); + } + if( HPMHooks.count.HP_console_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_console_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.final(); + } + if( HPMHooks.count.HP_console_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_console_display_title(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_display_title_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_display_title_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.display_title(); + } + if( HPMHooks.count.HP_console_display_title_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_display_title_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* core */ +void HP_core_shutdown_callback(void) { + int hIndex = 0; + if( HPMHooks.count.HP_core_shutdown_callback_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_core_shutdown_callback_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.core.shutdown_callback(); + } + if( HPMHooks.count.HP_core_shutdown_callback_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_core_shutdown_callback_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* DB */ +DBOptions HP_DB_fix_options(DBType type, DBOptions options) { + int hIndex = 0; + DBOptions retVal___ = DB_OPT_BASE; + if( HPMHooks.count.HP_DB_fix_options_pre ) { + DBOptions (*preHookFunc) (DBType *type, DBOptions *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_fix_options_pre[hIndex].func; + retVal___ = preHookFunc(&type, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.fix_options(type, options); + } + if( HPMHooks.count.HP_DB_fix_options_post ) { + DBOptions (*postHookFunc) (DBOptions retVal___, DBType *type, DBOptions *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_fix_options_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type, &options); + } + } + return retVal___; +} +DBComparator HP_DB_default_cmp(DBType type) { + int hIndex = 0; + DBComparator retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_cmp_pre ) { + DBComparator (*preHookFunc) (DBType *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_cmp_pre[hIndex].func; + retVal___ = preHookFunc(&type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_cmp(type); + } + if( HPMHooks.count.HP_DB_default_cmp_post ) { + DBComparator (*postHookFunc) (DBComparator retVal___, DBType *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_cmp_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type); + } + } + return retVal___; +} +DBHasher HP_DB_default_hash(DBType type) { + int hIndex = 0; + DBHasher retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_hash_pre ) { + DBHasher (*preHookFunc) (DBType *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_hash_pre[hIndex].func; + retVal___ = preHookFunc(&type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_hash(type); + } + if( HPMHooks.count.HP_DB_default_hash_post ) { + DBHasher (*postHookFunc) (DBHasher retVal___, DBType *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_hash_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type); + } + } + return retVal___; +} +DBReleaser HP_DB_default_release(DBType type, DBOptions options) { + int hIndex = 0; + DBReleaser retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_release_pre ) { + DBReleaser (*preHookFunc) (DBType *type, DBOptions *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_release_pre[hIndex].func; + retVal___ = preHookFunc(&type, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_release(type, options); + } + if( HPMHooks.count.HP_DB_default_release_post ) { + DBReleaser (*postHookFunc) (DBReleaser retVal___, DBType *type, DBOptions *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_release_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type, &options); + } + } + return retVal___; +} +DBReleaser HP_DB_custom_release(DBRelease which) { + int hIndex = 0; + DBReleaser retVal___ = NULL; + if( HPMHooks.count.HP_DB_custom_release_pre ) { + DBReleaser (*preHookFunc) (DBRelease *which); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_custom_release_pre[hIndex].func; + retVal___ = preHookFunc(&which); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.custom_release(which); + } + if( HPMHooks.count.HP_DB_custom_release_post ) { + DBReleaser (*postHookFunc) (DBReleaser retVal___, DBRelease *which); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_custom_release_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &which); + } + } + return retVal___; +} +DBMap* HP_DB_alloc(const char *file, const char *func, int line, DBType type, DBOptions options, unsigned short maxlen) { + int hIndex = 0; + DBMap* retVal___ = NULL; + if( HPMHooks.count.HP_DB_alloc_pre ) { + DBMap* (*preHookFunc) (const char *file, const char *func, int *line, DBType *type, DBOptions *options, unsigned short *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_alloc_pre[hIndex].func; + retVal___ = preHookFunc(file, func, &line, &type, &options, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen); + } + if( HPMHooks.count.HP_DB_alloc_post ) { + DBMap* (*postHookFunc) (DBMap* retVal___, const char *file, const char *func, int *line, DBType *type, DBOptions *options, unsigned short *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_alloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file, func, &line, &type, &options, &maxlen); + } + } + return retVal___; +} +DBKey HP_DB_i2key(int key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_i2key_pre ) { + DBKey (*preHookFunc) (int *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i2key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i2key(key); + } + if( HPMHooks.count.HP_DB_i2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, int *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_ui2key(unsigned int key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_ui2key_pre ) { + DBKey (*preHookFunc) (unsigned int *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui2key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui2key(key); + } + if( HPMHooks.count.HP_DB_ui2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, unsigned int *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_str2key(const char *key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_str2key_pre ) { + DBKey (*preHookFunc) (const char *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_str2key_pre[hIndex].func; + retVal___ = preHookFunc(key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.str2key(key); + } + if( HPMHooks.count.HP_DB_str2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, const char *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_str2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, key); + } + } + return retVal___; +} +DBKey HP_DB_i642key(int64 key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_i642key_pre ) { + DBKey (*preHookFunc) (int64 *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i642key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i642key(key); + } + if( HPMHooks.count.HP_DB_i642key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, int64 *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i642key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_ui642key(uint64 key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_ui642key_pre ) { + DBKey (*preHookFunc) (uint64 *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui642key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui642key(key); + } + if( HPMHooks.count.HP_DB_ui642key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, uint64 *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui642key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBData HP_DB_i2data(int data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_i2data_pre ) { + DBData (*preHookFunc) (int *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i2data_pre[hIndex].func; + retVal___ = preHookFunc(&data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i2data(data); + } + if( HPMHooks.count.HP_DB_i2data_post ) { + DBData (*postHookFunc) (DBData retVal___, int *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &data); + } + } + return retVal___; +} +DBData HP_DB_ui2data(unsigned int data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_ui2data_pre ) { + DBData (*preHookFunc) (unsigned int *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui2data_pre[hIndex].func; + retVal___ = preHookFunc(&data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui2data(data); + } + if( HPMHooks.count.HP_DB_ui2data_post ) { + DBData (*postHookFunc) (DBData retVal___, unsigned int *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &data); + } + } + return retVal___; +} +DBData HP_DB_ptr2data(void *data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_ptr2data_pre ) { + DBData (*preHookFunc) (void *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ptr2data_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ptr2data(data); + } + if( HPMHooks.count.HP_DB_ptr2data_post ) { + DBData (*postHookFunc) (DBData retVal___, void *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ptr2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +int HP_DB_data2i(DBData *data) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_DB_data2i_pre ) { + int (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2i_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2i(data); + } + if( HPMHooks.count.HP_DB_data2i_post ) { + int (*postHookFunc) (int retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2i_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +unsigned int HP_DB_data2ui(DBData *data) { + int hIndex = 0; + unsigned int retVal___ = 0; + if( HPMHooks.count.HP_DB_data2ui_pre ) { + unsigned int (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2ui_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2ui(data); + } + if( HPMHooks.count.HP_DB_data2ui_post ) { + unsigned int (*postHookFunc) (unsigned int retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2ui_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +void* HP_DB_data2ptr(DBData *data) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_DB_data2ptr_pre ) { + void* (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2ptr_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2ptr(data); + } + if( HPMHooks.count.HP_DB_data2ptr_post ) { + void* (*postHookFunc) (void* retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2ptr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +void HP_DB_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_DB_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.DB.init(); + } + if( HPMHooks.count.HP_DB_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_DB_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_DB_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.DB.final(); + } + if( HPMHooks.count.HP_DB_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} /* geoip */ const char* HP_geoip_getcountry(uint32 ipnum) { int hIndex = 0; @@ -6937,6 +7778,1563 @@ int HP_inter_storage_parse_frommap(int fd) { } return retVal___; } +/* libconfig */ +int HP_libconfig_read(config_t *config, FILE *stream) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_pre ) { + int (*preHookFunc) (config_t *config, FILE *stream); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_pre[hIndex].func; + retVal___ = preHookFunc(config, stream); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read(config, stream); + } + if( HPMHooks.count.HP_libconfig_read_post ) { + int (*postHookFunc) (int retVal___, config_t *config, FILE *stream); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, stream); + } + } + return retVal___; +} +void HP_libconfig_write(const config_t *config, FILE *stream) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_write_pre ) { + void (*preHookFunc) (const config_t *config, FILE *stream); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_write_pre[hIndex].func; + preHookFunc(config, stream); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.write(config, stream); + } + if( HPMHooks.count.HP_libconfig_write_post ) { + void (*postHookFunc) (const config_t *config, FILE *stream); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_write_post[hIndex].func; + postHookFunc(config, stream); + } + } + return; +} +void HP_libconfig_set_auto_convert(config_t *config, int flag) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_auto_convert_pre ) { + void (*preHookFunc) (config_t *config, int *flag); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_auto_convert_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_auto_convert_pre[hIndex].func; + preHookFunc(config, &flag); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_auto_convert(config, flag); + } + if( HPMHooks.count.HP_libconfig_set_auto_convert_post ) { + void (*postHookFunc) (config_t *config, int *flag); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_auto_convert_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_auto_convert_post[hIndex].func; + postHookFunc(config, &flag); + } + } + return; +} +int HP_libconfig_get_auto_convert(const config_t *config) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_get_auto_convert_pre ) { + int (*preHookFunc) (const config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_auto_convert_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_get_auto_convert_pre[hIndex].func; + retVal___ = preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.get_auto_convert(config); + } + if( HPMHooks.count.HP_libconfig_get_auto_convert_post ) { + int (*postHookFunc) (int retVal___, const config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_auto_convert_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_get_auto_convert_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config); + } + } + return retVal___; +} +int HP_libconfig_read_string(config_t *config, const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_string_pre ) { + int (*preHookFunc) (config_t *config, const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_string_pre[hIndex].func; + retVal___ = preHookFunc(config, str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_string(config, str); + } + if( HPMHooks.count.HP_libconfig_read_string_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, str); + } + } + return retVal___; +} +int HP_libconfig_read_file_src(config_t *config, const char *filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_file_src_pre ) { + int (*preHookFunc) (config_t *config, const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_file_src_pre[hIndex].func; + retVal___ = preHookFunc(config, filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_file_src(config, filename); + } + if( HPMHooks.count.HP_libconfig_read_file_src_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_file_src_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filename); + } + } + return retVal___; +} +int HP_libconfig_write_file(config_t *config, const char *filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_write_file_pre ) { + int (*preHookFunc) (config_t *config, const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_write_file_pre[hIndex].func; + retVal___ = preHookFunc(config, filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.write_file(config, filename); + } + if( HPMHooks.count.HP_libconfig_write_file_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_write_file_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filename); + } + } + return retVal___; +} +void HP_libconfig_set_destructor(config_t *config, void ( *destructor ) (void *)) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_destructor_pre ) { + void (*preHookFunc) (config_t *config, void ( *destructor ) (void *)); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_destructor_pre[hIndex].func; + preHookFunc(config, destructor); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_destructor(config, destructor); + } + if( HPMHooks.count.HP_libconfig_set_destructor_post ) { + void (*postHookFunc) (config_t *config, void ( *destructor ) (void *)); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_destructor_post[hIndex].func; + postHookFunc(config, destructor); + } + } + return; +} +void HP_libconfig_set_include_dir(config_t *config, const char *include_dir) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) { + void (*preHookFunc) (config_t *config, const char *include_dir); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_pre[hIndex].func; + preHookFunc(config, include_dir); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_include_dir(config, include_dir); + } + if( HPMHooks.count.HP_libconfig_set_include_dir_post ) { + void (*postHookFunc) (config_t *config, const char *include_dir); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_post[hIndex].func; + postHookFunc(config, include_dir); + } + } + return; +} +void HP_libconfig_init(config_t *config) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_init_pre ) { + void (*preHookFunc) (config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_init_pre[hIndex].func; + preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.init(config); + } + if( HPMHooks.count.HP_libconfig_init_post ) { + void (*postHookFunc) (config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_init_post[hIndex].func; + postHookFunc(config); + } + } + return; +} +void HP_libconfig_destroy(config_t *config) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_destroy_pre ) { + void (*preHookFunc) (config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_destroy_pre[hIndex].func; + preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.destroy(config); + } + if( HPMHooks.count.HP_libconfig_destroy_post ) { + void (*postHookFunc) (config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_destroy_post[hIndex].func; + postHookFunc(config); + } + } + return; +} +int HP_libconfig_setting_get_int(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_int_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +long long HP_libconfig_setting_get_int64(const config_setting_t *setting) { + int hIndex = 0; + long long retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) { + long long (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int64(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_int64_post ) { + long long (*postHookFunc) (long long retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +double HP_libconfig_setting_get_float(const config_setting_t *setting) { + int hIndex = 0; + double retVal___ = 0.; + if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) { + double (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_float(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_float_post ) { + double (*postHookFunc) (double retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_get_bool(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_bool(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_bool_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +const char* HP_libconfig_setting_get_string(const config_setting_t *setting) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) { + const char* (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_string(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_string_post ) { + const char* (*postHookFunc) (const char* retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_int(const config_setting_t *setting, const char *name, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_int(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_int_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_int64(const config_setting_t *setting, const char *name, long long *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_int64(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_int64_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_float(const config_setting_t *setting, const char *name, double *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_float(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_float_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_bool(const config_setting_t *setting, const char *name, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_bool(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_bool_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_string(const config_setting_t *setting, const char *name, const char **value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, const char **value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_string(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_string_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, const char **value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_int(config_setting_t *setting, int value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) { + int (*preHookFunc) (config_setting_t *setting, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_int64(config_setting_t *setting, long long value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) { + int (*preHookFunc) (config_setting_t *setting, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_float(config_setting_t *setting, double value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) { + int (*preHookFunc) (config_setting_t *setting, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_float_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_bool(config_setting_t *setting, int value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) { + int (*preHookFunc) (config_setting_t *setting, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_string(config_setting_t *setting, const char *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) { + int (*preHookFunc) (config_setting_t *setting, const char *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_pre[hIndex].func; + retVal___ = preHookFunc(setting, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_string(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_string_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, const char *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_format(config_setting_t *setting, short format) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) { + int (*preHookFunc) (config_setting_t *setting, short *format); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_pre[hIndex].func; + retVal___ = preHookFunc(setting, &format); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format); + } + if( HPMHooks.count.HP_libconfig_setting_set_format_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, short *format); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &format); + } + } + return retVal___; +} +short HP_libconfig_setting_get_format(const config_setting_t *setting) { + int hIndex = 0; + short retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) { + short (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_format(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_format_post ) { + short (*postHookFunc) (short retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_get_int_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) { + int (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_int_elem_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +long long HP_libconfig_setting_get_int64_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + long long retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) { + long long (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int64_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_post ) { + long long (*postHookFunc) (long long retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +double HP_libconfig_setting_get_float_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + double retVal___ = 0.; + if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) { + double (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_float_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_float_elem_post ) { + double (*postHookFunc) (double retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +int HP_libconfig_setting_get_bool_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) { + int (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_bool_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +const char* HP_libconfig_setting_get_string_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) { + const char* (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_string_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_string_elem_post ) { + const char* (*postHookFunc) (const char* retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_int_elem(config_setting_t *setting, int idx, int value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_int64_elem(config_setting_t *setting, int idx, long long value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_float_elem(config_setting_t *setting, int idx, double value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_bool_elem(config_setting_t *setting, int idx, int value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_string_elem(config_setting_t *setting, int idx, const char *value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, const char *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, const char *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, value); + } + } + return retVal___; +} +int HP_libconfig_setting_index(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_index_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_index_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_index(setting); + } + if( HPMHooks.count.HP_libconfig_setting_index_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_index_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_length(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_length_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_length_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_length(setting); + } + if( HPMHooks.count.HP_libconfig_setting_length_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_length_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_get_elem(const config_setting_t *setting, unsigned int idx) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) { + config_setting_t* (*preHookFunc) (const config_setting_t *setting, unsigned int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_setting_t *setting, unsigned int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_get_member(const config_setting_t *setting, const char *name) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) { + config_setting_t* (*preHookFunc) (const config_setting_t *setting, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_pre[hIndex].func; + retVal___ = preHookFunc(setting, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_member(setting, name); + } + if( HPMHooks.count.HP_libconfig_setting_get_member_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_setting_t *setting, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_add(config_setting_t *parent, const char *name, int type) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_add_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *parent, const char *name, int *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_add_pre[hIndex].func; + retVal___ = preHookFunc(parent, name, &type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type); + } + if( HPMHooks.count.HP_libconfig_setting_add_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *parent, const char *name, int *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, name, &type); + } + } + return retVal___; +} +int HP_libconfig_setting_remove(config_setting_t *parent, const char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_remove_pre ) { + int (*preHookFunc) (config_setting_t *parent, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_pre[hIndex].func; + retVal___ = preHookFunc(parent, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_remove(parent, name); + } + if( HPMHooks.count.HP_libconfig_setting_remove_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, name); + } + } + return retVal___; +} +int HP_libconfig_setting_remove_elem(config_setting_t *parent, unsigned int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) { + int (*preHookFunc) (config_setting_t *parent, unsigned int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_pre[hIndex].func; + retVal___ = preHookFunc(parent, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx); + } + if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, unsigned int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, &idx); + } + } + return retVal___; +} +void HP_libconfig_setting_set_hook(config_setting_t *setting, void *hook) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) { + void (*preHookFunc) (config_setting_t *setting, void *hook); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_pre[hIndex].func; + preHookFunc(setting, hook); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_set_hook(setting, hook); + } + if( HPMHooks.count.HP_libconfig_setting_set_hook_post ) { + void (*postHookFunc) (config_setting_t *setting, void *hook); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_post[hIndex].func; + postHookFunc(setting, hook); + } + } + return; +} +config_setting_t* HP_libconfig_lookup(const config_t *config, const char *filepath) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_lookup_pre ) { + config_setting_t* (*preHookFunc) (const config_t *config, const char *filepath); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup(config, filepath); + } + if( HPMHooks.count.HP_libconfig_lookup_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_t *config, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_lookup_from(config_setting_t *setting, const char *filepath) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_lookup_from_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, const char *filepath); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_from_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_from_pre[hIndex].func; + retVal___ = preHookFunc(setting, filepath); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_from(setting, filepath); + } + if( HPMHooks.count.HP_libconfig_lookup_from_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_from_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_from_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, filepath); + } + } + return retVal___; +} +int HP_libconfig_lookup_int(const config_t *config, const char *filepath, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_int_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_int_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_int(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_int_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_int64(const config_t *config, const char *filepath, long long *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_int64(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_int64_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_float(const config_t *config, const char *filepath, double *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_float_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_float_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_float(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_float_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_bool(const config_t *config, const char *filepath, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_bool(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_bool_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_string(const config_t *config, const char *filepath, const char **value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_string_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, const char **value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_string_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_string(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_string_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, const char **value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_read_file(config_t *config, const char *config_filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_file_pre ) { + int (*preHookFunc) (config_t *config, const char *config_filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_file_pre[hIndex].func; + retVal___ = preHookFunc(config, config_filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_file(config, config_filename); + } + if( HPMHooks.count.HP_libconfig_read_file_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *config_filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_file_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, config_filename); + } + } + return retVal___; +} +void HP_libconfig_setting_copy_simple(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_simple(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_simple_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +void HP_libconfig_setting_copy_elem(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_elem(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_elem_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +void HP_libconfig_setting_copy_aggregate(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_aggregate(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +int HP_libconfig_setting_copy(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_pre ) { + int (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_pre[hIndex].func; + retVal___ = preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_copy(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, src); + } + } + return retVal___; +} /* loginif */ void HP_loginif_init(void) { int hIndex = 0; @@ -7276,6 +9674,352 @@ void HP_loginif_connect_to_server(void) { } return; } +/* iMalloc */ +void HP_iMalloc_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.init(); + } + if( HPMHooks.count.HP_iMalloc_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_iMalloc_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.final(); + } + if( HPMHooks.count.HP_iMalloc_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_malloc_pre ) { + void* (*preHookFunc) (size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func; + retVal___ = preHookFunc(&size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_malloc_post ) { + void* (*postHookFunc) (void* retVal___, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_calloc_pre ) { + void* (*preHookFunc) (size_t *num, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func; + retVal___ = preHookFunc(&num, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_calloc_post ) { + void* (*postHookFunc) (void* retVal___, size_t *num, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &num, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_realloc_pre ) { + void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func; + retVal___ = preHookFunc(p, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_realloc_post ) { + void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_reallocz_pre ) { + void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func; + retVal___ = preHookFunc(p, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_reallocz_post ) { + void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + } + } + return retVal___; +} +char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char *func) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_astrdup_pre ) { + char* (*preHookFunc) (const char *p, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func; + retVal___ = preHookFunc(p, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_astrdup_post ) { + char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, file, &line, func); + } + } + return retVal___; +} +void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_free_pre ) { + void (*preHookFunc) (void *p, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func; + preHookFunc(p, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.free(p, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_free_post ) { + void (*postHookFunc) (void *p, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func; + postHookFunc(p, file, &line, func); + } + } + return; +} +void HP_iMalloc_memory_check(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_memory_check_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_memory_check_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.memory_check(); + } + if( HPMHooks.count.HP_iMalloc_memory_check_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_memory_check_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_iMalloc_verify_ptr(void *ptr) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) { + bool (*preHookFunc) (void *ptr); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func; + retVal___ = preHookFunc(ptr); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.verify_ptr(ptr); + } + if( HPMHooks.count.HP_iMalloc_verify_ptr_post ) { + bool (*postHookFunc) (bool retVal___, void *ptr); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ptr); + } + } + return retVal___; +} +size_t HP_iMalloc_usage(void) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_iMalloc_usage_pre ) { + size_t (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_usage_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.usage(); + } + if( HPMHooks.count.HP_iMalloc_usage_post ) { + size_t (*postHookFunc) (size_t retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_usage_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_iMalloc_post_shutdown(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_post_shutdown_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.post_shutdown(); + } + if( HPMHooks.count.HP_iMalloc_post_shutdown_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_iMalloc_init_messages(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_init_messages_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_init_messages_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.init_messages(); + } + if( HPMHooks.count.HP_iMalloc_init_messages_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_init_messages_post[hIndex].func; + postHookFunc(); + } + } + return; +} /* mapif */ void HP_mapif_ban(int id, unsigned int flag, int status) { int hIndex = 0; @@ -11693,6 +14437,275 @@ int HP_mapif_parse_NameChangeRequest(int fd) { } return retVal___; } +/* mapindex */ +int HP_mapindex_init(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_mapindex_init_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_init_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.init(); + } + if( HPMHooks.count.HP_mapindex_init_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_init_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_mapindex_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_mapindex_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapindex.final(); + } + if( HPMHooks.count.HP_mapindex_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_mapindex_addmap(int index, const char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_mapindex_addmap_pre ) { + int (*preHookFunc) (int *index, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_addmap_pre[hIndex].func; + retVal___ = preHookFunc(&index, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.addmap(index, name); + } + if( HPMHooks.count.HP_mapindex_addmap_post ) { + int (*postHookFunc) (int retVal___, int *index, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_addmap_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &index, name); + } + } + return retVal___; +} +void HP_mapindex_removemap(int index) { + int hIndex = 0; + if( HPMHooks.count.HP_mapindex_removemap_pre ) { + void (*preHookFunc) (int *index); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_removemap_pre[hIndex].func; + preHookFunc(&index); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapindex.removemap(index); + } + if( HPMHooks.count.HP_mapindex_removemap_post ) { + void (*postHookFunc) (int *index); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_removemap_post[hIndex].func; + postHookFunc(&index); + } + } + return; +} +const char* HP_mapindex_getmapname(const char *string, char *output) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_mapindex_getmapname_pre ) { + const char* (*preHookFunc) (const char *string, char *output); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_getmapname_pre[hIndex].func; + retVal___ = preHookFunc(string, output); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.getmapname(string, output); + } + if( HPMHooks.count.HP_mapindex_getmapname_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *string, char *output); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_getmapname_post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, output); + } + } + return retVal___; +} +const char* HP_mapindex_getmapname_ext(const char *string, char *output) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_mapindex_getmapname_ext_pre ) { + const char* (*preHookFunc) (const char *string, char *output); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_pre[hIndex].func; + retVal___ = preHookFunc(string, output); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.getmapname_ext(string, output); + } + if( HPMHooks.count.HP_mapindex_getmapname_ext_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *string, char *output); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, output); + } + } + return retVal___; +} +unsigned short HP_mapindex_name2id(const char *p1) { + int hIndex = 0; + unsigned short retVal___ = 0; + if( HPMHooks.count.HP_mapindex_name2id_pre ) { + unsigned short (*preHookFunc) (const char *p1); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_name2id_pre[hIndex].func; + retVal___ = preHookFunc(p1); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.name2id(p1); + } + if( HPMHooks.count.HP_mapindex_name2id_post ) { + unsigned short (*postHookFunc) (unsigned short retVal___, const char *p1); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_name2id_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p1); + } + } + return retVal___; +} +const char* HP_mapindex_id2name(uint16 id, const char *file, int line, const char *func) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_mapindex_id2name_pre ) { + const char* (*preHookFunc) (uint16 *id, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_id2name_pre[hIndex].func; + retVal___ = preHookFunc(&id, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.id2name(id, file, line, func); + } + if( HPMHooks.count.HP_mapindex_id2name_post ) { + const char* (*postHookFunc) (const char* retVal___, uint16 *id, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_id2name_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &id, file, &line, func); + } + } + return retVal___; +} +bool HP_mapindex_check_default(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_mapindex_check_default_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_check_default_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_check_default_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.check_default(); + } + if( HPMHooks.count.HP_mapindex_check_default_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_check_default_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_check_default_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +/* nullpo */ +void HP_nullpo_assert_report(const char *file, int line, const char *func, const char *targetname, const char *title) { + int hIndex = 0; + if( HPMHooks.count.HP_nullpo_assert_report_pre ) { + void (*preHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_nullpo_assert_report_pre[hIndex].func; + preHookFunc(file, &line, func, targetname, title); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.nullpo.assert_report(file, line, func, targetname, title); + } + if( HPMHooks.count.HP_nullpo_assert_report_post ) { + void (*postHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_nullpo_assert_report_post[hIndex].func; + postHookFunc(file, &line, func, targetname, title); + } + } + return; +} /* pincode */ void HP_pincode_handle(int fd, struct char_session_data *sd) { int hIndex = 0; @@ -11956,3 +14969,3409 @@ bool HP_pincode_config_read(char *w1, char *w2) { } return retVal___; } +/* showmsg */ +void HP_showmsg_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.init(); + } + if( HPMHooks.count.HP_showmsg_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_showmsg_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.final(); + } + if( HPMHooks.count.HP_showmsg_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_showmsg_clearScreen(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_clearScreen_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_clearScreen_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.clearScreen(); + } + if( HPMHooks.count.HP_showmsg_clearScreen_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_clearScreen_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_showmsg_showMessageV(const char *string, va_list ap) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_showmsg_showMessageV_pre ) { + int (*preHookFunc) (const char *string, va_list ap); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_pre; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + preHookFunc = HPMHooks.list.HP_showmsg_showMessageV_pre[hIndex].func; + retVal___ = preHookFunc(string, ap___copy); + va_end(ap___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list ap___copy; va_copy(ap___copy, ap); + retVal___ = HPMHooks.source.showmsg.showMessageV(string, ap___copy); + va_end(ap___copy); + } + if( HPMHooks.count.HP_showmsg_showMessageV_post ) { + int (*postHookFunc) (int retVal___, const char *string, va_list ap); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_post; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + postHookFunc = HPMHooks.list.HP_showmsg_showMessageV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, ap___copy); + va_end(ap___copy); + } + } + return retVal___; +} +/* sockt */ +void HP_sockt_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.init(); + } + if( HPMHooks.count.HP_sockt_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sockt_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.final(); + } + if( HPMHooks.count.HP_sockt_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_sockt_perform(int next) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_perform_pre ) { + int (*preHookFunc) (int *next); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_perform_pre[hIndex].func; + retVal___ = preHookFunc(&next); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.perform(next); + } + if( HPMHooks.count.HP_sockt_perform_post ) { + int (*postHookFunc) (int retVal___, int *next); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_perform_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &next); + } + } + return retVal___; +} +void HP_sockt_datasync(int fd, bool send) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_datasync_pre ) { + void (*preHookFunc) (int *fd, bool *send); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_datasync_pre[hIndex].func; + preHookFunc(&fd, &send); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.datasync(fd, send); + } + if( HPMHooks.count.HP_sockt_datasync_post ) { + void (*postHookFunc) (int *fd, bool *send); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_datasync_post[hIndex].func; + postHookFunc(&fd, &send); + } + } + return; +} +int HP_sockt_make_listen_bind(uint32 ip, uint16 port) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_make_listen_bind_pre ) { + int (*preHookFunc) (uint32 *ip, uint16 *port); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_pre[hIndex].func; + retVal___ = preHookFunc(&ip, &port); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.make_listen_bind(ip, port); + } + if( HPMHooks.count.HP_sockt_make_listen_bind_post ) { + int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, &port); + } + } + return retVal___; +} +int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_make_connection_pre ) { + int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_make_connection_pre[hIndex].func; + retVal___ = preHookFunc(&ip, &port, opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.make_connection(ip, port, opt); + } + if( HPMHooks.count.HP_sockt_make_connection_post ) { + int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port, struct hSockOpt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_make_connection_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, &port, opt); + } + } + return retVal___; +} +int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_size) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_realloc_fifo_pre ) { + int (*preHookFunc) (int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &rfifo_size, &wfifo_size); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.realloc_fifo(fd, rfifo_size, wfifo_size); + } + if( HPMHooks.count.HP_sockt_realloc_fifo_post ) { + int (*postHookFunc) (int retVal___, int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &rfifo_size, &wfifo_size); + } + } + return retVal___; +} +int HP_sockt_realloc_writefifo(int fd, size_t addition) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_realloc_writefifo_pre ) { + int (*preHookFunc) (int *fd, size_t *addition); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &addition); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.realloc_writefifo(fd, addition); + } + if( HPMHooks.count.HP_sockt_realloc_writefifo_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *addition); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &addition); + } + } + return retVal___; +} +int HP_sockt_wfifoset(int fd, size_t len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_wfifoset_pre ) { + int (*preHookFunc) (int *fd, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_wfifoset_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.wfifoset(fd, len); + } + if( HPMHooks.count.HP_sockt_wfifoset_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &len); + } + } + return retVal___; +} +int HP_sockt_rfifoskip(int fd, size_t len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_rfifoskip_pre ) { + int (*preHookFunc) (int *fd, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_rfifoskip_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len); + } + if( HPMHooks.count.HP_sockt_rfifoskip_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_rfifoskip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &len); + } + } + return retVal___; +} +void HP_sockt_close(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_close_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_close_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.close(fd); + } + if( HPMHooks.count.HP_sockt_close_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_close_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +bool HP_sockt_session_is_valid(int fd) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_session_is_valid_pre ) { + bool (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_session_is_valid_pre[hIndex].func; + retVal___ = preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.session_is_valid(fd); + } + if( HPMHooks.count.HP_sockt_session_is_valid_post ) { + bool (*postHookFunc) (bool retVal___, int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_session_is_valid_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd); + } + } + return retVal___; +} +bool HP_sockt_session_is_active(int fd) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_session_is_active_pre ) { + bool (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_session_is_active_pre[hIndex].func; + retVal___ = preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.session_is_active(fd); + } + if( HPMHooks.count.HP_sockt_session_is_active_post ) { + bool (*postHookFunc) (bool retVal___, int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_session_is_active_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd); + } + } + return retVal___; +} +void HP_sockt_flush(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_flush_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_flush_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.flush(fd); + } + if( HPMHooks.count.HP_sockt_flush_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_flush_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +void HP_sockt_flush_fifos(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_flush_fifos_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_flush_fifos_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.flush_fifos(); + } + if( HPMHooks.count.HP_sockt_flush_fifos_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_flush_fifos_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sockt_set_nonblocking(int fd, unsigned long yes) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_set_nonblocking_pre ) { + void (*preHookFunc) (int *fd, unsigned long *yes); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_pre[hIndex].func; + preHookFunc(&fd, &yes); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.set_nonblocking(fd, yes); + } + if( HPMHooks.count.HP_sockt_set_nonblocking_post ) { + void (*postHookFunc) (int *fd, unsigned long *yes); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_post[hIndex].func; + postHookFunc(&fd, &yes); + } + } + return; +} +void HP_sockt_set_defaultparse(ParseFunc defaultparse) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_set_defaultparse_pre ) { + void (*preHookFunc) (ParseFunc *defaultparse); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_pre[hIndex].func; + preHookFunc(&defaultparse); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.set_defaultparse(defaultparse); + } + if( HPMHooks.count.HP_sockt_set_defaultparse_post ) { + void (*postHookFunc) (ParseFunc *defaultparse); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_post[hIndex].func; + postHookFunc(&defaultparse); + } + } + return; +} +uint32 HP_sockt_host2ip(const char *hostname) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_host2ip_pre ) { + uint32 (*preHookFunc) (const char *hostname); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_host2ip_pre[hIndex].func; + retVal___ = preHookFunc(hostname); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.host2ip(hostname); + } + if( HPMHooks.count.HP_sockt_host2ip_post ) { + uint32 (*postHookFunc) (uint32 retVal___, const char *hostname); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_host2ip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, hostname); + } + } + return retVal___; +} +const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sockt_ip2str_pre ) { + const char* (*preHookFunc) (uint32 *ip, char *ip_str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_ip2str_pre[hIndex].func; + retVal___ = preHookFunc(&ip, ip_str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.ip2str(ip, ip_str); + } + if( HPMHooks.count.HP_sockt_ip2str_post ) { + const char* (*postHookFunc) (const char* retVal___, uint32 *ip, char *ip_str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_ip2str_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, ip_str); + } + } + return retVal___; +} +uint32 HP_sockt_str2ip(const char *ip_str) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_str2ip_pre ) { + uint32 (*preHookFunc) (const char *ip_str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_str2ip_pre[hIndex].func; + retVal___ = preHookFunc(ip_str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.str2ip(ip_str); + } + if( HPMHooks.count.HP_sockt_str2ip_post ) { + uint32 (*postHookFunc) (uint32 retVal___, const char *ip_str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_str2ip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ip_str); + } + } + return retVal___; +} +uint16 HP_sockt_ntows(uint16 netshort) { + int hIndex = 0; + uint16 retVal___ = 0; + if( HPMHooks.count.HP_sockt_ntows_pre ) { + uint16 (*preHookFunc) (uint16 *netshort); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_ntows_pre[hIndex].func; + retVal___ = preHookFunc(&netshort); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.ntows(netshort); + } + if( HPMHooks.count.HP_sockt_ntows_post ) { + uint16 (*postHookFunc) (uint16 retVal___, uint16 *netshort); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_ntows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &netshort); + } + } + return retVal___; +} +int HP_sockt_getips(uint32 *ips, int max) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_getips_pre ) { + int (*preHookFunc) (uint32 *ips, int *max); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_getips_pre[hIndex].func; + retVal___ = preHookFunc(ips, &max); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.getips(ips, max); + } + if( HPMHooks.count.HP_sockt_getips_post ) { + int (*postHookFunc) (int retVal___, uint32 *ips, int *max); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_getips_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ips, &max); + } + } + return retVal___; +} +void HP_sockt_eof(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_eof_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_eof_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.eof(fd); + } + if( HPMHooks.count.HP_sockt_eof_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_eof_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_lan_subnet_check_pre ) { + uint32 (*preHookFunc) (uint32 *ip, struct s_subnet *info); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip, info); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.lan_subnet_check(ip, info); + } + if( HPMHooks.count.HP_sockt_lan_subnet_check_post ) { + uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip, struct s_subnet *info); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, info); + } + } + return retVal___; +} +bool HP_sockt_allowed_ip_check(uint32 ip) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_allowed_ip_check_pre ) { + bool (*preHookFunc) (uint32 *ip); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip); + } + if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) { + bool (*postHookFunc) (bool retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip); + } + } + return retVal___; +} +bool HP_sockt_trusted_ip_check(uint32 ip) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_trusted_ip_check_pre ) { + bool (*preHookFunc) (uint32 *ip); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip); + } + if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) { + bool (*postHookFunc) (bool retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip); + } + } + return retVal___; +} +int HP_sockt_net_config_read_sub(config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) { + int (*preHookFunc) (config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_pre[hIndex].func; + retVal___ = preHookFunc(t, list, count, filename, groupname); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.net_config_read_sub(t, list, count, filename, groupname); + } + if( HPMHooks.count.HP_sockt_net_config_read_sub_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_post[hIndex].func; + retVal___ = postHookFunc(retVal___, t, list, count, filename, groupname); + } + } + return retVal___; +} +void HP_sockt_net_config_read(const char *filename) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_net_config_read_pre ) { + void (*preHookFunc) (const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_net_config_read_pre[hIndex].func; + preHookFunc(filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.net_config_read(filename); + } + if( HPMHooks.count.HP_sockt_net_config_read_post ) { + void (*postHookFunc) (const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_net_config_read_post[hIndex].func; + postHookFunc(filename); + } + } + return; +} +/* SQL */ +int HP_SQL_Connect(Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_Connect_pre ) { + int (*preHookFunc) (Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Connect_pre[hIndex].func; + retVal___ = preHookFunc(self, user, passwd, host, &port, db); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db); + } + if( HPMHooks.count.HP_SQL_Connect_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Connect_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, user, passwd, host, &port, db); + } + } + return retVal___; +} +int HP_SQL_GetTimeout(Sql *self, uint32 *out_timeout) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetTimeout_pre ) { + int (*preHookFunc) (Sql *self, uint32 *out_timeout); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetTimeout_pre[hIndex].func; + retVal___ = preHookFunc(self, out_timeout); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetTimeout(self, out_timeout); + } + if( HPMHooks.count.HP_SQL_GetTimeout_post ) { + int (*postHookFunc) (int retVal___, Sql *self, uint32 *out_timeout); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetTimeout_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_timeout); + } + } + return retVal___; +} +int HP_SQL_GetColumnNames(Sql *self, const char *table, char *out_buf, size_t buf_len, char sep) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) { + int (*preHookFunc) (Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_pre[hIndex].func; + retVal___ = preHookFunc(self, table, out_buf, &buf_len, &sep); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep); + } + if( HPMHooks.count.HP_SQL_GetColumnNames_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, table, out_buf, &buf_len, &sep); + } + } + return retVal___; +} +int HP_SQL_SetEncoding(Sql *self, const char *encoding) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_SetEncoding_pre ) { + int (*preHookFunc) (Sql *self, const char *encoding); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_SetEncoding_pre[hIndex].func; + retVal___ = preHookFunc(self, encoding); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.SetEncoding(self, encoding); + } + if( HPMHooks.count.HP_SQL_SetEncoding_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *encoding); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_SetEncoding_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, encoding); + } + } + return retVal___; +} +int HP_SQL_Ping(Sql *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_Ping_pre ) { + int (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Ping_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Ping(self); + } + if( HPMHooks.count.HP_SQL_Ping_post ) { + int (*postHookFunc) (int retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Ping_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +size_t HP_SQL_EscapeString(Sql *self, char *out_to, const char *from) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_EscapeString_pre ) { + size_t (*preHookFunc) (Sql *self, char *out_to, const char *from); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_EscapeString_pre[hIndex].func; + retVal___ = preHookFunc(self, out_to, from); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.EscapeString(self, out_to, from); + } + if( HPMHooks.count.HP_SQL_EscapeString_post ) { + size_t (*postHookFunc) (size_t retVal___, Sql *self, char *out_to, const char *from); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_EscapeString_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_to, from); + } + } + return retVal___; +} +size_t HP_SQL_EscapeStringLen(Sql *self, char *out_to, const char *from, size_t from_len) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) { + size_t (*preHookFunc) (Sql *self, char *out_to, const char *from, size_t *from_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_pre[hIndex].func; + retVal___ = preHookFunc(self, out_to, from, &from_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len); + } + if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) { + size_t (*postHookFunc) (size_t retVal___, Sql *self, char *out_to, const char *from, size_t *from_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_to, from, &from_len); + } + } + return retVal___; +} +int HP_SQL_QueryV(Sql *self, const char *query, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_QueryV_pre ) { + int (*preHookFunc) (Sql *self, const char *query, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_SQL_QueryV_pre[hIndex].func; + retVal___ = preHookFunc(self, query, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.SQL.QueryV(self, query, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_SQL_QueryV_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *query, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_SQL_QueryV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_SQL_QueryStr(Sql *self, const char *query) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_QueryStr_pre ) { + int (*preHookFunc) (Sql *self, const char *query); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_QueryStr_pre[hIndex].func; + retVal___ = preHookFunc(self, query); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.QueryStr(self, query); + } + if( HPMHooks.count.HP_SQL_QueryStr_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *query); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_QueryStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query); + } + } + return retVal___; +} +uint64 HP_SQL_LastInsertId(Sql *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_LastInsertId_pre ) { + uint64 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_LastInsertId_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.LastInsertId(self); + } + if( HPMHooks.count.HP_SQL_LastInsertId_post ) { + uint64 (*postHookFunc) (uint64 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_LastInsertId_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint32 HP_SQL_NumColumns(Sql *self) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_SQL_NumColumns_pre ) { + uint32 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NumColumns_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NumColumns(self); + } + if( HPMHooks.count.HP_SQL_NumColumns_post ) { + uint32 (*postHookFunc) (uint32 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NumColumns_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint64 HP_SQL_NumRows(Sql *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_NumRows_pre ) { + uint64 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NumRows_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NumRows(self); + } + if( HPMHooks.count.HP_SQL_NumRows_post ) { + uint64 (*postHookFunc) (uint64 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NumRows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_NextRow(Sql *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_NextRow_pre ) { + int (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NextRow_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NextRow(self); + } + if( HPMHooks.count.HP_SQL_NextRow_post ) { + int (*postHookFunc) (int retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NextRow_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_GetData(Sql *self, size_t col, char **out_buf, size_t *out_len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetData_pre ) { + int (*preHookFunc) (Sql *self, size_t *col, char **out_buf, size_t *out_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetData_pre[hIndex].func; + retVal___ = preHookFunc(self, &col, out_buf, out_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len); + } + if( HPMHooks.count.HP_SQL_GetData_post ) { + int (*postHookFunc) (int retVal___, Sql *self, size_t *col, char **out_buf, size_t *out_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetData_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &col, out_buf, out_len); + } + } + return retVal___; +} +void HP_SQL_FreeResult(Sql *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_FreeResult_pre ) { + void (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_FreeResult_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.FreeResult(self); + } + if( HPMHooks.count.HP_SQL_FreeResult_post ) { + void (*postHookFunc) (Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_FreeResult_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_ShowDebug_(Sql *self, const char *debug_file, const unsigned long debug_line) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_ShowDebug__pre ) { + void (*preHookFunc) (Sql *self, const char *debug_file, const unsigned long *debug_line); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_ShowDebug__pre[hIndex].func; + preHookFunc(self, debug_file, &debug_line); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line); + } + if( HPMHooks.count.HP_SQL_ShowDebug__post ) { + void (*postHookFunc) (Sql *self, const char *debug_file, const unsigned long *debug_line); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_ShowDebug__post[hIndex].func; + postHookFunc(self, debug_file, &debug_line); + } + } + return; +} +void HP_SQL_Free(Sql *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_Free_pre ) { + void (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Free_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.Free(self); + } + if( HPMHooks.count.HP_SQL_Free_post ) { + void (*postHookFunc) (Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Free_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +struct Sql* HP_SQL_Malloc(void) { + int hIndex = 0; + struct Sql* retVal___ = NULL; + if( HPMHooks.count.HP_SQL_Malloc_pre ) { + struct Sql* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Malloc_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Malloc(); + } + if( HPMHooks.count.HP_SQL_Malloc_post ) { + struct Sql* (*postHookFunc) (struct Sql* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +struct SqlStmt* HP_SQL_StmtMalloc(Sql *sql) { + int hIndex = 0; + struct SqlStmt* retVal___ = NULL; + if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) { + struct SqlStmt* (*preHookFunc) (Sql *sql); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_pre[hIndex].func; + retVal___ = preHookFunc(sql); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtMalloc(sql); + } + if( HPMHooks.count.HP_SQL_StmtMalloc_post ) { + struct SqlStmt* (*postHookFunc) (struct SqlStmt* retVal___, Sql *sql); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, sql); + } + } + return retVal___; +} +int HP_SQL_StmtPrepareV(SqlStmt *self, const char *query, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) { + int (*preHookFunc) (SqlStmt *self, const char *query, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_pre[hIndex].func; + retVal___ = preHookFunc(self, query, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.SQL.StmtPrepareV(self, query, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_SQL_StmtPrepareV_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, const char *query, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_SQL_StmtPrepareStr(SqlStmt *self, const char *query) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) { + int (*preHookFunc) (SqlStmt *self, const char *query); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_pre[hIndex].func; + retVal___ = preHookFunc(self, query); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtPrepareStr(self, query); + } + if( HPMHooks.count.HP_SQL_StmtPrepareStr_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, const char *query); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query); + } + } + return retVal___; +} +size_t HP_SQL_StmtNumParams(SqlStmt *self) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) { + size_t (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumParams(self); + } + if( HPMHooks.count.HP_SQL_StmtNumParams_post ) { + size_t (*postHookFunc) (size_t retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtBindParam(SqlStmt *self, size_t idx, SqlDataType buffer_type, void *buffer, size_t buffer_len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) { + int (*preHookFunc) (SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_pre[hIndex].func; + retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len); + } + if( HPMHooks.count.HP_SQL_StmtBindParam_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len); + } + } + return retVal___; +} +int HP_SQL_StmtExecute(SqlStmt *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtExecute_pre ) { + int (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtExecute_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtExecute(self); + } + if( HPMHooks.count.HP_SQL_StmtExecute_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtExecute_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint64 HP_SQL_StmtLastInsertId(SqlStmt *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) { + uint64 (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtLastInsertId(self); + } + if( HPMHooks.count.HP_SQL_StmtLastInsertId_post ) { + uint64 (*postHookFunc) (uint64 retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +size_t HP_SQL_StmtNumColumns(SqlStmt *self) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) { + size_t (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumColumns(self); + } + if( HPMHooks.count.HP_SQL_StmtNumColumns_post ) { + size_t (*postHookFunc) (size_t retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtBindColumn(SqlStmt *self, size_t idx, SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) { + int (*preHookFunc) (SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_pre[hIndex].func; + retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtBindColumn(self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); + } + if( HPMHooks.count.HP_SQL_StmtBindColumn_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + } + } + return retVal___; +} +uint64 HP_SQL_StmtNumRows(SqlStmt *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) { + uint64 (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumRows(self); + } + if( HPMHooks.count.HP_SQL_StmtNumRows_post ) { + uint64 (*postHookFunc) (uint64 retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtNextRow(SqlStmt *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) { + int (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNextRow(self); + } + if( HPMHooks.count.HP_SQL_StmtNextRow_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +void HP_SQL_StmtFreeResult(SqlStmt *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) { + void (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtFreeResult(self); + } + if( HPMHooks.count.HP_SQL_StmtFreeResult_post ) { + void (*postHookFunc) (SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_StmtFree(SqlStmt *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtFree_pre ) { + void (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtFree_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtFree(self); + } + if( HPMHooks.count.HP_SQL_StmtFree_post ) { + void (*postHookFunc) (SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtFree_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_StmtShowDebug_(SqlStmt *self, const char *debug_file, const unsigned long debug_line) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) { + void (*preHookFunc) (SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__pre[hIndex].func; + preHookFunc(self, debug_file, &debug_line); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line); + } + if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) { + void (*postHookFunc) (SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__post[hIndex].func; + postHookFunc(self, debug_file, &debug_line); + } + } + return; +} +/* StrBuf */ +StringBuf* HP_StrBuf_Malloc(void) { + int hIndex = 0; + StringBuf* retVal___ = NULL; + if( HPMHooks.count.HP_StrBuf_Malloc_pre ) { + StringBuf* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Malloc_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Malloc(); + } + if( HPMHooks.count.HP_StrBuf_Malloc_post ) { + StringBuf* (*postHookFunc) (StringBuf* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_StrBuf_Init(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Init_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Init_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Init(self); + } + if( HPMHooks.count.HP_StrBuf_Init_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Init_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +int HP_StrBuf_Vprintf(StringBuf *self, const char *fmt, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Vprintf_pre ) { + int (*preHookFunc) (StringBuf *self, const char *fmt, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_pre[hIndex].func; + retVal___ = preHookFunc(self, fmt, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.StrBuf.Vprintf(self, fmt, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_StrBuf_Vprintf_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const char *fmt, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, fmt, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_StrBuf_Append(StringBuf *self, const StringBuf *sbuf) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Append_pre ) { + int (*preHookFunc) (StringBuf *self, const StringBuf *sbuf); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Append_pre[hIndex].func; + retVal___ = preHookFunc(self, sbuf); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Append(self, sbuf); + } + if( HPMHooks.count.HP_StrBuf_Append_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const StringBuf *sbuf); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Append_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, sbuf); + } + } + return retVal___; +} +int HP_StrBuf_AppendStr(StringBuf *self, const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_AppendStr_pre ) { + int (*preHookFunc) (StringBuf *self, const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_pre[hIndex].func; + retVal___ = preHookFunc(self, str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.AppendStr(self, str); + } + if( HPMHooks.count.HP_StrBuf_AppendStr_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, str); + } + } + return retVal___; +} +int HP_StrBuf_Length(StringBuf *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Length_pre ) { + int (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Length_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Length(self); + } + if( HPMHooks.count.HP_StrBuf_Length_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Length_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +char* HP_StrBuf_Value(StringBuf *self) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_StrBuf_Value_pre ) { + char* (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Value_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Value(self); + } + if( HPMHooks.count.HP_StrBuf_Value_post ) { + char* (*postHookFunc) (char* retVal___, StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Value_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +void HP_StrBuf_Clear(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Clear_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Clear_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Clear(self); + } + if( HPMHooks.count.HP_StrBuf_Clear_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Clear_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_StrBuf_Destroy(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Destroy_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Destroy_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Destroy(self); + } + if( HPMHooks.count.HP_StrBuf_Destroy_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Destroy_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_StrBuf_Free(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Free_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Free_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Free(self); + } + if( HPMHooks.count.HP_StrBuf_Free_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Free_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +/* strlib */ +char* HP_strlib_jstrescape(char *pt) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_jstrescape_pre ) { + char* (*preHookFunc) (char *pt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jstrescape_pre[hIndex].func; + retVal___ = preHookFunc(pt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jstrescape(pt); + } + if( HPMHooks.count.HP_strlib_jstrescape_post ) { + char* (*postHookFunc) (char* retVal___, char *pt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jstrescape_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt); + } + } + return retVal___; +} +char* HP_strlib_jstrescapecpy(char *pt, const char *spt) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_jstrescapecpy_pre ) { + char* (*preHookFunc) (char *pt, const char *spt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_pre[hIndex].func; + retVal___ = preHookFunc(pt, spt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jstrescapecpy(pt, spt); + } + if( HPMHooks.count.HP_strlib_jstrescapecpy_post ) { + char* (*postHookFunc) (char* retVal___, char *pt, const char *spt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt, spt); + } + } + return retVal___; +} +int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_jmemescapecpy_pre ) { + int (*preHookFunc) (char *pt, const char *spt, int *size); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_pre[hIndex].func; + retVal___ = preHookFunc(pt, spt, &size); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jmemescapecpy(pt, spt, size); + } + if( HPMHooks.count.HP_strlib_jmemescapecpy_post ) { + int (*postHookFunc) (int retVal___, char *pt, const char *spt, int *size); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt, spt, &size); + } + } + return retVal___; +} +int HP_strlib_remove_control_chars_(char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_remove_control_chars__pre ) { + int (*preHookFunc) (char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.remove_control_chars_(str); + } + if( HPMHooks.count.HP_strlib_remove_control_chars__post ) { + int (*postHookFunc) (int retVal___, char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_trim_(char *str) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_trim__pre ) { + char* (*preHookFunc) (char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_trim__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.trim_(str); + } + if( HPMHooks.count.HP_strlib_trim__post ) { + char* (*postHookFunc) (char* retVal___, char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_trim__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_normalize_name_(char *str, const char *delims) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_normalize_name__pre ) { + char* (*preHookFunc) (char *str, const char *delims); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_normalize_name__pre[hIndex].func; + retVal___ = preHookFunc(str, delims); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.normalize_name_(str, delims); + } + if( HPMHooks.count.HP_strlib_normalize_name__post ) { + char* (*postHookFunc) (char* retVal___, char *str, const char *delims); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_normalize_name__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, delims); + } + } + return retVal___; +} +const char* HP_strlib_stristr_(const char *haystack, const char *needle) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_stristr__pre ) { + const char* (*preHookFunc) (const char *haystack, const char *needle); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_stristr__pre[hIndex].func; + retVal___ = preHookFunc(haystack, needle); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.stristr_(haystack, needle); + } + if( HPMHooks.count.HP_strlib_stristr__post ) { + const char* (*postHookFunc) (const char* retVal___, const char *haystack, const char *needle); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_stristr__post[hIndex].func; + retVal___ = postHookFunc(retVal___, haystack, needle); + } + } + return retVal___; +} +size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_strlib_strnlen__pre ) { + size_t (*preHookFunc) (const char *string, size_t *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strnlen__pre[hIndex].func; + retVal___ = preHookFunc(string, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strnlen_(string, maxlen); + } + if( HPMHooks.count.HP_strlib_strnlen__post ) { + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strnlen__post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, &maxlen); + } + } + return retVal___; +} +char* HP_strlib_strtok_r_(char *s1, const char *s2, char **lasts) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_strtok_r__pre ) { + char* (*preHookFunc) (char *s1, const char *s2, char **lasts); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strtok_r__pre[hIndex].func; + retVal___ = preHookFunc(s1, s2, lasts); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strtok_r_(s1, s2, lasts); + } + if( HPMHooks.count.HP_strlib_strtok_r__post ) { + char* (*postHookFunc) (char* retVal___, char *s1, const char *s2, char **lasts); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strtok_r__post[hIndex].func; + retVal___ = postHookFunc(retVal___, s1, s2, lasts); + } + } + return retVal___; +} +int HP_strlib_e_mail_check_(char *email) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_e_mail_check__pre ) { + int (*preHookFunc) (char *email); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_e_mail_check__pre[hIndex].func; + retVal___ = preHookFunc(email); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.e_mail_check_(email); + } + if( HPMHooks.count.HP_strlib_e_mail_check__post ) { + int (*postHookFunc) (int retVal___, char *email); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_e_mail_check__post[hIndex].func; + retVal___ = postHookFunc(retVal___, email); + } + } + return retVal___; +} +int HP_strlib_config_switch_(const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_config_switch__pre ) { + int (*preHookFunc) (const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_config_switch__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.config_switch_(str); + } + if( HPMHooks.count.HP_strlib_config_switch__post ) { + int (*postHookFunc) (int retVal___, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_config_switch__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_safestrncpy__pre ) { + char* (*preHookFunc) (char *dst, const char *src, size_t *n); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_safestrncpy__pre[hIndex].func; + retVal___ = preHookFunc(dst, src, &n); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.safestrncpy_(dst, src, n); + } + if( HPMHooks.count.HP_strlib_safestrncpy__post ) { + char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t *n); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_safestrncpy__post[hIndex].func; + retVal___ = postHookFunc(retVal___, dst, src, &n); + } + } + return retVal___; +} +size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_strlib_safestrnlen__pre ) { + size_t (*preHookFunc) (const char *string, size_t *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_safestrnlen__pre[hIndex].func; + retVal___ = preHookFunc(string, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.safestrnlen_(string, maxlen); + } + if( HPMHooks.count.HP_strlib_safestrnlen__post ) { + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_safestrnlen__post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, &maxlen); + } + } + return retVal___; +} +int HP_strlib_strline_(const char *str, size_t pos) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_strline__pre ) { + int (*preHookFunc) (const char *str, size_t *pos); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strline__pre[hIndex].func; + retVal___ = preHookFunc(str, &pos); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strline_(str, pos); + } + if( HPMHooks.count.HP_strlib_strline__post ) { + int (*postHookFunc) (int retVal___, const char *str, size_t *pos); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strline__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &pos); + } + } + return retVal___; +} +bool HP_strlib_bin2hex_(char *output, unsigned char *input, size_t count) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_strlib_bin2hex__pre ) { + bool (*preHookFunc) (char *output, unsigned char *input, size_t *count); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_bin2hex__pre[hIndex].func; + retVal___ = preHookFunc(output, input, &count); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count); + } + if( HPMHooks.count.HP_strlib_bin2hex__post ) { + bool (*postHookFunc) (bool retVal___, char *output, unsigned char *input, size_t *count); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_bin2hex__post[hIndex].func; + retVal___ = postHookFunc(retVal___, output, input, &count); + } + } + return retVal___; +} +/* sv */ +int HP_sv_parse_next(struct s_svstate *svstate) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_parse_next_pre ) { + int (*preHookFunc) (struct s_svstate *svstate); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_parse_next_pre[hIndex].func; + retVal___ = preHookFunc(svstate); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.parse_next(svstate); + } + if( HPMHooks.count.HP_sv_parse_next_post ) { + int (*postHookFunc) (int retVal___, struct s_svstate *svstate); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_parse_next_post[hIndex].func; + retVal___ = postHookFunc(retVal___, svstate); + } + } + return retVal___; +} +int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_parse_pre ) { + int (*preHookFunc) (const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_parse_pre[hIndex].func; + retVal___ = preHookFunc(str, &len, &startoff, &delim, out_pos, &npos, &opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.parse(str, len, startoff, delim, out_pos, npos, opt); + } + if( HPMHooks.count.HP_sv_parse_post ) { + int (*postHookFunc) (int retVal___, const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_parse_post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_pos, &npos, &opt); + } + } + return retVal___; +} +int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_split_pre ) { + int (*preHookFunc) (char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_split_pre[hIndex].func; + retVal___ = preHookFunc(str, &len, &startoff, &delim, out_fields, &nfields, &opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.split(str, len, startoff, delim, out_fields, nfields, opt); + } + if( HPMHooks.count.HP_sv_split_post ) { + int (*postHookFunc) (int retVal___, char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_split_post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_fields, &nfields, &opt); + } + } + return retVal___; +} +size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *escapes) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_sv_escape_c_pre ) { + size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len, const char *escapes); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_escape_c_pre[hIndex].func; + retVal___ = preHookFunc(out_dest, src, &len, escapes); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.escape_c(out_dest, src, len, escapes); + } + if( HPMHooks.count.HP_sv_escape_c_post ) { + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len, const char *escapes); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_escape_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, out_dest, src, &len, escapes); + } + } + return retVal___; +} +size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_sv_unescape_c_pre ) { + size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_unescape_c_pre[hIndex].func; + retVal___ = preHookFunc(out_dest, src, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.unescape_c(out_dest, src, len); + } + if( HPMHooks.count.HP_sv_unescape_c_post ) { + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_unescape_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, out_dest, src, &len); + } + } + return retVal___; +} +const char* HP_sv_skip_escaped_c(const char *p) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sv_skip_escaped_c_pre ) { + const char* (*preHookFunc) (const char *p); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_pre[hIndex].func; + retVal___ = preHookFunc(p); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.skip_escaped_c(p); + } + if( HPMHooks.count.HP_sv_skip_escaped_c_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *p); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p); + } + } + return retVal___; +} +bool HP_sv_readdb(const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sv_readdb_pre ) { + bool (*preHookFunc) (const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_readdb_pre[hIndex].func; + retVal___ = preHookFunc(directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.readdb(directory, filename, delim, mincols, maxcols, maxrows, parseproc); + } + if( HPMHooks.count.HP_sv_readdb_post ) { + bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_readdb_post[hIndex].func; + retVal___ = postHookFunc(retVal___, directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + } + } + return retVal___; +} +/* sysinfo */ +int HP_sysinfo_getpagesize(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_getpagesize_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.getpagesize(); + } + if( HPMHooks.count.HP_sysinfo_getpagesize_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_platform(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_platform_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_platform_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.platform(); + } + if( HPMHooks.count.HP_sysinfo_platform_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_platform_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_osversion(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_osversion_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_osversion_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.osversion(); + } + if( HPMHooks.count.HP_sysinfo_osversion_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_osversion_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_cpu(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_cpu_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cpu_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cpu(); + } + if( HPMHooks.count.HP_sysinfo_cpu_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cpu_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_sysinfo_cpucores(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_cpucores_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cpucores_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cpucores(); + } + if( HPMHooks.count.HP_sysinfo_cpucores_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cpucores_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_arch(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_arch_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_arch_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.arch(); + } + if( HPMHooks.count.HP_sysinfo_arch_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_arch_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +bool HP_sysinfo_is64bit(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sysinfo_is64bit_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_is64bit_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.is64bit(); + } + if( HPMHooks.count.HP_sysinfo_is64bit_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_is64bit_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_compiler(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_compiler_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_compiler_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.compiler(); + } + if( HPMHooks.count.HP_sysinfo_compiler_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_compiler_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_cflags(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_cflags_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cflags_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cflags(); + } + if( HPMHooks.count.HP_sysinfo_cflags_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cflags_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcstype(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcstype_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcstype_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcstype(); + } + if( HPMHooks.count.HP_sysinfo_vcstype_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcstype_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_sysinfo_vcstypeid(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_vcstypeid_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcstypeid(); + } + if( HPMHooks.count.HP_sysinfo_vcstypeid_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcsrevision_src(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcsrevision_src_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcsrevision_src(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_src_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcsrevision_scripts(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcsrevision_scripts(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_sysinfo_vcsrevision_reload(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.vcsrevision_reload(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_sysinfo_is_superuser(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sysinfo_is_superuser_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.is_superuser(); + } + if( HPMHooks.count.HP_sysinfo_is_superuser_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_sysinfo_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.init(); + } + if( HPMHooks.count.HP_sysinfo_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sysinfo_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.final(); + } + if( HPMHooks.count.HP_sysinfo_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* timer */ +int64 HP_timer_gettick(void) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_gettick_pre ) { + int64 (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_gettick_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.gettick(); + } + if( HPMHooks.count.HP_timer_gettick_post ) { + int64 (*postHookFunc) (int64 retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_gettick_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int64 HP_timer_gettick_nocache(void) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_gettick_nocache_pre ) { + int64 (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_gettick_nocache_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.gettick_nocache(); + } + if( HPMHooks.count.HP_timer_gettick_nocache_post ) { + int64 (*postHookFunc) (int64 retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_gettick_nocache_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_pre ) { + int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_pre[hIndex].func; + retVal___ = preHookFunc(&tick, &func, &id, &data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add(tick, func, id, data); + } + if( HPMHooks.count.HP_timer_add_post ) { + int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data); + } + } + return retVal___; +} +int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int interval) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_interval_pre ) { + int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_interval_pre[hIndex].func; + retVal___ = preHookFunc(&tick, &func, &id, &data, &interval); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add_interval(tick, func, id, data, interval); + } + if( HPMHooks.count.HP_timer_add_interval_post ) { + int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_interval_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data, &interval); + } + } + return retVal___; +} +const struct TimerData* HP_timer_get(int tid) { + int hIndex = 0; + const struct TimerData* retVal___ = NULL; + if( HPMHooks.count.HP_timer_get_pre ) { + const struct TimerData* (*preHookFunc) (int *tid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_get_pre[hIndex].func; + retVal___ = preHookFunc(&tid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.get(tid); + } + if( HPMHooks.count.HP_timer_get_post ) { + const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int *tid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_get_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid); + } + } + return retVal___; +} +int HP_timer_delete(int tid, TimerFunc func) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_delete_pre ) { + int (*preHookFunc) (int *tid, TimerFunc *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_delete_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.delete(tid, func); + } + if( HPMHooks.count.HP_timer_delete_post ) { + int (*postHookFunc) (int retVal___, int *tid, TimerFunc *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_delete_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &func); + } + } + return retVal___; +} +int64 HP_timer_addtick(int tid, int64 tick) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_addtick_pre ) { + int64 (*preHookFunc) (int *tid, int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_addtick_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.addtick(tid, tick); + } + if( HPMHooks.count.HP_timer_addtick_post ) { + int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_addtick_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &tick); + } + } + return retVal___; +} +int64 HP_timer_settick(int tid, int64 tick) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_settick_pre ) { + int64 (*preHookFunc) (int *tid, int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_settick_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.settick(tid, tick); + } + if( HPMHooks.count.HP_timer_settick_post ) { + int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_settick_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &tick); + } + } + return retVal___; +} +int HP_timer_add_func_list(TimerFunc func, char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_func_list_pre ) { + int (*preHookFunc) (TimerFunc *func, char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_func_list_pre[hIndex].func; + retVal___ = preHookFunc(&func, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add_func_list(func, name); + } + if( HPMHooks.count.HP_timer_add_func_list_post ) { + int (*postHookFunc) (int retVal___, TimerFunc *func, char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_func_list_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &func, name); + } + } + return retVal___; +} +unsigned long HP_timer_get_uptime(void) { + int hIndex = 0; + unsigned long retVal___ = 0; + if( HPMHooks.count.HP_timer_get_uptime_pre ) { + unsigned long (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_get_uptime_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.get_uptime(); + } + if( HPMHooks.count.HP_timer_get_uptime_post ) { + unsigned long (*postHookFunc) (unsigned long retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_get_uptime_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_timer_perform(int64 tick) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_perform_pre ) { + int (*preHookFunc) (int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_perform_pre[hIndex].func; + retVal___ = preHookFunc(&tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.perform(tick); + } + if( HPMHooks.count.HP_timer_perform_post ) { + int (*postHookFunc) (int retVal___, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_perform_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick); + } + } + return retVal___; +} +void HP_timer_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_timer_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.timer.init(); + } + if( HPMHooks.count.HP_timer_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_timer_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_timer_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.timer.final(); + } + if( HPMHooks.count.HP_timer_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} diff --git a/src/plugins/HPMHooking/HPMHooking_char.sources.inc b/src/plugins/HPMHooking/HPMHooking_char.sources.inc index 00700756c..489917771 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.sources.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.sources.inc @@ -4,7 +4,12 @@ // NOTE: This file was auto-generated and should never be manually edited, // as it will get overwritten. +memcpy(&HPMHooks.source.HCache, HCache, sizeof(struct HCache_interface)); memcpy(&HPMHooks.source.chr, chr, sizeof(struct char_interface)); +memcpy(&HPMHooks.source.cmdline, cmdline, sizeof(struct cmdline_interface)); +memcpy(&HPMHooks.source.console, console, sizeof(struct console_interface)); +memcpy(&HPMHooks.source.core, core, sizeof(struct core_interface)); +memcpy(&HPMHooks.source.DB, DB, sizeof(struct db_interface)); memcpy(&HPMHooks.source.geoip, geoip, sizeof(struct geoip_interface)); memcpy(&HPMHooks.source.inter_auction, inter_auction, sizeof(struct inter_auction_interface)); memcpy(&HPMHooks.source.inter_elemental, inter_elemental, sizeof(struct inter_elemental_interface)); @@ -17,6 +22,18 @@ memcpy(&HPMHooks.source.inter_party, inter_party, sizeof(struct inter_party_inte memcpy(&HPMHooks.source.inter_pet, inter_pet, sizeof(struct inter_pet_interface)); memcpy(&HPMHooks.source.inter_quest, inter_quest, sizeof(struct inter_quest_interface)); memcpy(&HPMHooks.source.inter_storage, inter_storage, sizeof(struct inter_storage_interface)); +memcpy(&HPMHooks.source.libconfig, libconfig, sizeof(struct libconfig_interface)); memcpy(&HPMHooks.source.loginif, loginif, sizeof(struct loginif_interface)); +memcpy(&HPMHooks.source.iMalloc, iMalloc, sizeof(struct malloc_interface)); memcpy(&HPMHooks.source.mapif, mapif, sizeof(struct mapif_interface)); +memcpy(&HPMHooks.source.mapindex, mapindex, sizeof(struct mapindex_interface)); +memcpy(&HPMHooks.source.nullpo, nullpo, sizeof(struct nullpo_interface)); memcpy(&HPMHooks.source.pincode, pincode, sizeof(struct pincode_interface)); +memcpy(&HPMHooks.source.showmsg, showmsg, sizeof(struct showmsg_interface)); +memcpy(&HPMHooks.source.sockt, sockt, sizeof(struct socket_interface)); +memcpy(&HPMHooks.source.SQL, SQL, sizeof(struct sql_interface)); +memcpy(&HPMHooks.source.StrBuf, StrBuf, sizeof(struct stringbuf_interface)); +memcpy(&HPMHooks.source.strlib, strlib, sizeof(struct strlib_interface)); +memcpy(&HPMHooks.source.sv, sv, sizeof(struct sv_interface)); +memcpy(&HPMHooks.source.sysinfo, sysinfo, sizeof(struct sysinfo_interface)); +memcpy(&HPMHooks.source.timer, timer, sizeof(struct timer_interface)); diff --git a/src/plugins/HPMHooking/HPMHooking_login.GetSymbol.inc b/src/plugins/HPMHooking/HPMHooking_login.GetSymbol.inc deleted file mode 100644 index fd9eeba8c..000000000 --- a/src/plugins/HPMHooking/HPMHooking_login.GetSymbol.inc +++ /dev/null @@ -1,7 +0,0 @@ -// Copyright (c) Hercules Dev Team, licensed under GNU GPL. -// See the LICENSE file -// -// NOTE: This file was auto-generated and should never be manually edited, -// as it will get overwritten. - -if( !(login = GET_SYMBOL("login") ) ) return "login"; diff --git a/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc index af7e7250c..4edefd5b7 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc @@ -5,6 +5,186 @@ // as it will get overwritten. struct { + struct HPMHookPoint *HP_HCache_init_pre; + struct HPMHookPoint *HP_HCache_init_post; + struct HPMHookPoint *HP_HCache_check_pre; + struct HPMHookPoint *HP_HCache_check_post; + struct HPMHookPoint *HP_HCache_open_pre; + struct HPMHookPoint *HP_HCache_open_post; + struct HPMHookPoint *HP_cmdline_init_pre; + struct HPMHookPoint *HP_cmdline_init_post; + struct HPMHookPoint *HP_cmdline_final_pre; + struct HPMHookPoint *HP_cmdline_final_post; + struct HPMHookPoint *HP_cmdline_arg_add_pre; + struct HPMHookPoint *HP_cmdline_arg_add_post; + struct HPMHookPoint *HP_cmdline_exec_pre; + struct HPMHookPoint *HP_cmdline_exec_post; + struct HPMHookPoint *HP_cmdline_arg_next_value_pre; + struct HPMHookPoint *HP_cmdline_arg_next_value_post; + struct HPMHookPoint *HP_cmdline_arg_source_pre; + struct HPMHookPoint *HP_cmdline_arg_source_post; + struct HPMHookPoint *HP_console_init_pre; + struct HPMHookPoint *HP_console_init_post; + struct HPMHookPoint *HP_console_final_pre; + struct HPMHookPoint *HP_console_final_post; + struct HPMHookPoint *HP_console_display_title_pre; + struct HPMHookPoint *HP_console_display_title_post; + struct HPMHookPoint *HP_core_shutdown_callback_pre; + struct HPMHookPoint *HP_core_shutdown_callback_post; + struct HPMHookPoint *HP_DB_fix_options_pre; + struct HPMHookPoint *HP_DB_fix_options_post; + struct HPMHookPoint *HP_DB_default_cmp_pre; + struct HPMHookPoint *HP_DB_default_cmp_post; + struct HPMHookPoint *HP_DB_default_hash_pre; + struct HPMHookPoint *HP_DB_default_hash_post; + struct HPMHookPoint *HP_DB_default_release_pre; + struct HPMHookPoint *HP_DB_default_release_post; + struct HPMHookPoint *HP_DB_custom_release_pre; + struct HPMHookPoint *HP_DB_custom_release_post; + struct HPMHookPoint *HP_DB_alloc_pre; + struct HPMHookPoint *HP_DB_alloc_post; + struct HPMHookPoint *HP_DB_i2key_pre; + struct HPMHookPoint *HP_DB_i2key_post; + struct HPMHookPoint *HP_DB_ui2key_pre; + struct HPMHookPoint *HP_DB_ui2key_post; + struct HPMHookPoint *HP_DB_str2key_pre; + struct HPMHookPoint *HP_DB_str2key_post; + struct HPMHookPoint *HP_DB_i642key_pre; + struct HPMHookPoint *HP_DB_i642key_post; + struct HPMHookPoint *HP_DB_ui642key_pre; + struct HPMHookPoint *HP_DB_ui642key_post; + struct HPMHookPoint *HP_DB_i2data_pre; + struct HPMHookPoint *HP_DB_i2data_post; + struct HPMHookPoint *HP_DB_ui2data_pre; + struct HPMHookPoint *HP_DB_ui2data_post; + struct HPMHookPoint *HP_DB_ptr2data_pre; + struct HPMHookPoint *HP_DB_ptr2data_post; + struct HPMHookPoint *HP_DB_data2i_pre; + struct HPMHookPoint *HP_DB_data2i_post; + struct HPMHookPoint *HP_DB_data2ui_pre; + struct HPMHookPoint *HP_DB_data2ui_post; + struct HPMHookPoint *HP_DB_data2ptr_pre; + struct HPMHookPoint *HP_DB_data2ptr_post; + struct HPMHookPoint *HP_DB_init_pre; + struct HPMHookPoint *HP_DB_init_post; + struct HPMHookPoint *HP_DB_final_pre; + struct HPMHookPoint *HP_DB_final_post; + struct HPMHookPoint *HP_libconfig_read_pre; + struct HPMHookPoint *HP_libconfig_read_post; + struct HPMHookPoint *HP_libconfig_write_pre; + struct HPMHookPoint *HP_libconfig_write_post; + struct HPMHookPoint *HP_libconfig_set_auto_convert_pre; + struct HPMHookPoint *HP_libconfig_set_auto_convert_post; + struct HPMHookPoint *HP_libconfig_get_auto_convert_pre; + struct HPMHookPoint *HP_libconfig_get_auto_convert_post; + struct HPMHookPoint *HP_libconfig_read_string_pre; + struct HPMHookPoint *HP_libconfig_read_string_post; + struct HPMHookPoint *HP_libconfig_read_file_src_pre; + struct HPMHookPoint *HP_libconfig_read_file_src_post; + struct HPMHookPoint *HP_libconfig_write_file_pre; + struct HPMHookPoint *HP_libconfig_write_file_post; + struct HPMHookPoint *HP_libconfig_set_destructor_pre; + struct HPMHookPoint *HP_libconfig_set_destructor_post; + struct HPMHookPoint *HP_libconfig_set_include_dir_pre; + struct HPMHookPoint *HP_libconfig_set_include_dir_post; + struct HPMHookPoint *HP_libconfig_init_pre; + struct HPMHookPoint *HP_libconfig_init_post; + struct HPMHookPoint *HP_libconfig_destroy_pre; + struct HPMHookPoint *HP_libconfig_destroy_post; + struct HPMHookPoint *HP_libconfig_setting_get_int_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int_post; + struct HPMHookPoint *HP_libconfig_setting_get_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int64_post; + struct HPMHookPoint *HP_libconfig_setting_get_float_pre; + struct HPMHookPoint *HP_libconfig_setting_get_float_post; + struct HPMHookPoint *HP_libconfig_setting_get_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_get_bool_post; + struct HPMHookPoint *HP_libconfig_setting_get_string_pre; + struct HPMHookPoint *HP_libconfig_setting_get_string_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_int_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_int_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_int64_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_float_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_float_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_bool_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_string_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_string_post; + struct HPMHookPoint *HP_libconfig_setting_set_int_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int_post; + struct HPMHookPoint *HP_libconfig_setting_set_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int64_post; + struct HPMHookPoint *HP_libconfig_setting_set_float_pre; + struct HPMHookPoint *HP_libconfig_setting_set_float_post; + struct HPMHookPoint *HP_libconfig_setting_set_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_set_bool_post; + struct HPMHookPoint *HP_libconfig_setting_set_string_pre; + struct HPMHookPoint *HP_libconfig_setting_set_string_post; + struct HPMHookPoint *HP_libconfig_setting_set_format_pre; + struct HPMHookPoint *HP_libconfig_setting_set_format_post; + struct HPMHookPoint *HP_libconfig_setting_get_format_pre; + struct HPMHookPoint *HP_libconfig_setting_get_format_post; + struct HPMHookPoint *HP_libconfig_setting_get_int_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_int64_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int64_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_float_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_float_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_bool_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_bool_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_string_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_string_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_int_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_int64_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int64_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_float_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_float_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_bool_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_bool_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_string_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_string_elem_post; + struct HPMHookPoint *HP_libconfig_setting_index_pre; + struct HPMHookPoint *HP_libconfig_setting_index_post; + struct HPMHookPoint *HP_libconfig_setting_length_pre; + struct HPMHookPoint *HP_libconfig_setting_length_post; + struct HPMHookPoint *HP_libconfig_setting_get_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_member_pre; + struct HPMHookPoint *HP_libconfig_setting_get_member_post; + struct HPMHookPoint *HP_libconfig_setting_add_pre; + struct HPMHookPoint *HP_libconfig_setting_add_post; + struct HPMHookPoint *HP_libconfig_setting_remove_pre; + struct HPMHookPoint *HP_libconfig_setting_remove_post; + struct HPMHookPoint *HP_libconfig_setting_remove_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_remove_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_hook_pre; + struct HPMHookPoint *HP_libconfig_setting_set_hook_post; + struct HPMHookPoint *HP_libconfig_lookup_pre; + struct HPMHookPoint *HP_libconfig_lookup_post; + struct HPMHookPoint *HP_libconfig_lookup_from_pre; + struct HPMHookPoint *HP_libconfig_lookup_from_post; + struct HPMHookPoint *HP_libconfig_lookup_int_pre; + struct HPMHookPoint *HP_libconfig_lookup_int_post; + struct HPMHookPoint *HP_libconfig_lookup_int64_pre; + struct HPMHookPoint *HP_libconfig_lookup_int64_post; + struct HPMHookPoint *HP_libconfig_lookup_float_pre; + struct HPMHookPoint *HP_libconfig_lookup_float_post; + struct HPMHookPoint *HP_libconfig_lookup_bool_pre; + struct HPMHookPoint *HP_libconfig_lookup_bool_post; + struct HPMHookPoint *HP_libconfig_lookup_string_pre; + struct HPMHookPoint *HP_libconfig_lookup_string_post; + struct HPMHookPoint *HP_libconfig_read_file_pre; + struct HPMHookPoint *HP_libconfig_read_file_post; + struct HPMHookPoint *HP_libconfig_setting_copy_simple_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_simple_post; + struct HPMHookPoint *HP_libconfig_setting_copy_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_elem_post; + struct HPMHookPoint *HP_libconfig_setting_copy_aggregate_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_aggregate_post; + struct HPMHookPoint *HP_libconfig_setting_copy_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_post; struct HPMHookPoint *HP_login_mmo_auth_pre; struct HPMHookPoint *HP_login_mmo_auth_post; struct HPMHookPoint *HP_login_mmo_auth_new_pre; @@ -29,10 +209,8 @@ struct { struct HPMHookPoint *HP_login_check_encrypted_post; struct HPMHookPoint *HP_login_check_password_pre; struct HPMHookPoint *HP_login_check_password_post; - struct HPMHookPoint *HP_login_lan_subnetcheck_pre; - struct HPMHookPoint *HP_login_lan_subnetcheck_post; - struct HPMHookPoint *HP_login_lan_config_read_pre; - struct HPMHookPoint *HP_login_lan_config_read_post; + struct HPMHookPoint *HP_login_lan_subnet_check_pre; + struct HPMHookPoint *HP_login_lan_subnet_check_post; struct HPMHookPoint *HP_login_fromchar_accinfo_pre; struct HPMHookPoint *HP_login_fromchar_accinfo_post; struct HPMHookPoint *HP_login_fromchar_account_pre; @@ -115,9 +293,469 @@ struct { struct HPMHookPoint *HP_login_parse_request_connection_post; struct HPMHookPoint *HP_login_parse_login_pre; struct HPMHookPoint *HP_login_parse_login_post; + struct HPMHookPoint *HP_iMalloc_init_pre; + struct HPMHookPoint *HP_iMalloc_init_post; + struct HPMHookPoint *HP_iMalloc_final_pre; + struct HPMHookPoint *HP_iMalloc_final_post; + struct HPMHookPoint *HP_iMalloc_malloc_pre; + struct HPMHookPoint *HP_iMalloc_malloc_post; + struct HPMHookPoint *HP_iMalloc_calloc_pre; + struct HPMHookPoint *HP_iMalloc_calloc_post; + struct HPMHookPoint *HP_iMalloc_realloc_pre; + struct HPMHookPoint *HP_iMalloc_realloc_post; + struct HPMHookPoint *HP_iMalloc_reallocz_pre; + struct HPMHookPoint *HP_iMalloc_reallocz_post; + struct HPMHookPoint *HP_iMalloc_astrdup_pre; + struct HPMHookPoint *HP_iMalloc_astrdup_post; + struct HPMHookPoint *HP_iMalloc_free_pre; + struct HPMHookPoint *HP_iMalloc_free_post; + struct HPMHookPoint *HP_iMalloc_memory_check_pre; + struct HPMHookPoint *HP_iMalloc_memory_check_post; + struct HPMHookPoint *HP_iMalloc_verify_ptr_pre; + struct HPMHookPoint *HP_iMalloc_verify_ptr_post; + struct HPMHookPoint *HP_iMalloc_usage_pre; + struct HPMHookPoint *HP_iMalloc_usage_post; + struct HPMHookPoint *HP_iMalloc_post_shutdown_pre; + struct HPMHookPoint *HP_iMalloc_post_shutdown_post; + struct HPMHookPoint *HP_iMalloc_init_messages_pre; + struct HPMHookPoint *HP_iMalloc_init_messages_post; + struct HPMHookPoint *HP_nullpo_assert_report_pre; + struct HPMHookPoint *HP_nullpo_assert_report_post; + struct HPMHookPoint *HP_showmsg_init_pre; + struct HPMHookPoint *HP_showmsg_init_post; + struct HPMHookPoint *HP_showmsg_final_pre; + struct HPMHookPoint *HP_showmsg_final_post; + struct HPMHookPoint *HP_showmsg_clearScreen_pre; + struct HPMHookPoint *HP_showmsg_clearScreen_post; + struct HPMHookPoint *HP_showmsg_showMessageV_pre; + struct HPMHookPoint *HP_showmsg_showMessageV_post; + struct HPMHookPoint *HP_sockt_init_pre; + struct HPMHookPoint *HP_sockt_init_post; + struct HPMHookPoint *HP_sockt_final_pre; + struct HPMHookPoint *HP_sockt_final_post; + struct HPMHookPoint *HP_sockt_perform_pre; + struct HPMHookPoint *HP_sockt_perform_post; + struct HPMHookPoint *HP_sockt_datasync_pre; + struct HPMHookPoint *HP_sockt_datasync_post; + struct HPMHookPoint *HP_sockt_make_listen_bind_pre; + struct HPMHookPoint *HP_sockt_make_listen_bind_post; + struct HPMHookPoint *HP_sockt_make_connection_pre; + struct HPMHookPoint *HP_sockt_make_connection_post; + struct HPMHookPoint *HP_sockt_realloc_fifo_pre; + struct HPMHookPoint *HP_sockt_realloc_fifo_post; + struct HPMHookPoint *HP_sockt_realloc_writefifo_pre; + struct HPMHookPoint *HP_sockt_realloc_writefifo_post; + struct HPMHookPoint *HP_sockt_wfifoset_pre; + struct HPMHookPoint *HP_sockt_wfifoset_post; + struct HPMHookPoint *HP_sockt_rfifoskip_pre; + struct HPMHookPoint *HP_sockt_rfifoskip_post; + struct HPMHookPoint *HP_sockt_close_pre; + struct HPMHookPoint *HP_sockt_close_post; + struct HPMHookPoint *HP_sockt_session_is_valid_pre; + struct HPMHookPoint *HP_sockt_session_is_valid_post; + struct HPMHookPoint *HP_sockt_session_is_active_pre; + struct HPMHookPoint *HP_sockt_session_is_active_post; + struct HPMHookPoint *HP_sockt_flush_pre; + struct HPMHookPoint *HP_sockt_flush_post; + struct HPMHookPoint *HP_sockt_flush_fifos_pre; + struct HPMHookPoint *HP_sockt_flush_fifos_post; + struct HPMHookPoint *HP_sockt_set_nonblocking_pre; + struct HPMHookPoint *HP_sockt_set_nonblocking_post; + struct HPMHookPoint *HP_sockt_set_defaultparse_pre; + struct HPMHookPoint *HP_sockt_set_defaultparse_post; + struct HPMHookPoint *HP_sockt_host2ip_pre; + struct HPMHookPoint *HP_sockt_host2ip_post; + struct HPMHookPoint *HP_sockt_ip2str_pre; + struct HPMHookPoint *HP_sockt_ip2str_post; + struct HPMHookPoint *HP_sockt_str2ip_pre; + struct HPMHookPoint *HP_sockt_str2ip_post; + struct HPMHookPoint *HP_sockt_ntows_pre; + struct HPMHookPoint *HP_sockt_ntows_post; + struct HPMHookPoint *HP_sockt_getips_pre; + struct HPMHookPoint *HP_sockt_getips_post; + struct HPMHookPoint *HP_sockt_eof_pre; + struct HPMHookPoint *HP_sockt_eof_post; + struct HPMHookPoint *HP_sockt_lan_subnet_check_pre; + struct HPMHookPoint *HP_sockt_lan_subnet_check_post; + struct HPMHookPoint *HP_sockt_allowed_ip_check_pre; + struct HPMHookPoint *HP_sockt_allowed_ip_check_post; + struct HPMHookPoint *HP_sockt_trusted_ip_check_pre; + struct HPMHookPoint *HP_sockt_trusted_ip_check_post; + struct HPMHookPoint *HP_sockt_net_config_read_sub_pre; + struct HPMHookPoint *HP_sockt_net_config_read_sub_post; + struct HPMHookPoint *HP_sockt_net_config_read_pre; + struct HPMHookPoint *HP_sockt_net_config_read_post; + struct HPMHookPoint *HP_SQL_Connect_pre; + struct HPMHookPoint *HP_SQL_Connect_post; + struct HPMHookPoint *HP_SQL_GetTimeout_pre; + struct HPMHookPoint *HP_SQL_GetTimeout_post; + struct HPMHookPoint *HP_SQL_GetColumnNames_pre; + struct HPMHookPoint *HP_SQL_GetColumnNames_post; + struct HPMHookPoint *HP_SQL_SetEncoding_pre; + struct HPMHookPoint *HP_SQL_SetEncoding_post; + struct HPMHookPoint *HP_SQL_Ping_pre; + struct HPMHookPoint *HP_SQL_Ping_post; + struct HPMHookPoint *HP_SQL_EscapeString_pre; + struct HPMHookPoint *HP_SQL_EscapeString_post; + struct HPMHookPoint *HP_SQL_EscapeStringLen_pre; + struct HPMHookPoint *HP_SQL_EscapeStringLen_post; + struct HPMHookPoint *HP_SQL_QueryV_pre; + struct HPMHookPoint *HP_SQL_QueryV_post; + struct HPMHookPoint *HP_SQL_QueryStr_pre; + struct HPMHookPoint *HP_SQL_QueryStr_post; + struct HPMHookPoint *HP_SQL_LastInsertId_pre; + struct HPMHookPoint *HP_SQL_LastInsertId_post; + struct HPMHookPoint *HP_SQL_NumColumns_pre; + struct HPMHookPoint *HP_SQL_NumColumns_post; + struct HPMHookPoint *HP_SQL_NumRows_pre; + struct HPMHookPoint *HP_SQL_NumRows_post; + struct HPMHookPoint *HP_SQL_NextRow_pre; + struct HPMHookPoint *HP_SQL_NextRow_post; + struct HPMHookPoint *HP_SQL_GetData_pre; + struct HPMHookPoint *HP_SQL_GetData_post; + struct HPMHookPoint *HP_SQL_FreeResult_pre; + struct HPMHookPoint *HP_SQL_FreeResult_post; + struct HPMHookPoint *HP_SQL_ShowDebug__pre; + struct HPMHookPoint *HP_SQL_ShowDebug__post; + struct HPMHookPoint *HP_SQL_Free_pre; + struct HPMHookPoint *HP_SQL_Free_post; + struct HPMHookPoint *HP_SQL_Malloc_pre; + struct HPMHookPoint *HP_SQL_Malloc_post; + struct HPMHookPoint *HP_SQL_StmtMalloc_pre; + struct HPMHookPoint *HP_SQL_StmtMalloc_post; + struct HPMHookPoint *HP_SQL_StmtPrepareV_pre; + struct HPMHookPoint *HP_SQL_StmtPrepareV_post; + struct HPMHookPoint *HP_SQL_StmtPrepareStr_pre; + struct HPMHookPoint *HP_SQL_StmtPrepareStr_post; + struct HPMHookPoint *HP_SQL_StmtNumParams_pre; + struct HPMHookPoint *HP_SQL_StmtNumParams_post; + struct HPMHookPoint *HP_SQL_StmtBindParam_pre; + struct HPMHookPoint *HP_SQL_StmtBindParam_post; + struct HPMHookPoint *HP_SQL_StmtExecute_pre; + struct HPMHookPoint *HP_SQL_StmtExecute_post; + struct HPMHookPoint *HP_SQL_StmtLastInsertId_pre; + struct HPMHookPoint *HP_SQL_StmtLastInsertId_post; + struct HPMHookPoint *HP_SQL_StmtNumColumns_pre; + struct HPMHookPoint *HP_SQL_StmtNumColumns_post; + struct HPMHookPoint *HP_SQL_StmtBindColumn_pre; + struct HPMHookPoint *HP_SQL_StmtBindColumn_post; + struct HPMHookPoint *HP_SQL_StmtNumRows_pre; + struct HPMHookPoint *HP_SQL_StmtNumRows_post; + struct HPMHookPoint *HP_SQL_StmtNextRow_pre; + struct HPMHookPoint *HP_SQL_StmtNextRow_post; + struct HPMHookPoint *HP_SQL_StmtFreeResult_pre; + struct HPMHookPoint *HP_SQL_StmtFreeResult_post; + struct HPMHookPoint *HP_SQL_StmtFree_pre; + struct HPMHookPoint *HP_SQL_StmtFree_post; + struct HPMHookPoint *HP_SQL_StmtShowDebug__pre; + struct HPMHookPoint *HP_SQL_StmtShowDebug__post; + struct HPMHookPoint *HP_StrBuf_Malloc_pre; + struct HPMHookPoint *HP_StrBuf_Malloc_post; + struct HPMHookPoint *HP_StrBuf_Init_pre; + struct HPMHookPoint *HP_StrBuf_Init_post; + struct HPMHookPoint *HP_StrBuf_Vprintf_pre; + struct HPMHookPoint *HP_StrBuf_Vprintf_post; + struct HPMHookPoint *HP_StrBuf_Append_pre; + struct HPMHookPoint *HP_StrBuf_Append_post; + struct HPMHookPoint *HP_StrBuf_AppendStr_pre; + struct HPMHookPoint *HP_StrBuf_AppendStr_post; + struct HPMHookPoint *HP_StrBuf_Length_pre; + struct HPMHookPoint *HP_StrBuf_Length_post; + struct HPMHookPoint *HP_StrBuf_Value_pre; + struct HPMHookPoint *HP_StrBuf_Value_post; + struct HPMHookPoint *HP_StrBuf_Clear_pre; + struct HPMHookPoint *HP_StrBuf_Clear_post; + struct HPMHookPoint *HP_StrBuf_Destroy_pre; + struct HPMHookPoint *HP_StrBuf_Destroy_post; + struct HPMHookPoint *HP_StrBuf_Free_pre; + struct HPMHookPoint *HP_StrBuf_Free_post; + struct HPMHookPoint *HP_strlib_jstrescape_pre; + struct HPMHookPoint *HP_strlib_jstrescape_post; + struct HPMHookPoint *HP_strlib_jstrescapecpy_pre; + struct HPMHookPoint *HP_strlib_jstrescapecpy_post; + struct HPMHookPoint *HP_strlib_jmemescapecpy_pre; + struct HPMHookPoint *HP_strlib_jmemescapecpy_post; + struct HPMHookPoint *HP_strlib_remove_control_chars__pre; + struct HPMHookPoint *HP_strlib_remove_control_chars__post; + struct HPMHookPoint *HP_strlib_trim__pre; + struct HPMHookPoint *HP_strlib_trim__post; + struct HPMHookPoint *HP_strlib_normalize_name__pre; + struct HPMHookPoint *HP_strlib_normalize_name__post; + struct HPMHookPoint *HP_strlib_stristr__pre; + struct HPMHookPoint *HP_strlib_stristr__post; + struct HPMHookPoint *HP_strlib_strnlen__pre; + struct HPMHookPoint *HP_strlib_strnlen__post; + struct HPMHookPoint *HP_strlib_strtok_r__pre; + struct HPMHookPoint *HP_strlib_strtok_r__post; + struct HPMHookPoint *HP_strlib_e_mail_check__pre; + struct HPMHookPoint *HP_strlib_e_mail_check__post; + struct HPMHookPoint *HP_strlib_config_switch__pre; + struct HPMHookPoint *HP_strlib_config_switch__post; + struct HPMHookPoint *HP_strlib_safestrncpy__pre; + struct HPMHookPoint *HP_strlib_safestrncpy__post; + struct HPMHookPoint *HP_strlib_safestrnlen__pre; + struct HPMHookPoint *HP_strlib_safestrnlen__post; + struct HPMHookPoint *HP_strlib_strline__pre; + struct HPMHookPoint *HP_strlib_strline__post; + struct HPMHookPoint *HP_strlib_bin2hex__pre; + struct HPMHookPoint *HP_strlib_bin2hex__post; + struct HPMHookPoint *HP_sv_parse_next_pre; + struct HPMHookPoint *HP_sv_parse_next_post; + struct HPMHookPoint *HP_sv_parse_pre; + struct HPMHookPoint *HP_sv_parse_post; + struct HPMHookPoint *HP_sv_split_pre; + struct HPMHookPoint *HP_sv_split_post; + struct HPMHookPoint *HP_sv_escape_c_pre; + struct HPMHookPoint *HP_sv_escape_c_post; + struct HPMHookPoint *HP_sv_unescape_c_pre; + struct HPMHookPoint *HP_sv_unescape_c_post; + struct HPMHookPoint *HP_sv_skip_escaped_c_pre; + struct HPMHookPoint *HP_sv_skip_escaped_c_post; + struct HPMHookPoint *HP_sv_readdb_pre; + struct HPMHookPoint *HP_sv_readdb_post; + struct HPMHookPoint *HP_sysinfo_getpagesize_pre; + struct HPMHookPoint *HP_sysinfo_getpagesize_post; + struct HPMHookPoint *HP_sysinfo_platform_pre; + struct HPMHookPoint *HP_sysinfo_platform_post; + struct HPMHookPoint *HP_sysinfo_osversion_pre; + struct HPMHookPoint *HP_sysinfo_osversion_post; + struct HPMHookPoint *HP_sysinfo_cpu_pre; + struct HPMHookPoint *HP_sysinfo_cpu_post; + struct HPMHookPoint *HP_sysinfo_cpucores_pre; + struct HPMHookPoint *HP_sysinfo_cpucores_post; + struct HPMHookPoint *HP_sysinfo_arch_pre; + struct HPMHookPoint *HP_sysinfo_arch_post; + struct HPMHookPoint *HP_sysinfo_is64bit_pre; + struct HPMHookPoint *HP_sysinfo_is64bit_post; + struct HPMHookPoint *HP_sysinfo_compiler_pre; + struct HPMHookPoint *HP_sysinfo_compiler_post; + struct HPMHookPoint *HP_sysinfo_cflags_pre; + struct HPMHookPoint *HP_sysinfo_cflags_post; + struct HPMHookPoint *HP_sysinfo_vcstype_pre; + struct HPMHookPoint *HP_sysinfo_vcstype_post; + struct HPMHookPoint *HP_sysinfo_vcstypeid_pre; + struct HPMHookPoint *HP_sysinfo_vcstypeid_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_src_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_src_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_scripts_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_scripts_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_reload_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_reload_post; + struct HPMHookPoint *HP_sysinfo_is_superuser_pre; + struct HPMHookPoint *HP_sysinfo_is_superuser_post; + struct HPMHookPoint *HP_sysinfo_init_pre; + struct HPMHookPoint *HP_sysinfo_init_post; + struct HPMHookPoint *HP_sysinfo_final_pre; + struct HPMHookPoint *HP_sysinfo_final_post; + struct HPMHookPoint *HP_timer_gettick_pre; + struct HPMHookPoint *HP_timer_gettick_post; + struct HPMHookPoint *HP_timer_gettick_nocache_pre; + struct HPMHookPoint *HP_timer_gettick_nocache_post; + struct HPMHookPoint *HP_timer_add_pre; + struct HPMHookPoint *HP_timer_add_post; + struct HPMHookPoint *HP_timer_add_interval_pre; + struct HPMHookPoint *HP_timer_add_interval_post; + struct HPMHookPoint *HP_timer_get_pre; + struct HPMHookPoint *HP_timer_get_post; + struct HPMHookPoint *HP_timer_delete_pre; + struct HPMHookPoint *HP_timer_delete_post; + struct HPMHookPoint *HP_timer_addtick_pre; + struct HPMHookPoint *HP_timer_addtick_post; + struct HPMHookPoint *HP_timer_settick_pre; + struct HPMHookPoint *HP_timer_settick_post; + struct HPMHookPoint *HP_timer_add_func_list_pre; + struct HPMHookPoint *HP_timer_add_func_list_post; + struct HPMHookPoint *HP_timer_get_uptime_pre; + struct HPMHookPoint *HP_timer_get_uptime_post; + struct HPMHookPoint *HP_timer_perform_pre; + struct HPMHookPoint *HP_timer_perform_post; + struct HPMHookPoint *HP_timer_init_pre; + struct HPMHookPoint *HP_timer_init_post; + struct HPMHookPoint *HP_timer_final_pre; + struct HPMHookPoint *HP_timer_final_post; } list; struct { + int HP_HCache_init_pre; + int HP_HCache_init_post; + int HP_HCache_check_pre; + int HP_HCache_check_post; + int HP_HCache_open_pre; + int HP_HCache_open_post; + int HP_cmdline_init_pre; + int HP_cmdline_init_post; + int HP_cmdline_final_pre; + int HP_cmdline_final_post; + int HP_cmdline_arg_add_pre; + int HP_cmdline_arg_add_post; + int HP_cmdline_exec_pre; + int HP_cmdline_exec_post; + int HP_cmdline_arg_next_value_pre; + int HP_cmdline_arg_next_value_post; + int HP_cmdline_arg_source_pre; + int HP_cmdline_arg_source_post; + int HP_console_init_pre; + int HP_console_init_post; + int HP_console_final_pre; + int HP_console_final_post; + int HP_console_display_title_pre; + int HP_console_display_title_post; + int HP_core_shutdown_callback_pre; + int HP_core_shutdown_callback_post; + int HP_DB_fix_options_pre; + int HP_DB_fix_options_post; + int HP_DB_default_cmp_pre; + int HP_DB_default_cmp_post; + int HP_DB_default_hash_pre; + int HP_DB_default_hash_post; + int HP_DB_default_release_pre; + int HP_DB_default_release_post; + int HP_DB_custom_release_pre; + int HP_DB_custom_release_post; + int HP_DB_alloc_pre; + int HP_DB_alloc_post; + int HP_DB_i2key_pre; + int HP_DB_i2key_post; + int HP_DB_ui2key_pre; + int HP_DB_ui2key_post; + int HP_DB_str2key_pre; + int HP_DB_str2key_post; + int HP_DB_i642key_pre; + int HP_DB_i642key_post; + int HP_DB_ui642key_pre; + int HP_DB_ui642key_post; + int HP_DB_i2data_pre; + int HP_DB_i2data_post; + int HP_DB_ui2data_pre; + int HP_DB_ui2data_post; + int HP_DB_ptr2data_pre; + int HP_DB_ptr2data_post; + int HP_DB_data2i_pre; + int HP_DB_data2i_post; + int HP_DB_data2ui_pre; + int HP_DB_data2ui_post; + int HP_DB_data2ptr_pre; + int HP_DB_data2ptr_post; + int HP_DB_init_pre; + int HP_DB_init_post; + int HP_DB_final_pre; + int HP_DB_final_post; + int HP_libconfig_read_pre; + int HP_libconfig_read_post; + int HP_libconfig_write_pre; + int HP_libconfig_write_post; + int HP_libconfig_set_auto_convert_pre; + int HP_libconfig_set_auto_convert_post; + int HP_libconfig_get_auto_convert_pre; + int HP_libconfig_get_auto_convert_post; + int HP_libconfig_read_string_pre; + int HP_libconfig_read_string_post; + int HP_libconfig_read_file_src_pre; + int HP_libconfig_read_file_src_post; + int HP_libconfig_write_file_pre; + int HP_libconfig_write_file_post; + int HP_libconfig_set_destructor_pre; + int HP_libconfig_set_destructor_post; + int HP_libconfig_set_include_dir_pre; + int HP_libconfig_set_include_dir_post; + int HP_libconfig_init_pre; + int HP_libconfig_init_post; + int HP_libconfig_destroy_pre; + int HP_libconfig_destroy_post; + int HP_libconfig_setting_get_int_pre; + int HP_libconfig_setting_get_int_post; + int HP_libconfig_setting_get_int64_pre; + int HP_libconfig_setting_get_int64_post; + int HP_libconfig_setting_get_float_pre; + int HP_libconfig_setting_get_float_post; + int HP_libconfig_setting_get_bool_pre; + int HP_libconfig_setting_get_bool_post; + int HP_libconfig_setting_get_string_pre; + int HP_libconfig_setting_get_string_post; + int HP_libconfig_setting_lookup_int_pre; + int HP_libconfig_setting_lookup_int_post; + int HP_libconfig_setting_lookup_int64_pre; + int HP_libconfig_setting_lookup_int64_post; + int HP_libconfig_setting_lookup_float_pre; + int HP_libconfig_setting_lookup_float_post; + int HP_libconfig_setting_lookup_bool_pre; + int HP_libconfig_setting_lookup_bool_post; + int HP_libconfig_setting_lookup_string_pre; + int HP_libconfig_setting_lookup_string_post; + int HP_libconfig_setting_set_int_pre; + int HP_libconfig_setting_set_int_post; + int HP_libconfig_setting_set_int64_pre; + int HP_libconfig_setting_set_int64_post; + int HP_libconfig_setting_set_float_pre; + int HP_libconfig_setting_set_float_post; + int HP_libconfig_setting_set_bool_pre; + int HP_libconfig_setting_set_bool_post; + int HP_libconfig_setting_set_string_pre; + int HP_libconfig_setting_set_string_post; + int HP_libconfig_setting_set_format_pre; + int HP_libconfig_setting_set_format_post; + int HP_libconfig_setting_get_format_pre; + int HP_libconfig_setting_get_format_post; + int HP_libconfig_setting_get_int_elem_pre; + int HP_libconfig_setting_get_int_elem_post; + int HP_libconfig_setting_get_int64_elem_pre; + int HP_libconfig_setting_get_int64_elem_post; + int HP_libconfig_setting_get_float_elem_pre; + int HP_libconfig_setting_get_float_elem_post; + int HP_libconfig_setting_get_bool_elem_pre; + int HP_libconfig_setting_get_bool_elem_post; + int HP_libconfig_setting_get_string_elem_pre; + int HP_libconfig_setting_get_string_elem_post; + int HP_libconfig_setting_set_int_elem_pre; + int HP_libconfig_setting_set_int_elem_post; + int HP_libconfig_setting_set_int64_elem_pre; + int HP_libconfig_setting_set_int64_elem_post; + int HP_libconfig_setting_set_float_elem_pre; + int HP_libconfig_setting_set_float_elem_post; + int HP_libconfig_setting_set_bool_elem_pre; + int HP_libconfig_setting_set_bool_elem_post; + int HP_libconfig_setting_set_string_elem_pre; + int HP_libconfig_setting_set_string_elem_post; + int HP_libconfig_setting_index_pre; + int HP_libconfig_setting_index_post; + int HP_libconfig_setting_length_pre; + int HP_libconfig_setting_length_post; + int HP_libconfig_setting_get_elem_pre; + int HP_libconfig_setting_get_elem_post; + int HP_libconfig_setting_get_member_pre; + int HP_libconfig_setting_get_member_post; + int HP_libconfig_setting_add_pre; + int HP_libconfig_setting_add_post; + int HP_libconfig_setting_remove_pre; + int HP_libconfig_setting_remove_post; + int HP_libconfig_setting_remove_elem_pre; + int HP_libconfig_setting_remove_elem_post; + int HP_libconfig_setting_set_hook_pre; + int HP_libconfig_setting_set_hook_post; + int HP_libconfig_lookup_pre; + int HP_libconfig_lookup_post; + int HP_libconfig_lookup_from_pre; + int HP_libconfig_lookup_from_post; + int HP_libconfig_lookup_int_pre; + int HP_libconfig_lookup_int_post; + int HP_libconfig_lookup_int64_pre; + int HP_libconfig_lookup_int64_post; + int HP_libconfig_lookup_float_pre; + int HP_libconfig_lookup_float_post; + int HP_libconfig_lookup_bool_pre; + int HP_libconfig_lookup_bool_post; + int HP_libconfig_lookup_string_pre; + int HP_libconfig_lookup_string_post; + int HP_libconfig_read_file_pre; + int HP_libconfig_read_file_post; + int HP_libconfig_setting_copy_simple_pre; + int HP_libconfig_setting_copy_simple_post; + int HP_libconfig_setting_copy_elem_pre; + int HP_libconfig_setting_copy_elem_post; + int HP_libconfig_setting_copy_aggregate_pre; + int HP_libconfig_setting_copy_aggregate_post; + int HP_libconfig_setting_copy_pre; + int HP_libconfig_setting_copy_post; int HP_login_mmo_auth_pre; int HP_login_mmo_auth_post; int HP_login_mmo_auth_new_pre; @@ -142,10 +780,8 @@ struct { int HP_login_check_encrypted_post; int HP_login_check_password_pre; int HP_login_check_password_post; - int HP_login_lan_subnetcheck_pre; - int HP_login_lan_subnetcheck_post; - int HP_login_lan_config_read_pre; - int HP_login_lan_config_read_post; + int HP_login_lan_subnet_check_pre; + int HP_login_lan_subnet_check_post; int HP_login_fromchar_accinfo_pre; int HP_login_fromchar_accinfo_post; int HP_login_fromchar_account_pre; @@ -228,8 +864,304 @@ struct { int HP_login_parse_request_connection_post; int HP_login_parse_login_pre; int HP_login_parse_login_post; + int HP_iMalloc_init_pre; + int HP_iMalloc_init_post; + int HP_iMalloc_final_pre; + int HP_iMalloc_final_post; + int HP_iMalloc_malloc_pre; + int HP_iMalloc_malloc_post; + int HP_iMalloc_calloc_pre; + int HP_iMalloc_calloc_post; + int HP_iMalloc_realloc_pre; + int HP_iMalloc_realloc_post; + int HP_iMalloc_reallocz_pre; + int HP_iMalloc_reallocz_post; + int HP_iMalloc_astrdup_pre; + int HP_iMalloc_astrdup_post; + int HP_iMalloc_free_pre; + int HP_iMalloc_free_post; + int HP_iMalloc_memory_check_pre; + int HP_iMalloc_memory_check_post; + int HP_iMalloc_verify_ptr_pre; + int HP_iMalloc_verify_ptr_post; + int HP_iMalloc_usage_pre; + int HP_iMalloc_usage_post; + int HP_iMalloc_post_shutdown_pre; + int HP_iMalloc_post_shutdown_post; + int HP_iMalloc_init_messages_pre; + int HP_iMalloc_init_messages_post; + int HP_nullpo_assert_report_pre; + int HP_nullpo_assert_report_post; + int HP_showmsg_init_pre; + int HP_showmsg_init_post; + int HP_showmsg_final_pre; + int HP_showmsg_final_post; + int HP_showmsg_clearScreen_pre; + int HP_showmsg_clearScreen_post; + int HP_showmsg_showMessageV_pre; + int HP_showmsg_showMessageV_post; + int HP_sockt_init_pre; + int HP_sockt_init_post; + int HP_sockt_final_pre; + int HP_sockt_final_post; + int HP_sockt_perform_pre; + int HP_sockt_perform_post; + int HP_sockt_datasync_pre; + int HP_sockt_datasync_post; + int HP_sockt_make_listen_bind_pre; + int HP_sockt_make_listen_bind_post; + int HP_sockt_make_connection_pre; + int HP_sockt_make_connection_post; + int HP_sockt_realloc_fifo_pre; + int HP_sockt_realloc_fifo_post; + int HP_sockt_realloc_writefifo_pre; + int HP_sockt_realloc_writefifo_post; + int HP_sockt_wfifoset_pre; + int HP_sockt_wfifoset_post; + int HP_sockt_rfifoskip_pre; + int HP_sockt_rfifoskip_post; + int HP_sockt_close_pre; + int HP_sockt_close_post; + int HP_sockt_session_is_valid_pre; + int HP_sockt_session_is_valid_post; + int HP_sockt_session_is_active_pre; + int HP_sockt_session_is_active_post; + int HP_sockt_flush_pre; + int HP_sockt_flush_post; + int HP_sockt_flush_fifos_pre; + int HP_sockt_flush_fifos_post; + int HP_sockt_set_nonblocking_pre; + int HP_sockt_set_nonblocking_post; + int HP_sockt_set_defaultparse_pre; + int HP_sockt_set_defaultparse_post; + int HP_sockt_host2ip_pre; + int HP_sockt_host2ip_post; + int HP_sockt_ip2str_pre; + int HP_sockt_ip2str_post; + int HP_sockt_str2ip_pre; + int HP_sockt_str2ip_post; + int HP_sockt_ntows_pre; + int HP_sockt_ntows_post; + int HP_sockt_getips_pre; + int HP_sockt_getips_post; + int HP_sockt_eof_pre; + int HP_sockt_eof_post; + int HP_sockt_lan_subnet_check_pre; + int HP_sockt_lan_subnet_check_post; + int HP_sockt_allowed_ip_check_pre; + int HP_sockt_allowed_ip_check_post; + int HP_sockt_trusted_ip_check_pre; + int HP_sockt_trusted_ip_check_post; + int HP_sockt_net_config_read_sub_pre; + int HP_sockt_net_config_read_sub_post; + int HP_sockt_net_config_read_pre; + int HP_sockt_net_config_read_post; + int HP_SQL_Connect_pre; + int HP_SQL_Connect_post; + int HP_SQL_GetTimeout_pre; + int HP_SQL_GetTimeout_post; + int HP_SQL_GetColumnNames_pre; + int HP_SQL_GetColumnNames_post; + int HP_SQL_SetEncoding_pre; + int HP_SQL_SetEncoding_post; + int HP_SQL_Ping_pre; + int HP_SQL_Ping_post; + int HP_SQL_EscapeString_pre; + int HP_SQL_EscapeString_post; + int HP_SQL_EscapeStringLen_pre; + int HP_SQL_EscapeStringLen_post; + int HP_SQL_QueryV_pre; + int HP_SQL_QueryV_post; + int HP_SQL_QueryStr_pre; + int HP_SQL_QueryStr_post; + int HP_SQL_LastInsertId_pre; + int HP_SQL_LastInsertId_post; + int HP_SQL_NumColumns_pre; + int HP_SQL_NumColumns_post; + int HP_SQL_NumRows_pre; + int HP_SQL_NumRows_post; + int HP_SQL_NextRow_pre; + int HP_SQL_NextRow_post; + int HP_SQL_GetData_pre; + int HP_SQL_GetData_post; + int HP_SQL_FreeResult_pre; + int HP_SQL_FreeResult_post; + int HP_SQL_ShowDebug__pre; + int HP_SQL_ShowDebug__post; + int HP_SQL_Free_pre; + int HP_SQL_Free_post; + int HP_SQL_Malloc_pre; + int HP_SQL_Malloc_post; + int HP_SQL_StmtMalloc_pre; + int HP_SQL_StmtMalloc_post; + int HP_SQL_StmtPrepareV_pre; + int HP_SQL_StmtPrepareV_post; + int HP_SQL_StmtPrepareStr_pre; + int HP_SQL_StmtPrepareStr_post; + int HP_SQL_StmtNumParams_pre; + int HP_SQL_StmtNumParams_post; + int HP_SQL_StmtBindParam_pre; + int HP_SQL_StmtBindParam_post; + int HP_SQL_StmtExecute_pre; + int HP_SQL_StmtExecute_post; + int HP_SQL_StmtLastInsertId_pre; + int HP_SQL_StmtLastInsertId_post; + int HP_SQL_StmtNumColumns_pre; + int HP_SQL_StmtNumColumns_post; + int HP_SQL_StmtBindColumn_pre; + int HP_SQL_StmtBindColumn_post; + int HP_SQL_StmtNumRows_pre; + int HP_SQL_StmtNumRows_post; + int HP_SQL_StmtNextRow_pre; + int HP_SQL_StmtNextRow_post; + int HP_SQL_StmtFreeResult_pre; + int HP_SQL_StmtFreeResult_post; + int HP_SQL_StmtFree_pre; + int HP_SQL_StmtFree_post; + int HP_SQL_StmtShowDebug__pre; + int HP_SQL_StmtShowDebug__post; + int HP_StrBuf_Malloc_pre; + int HP_StrBuf_Malloc_post; + int HP_StrBuf_Init_pre; + int HP_StrBuf_Init_post; + int HP_StrBuf_Vprintf_pre; + int HP_StrBuf_Vprintf_post; + int HP_StrBuf_Append_pre; + int HP_StrBuf_Append_post; + int HP_StrBuf_AppendStr_pre; + int HP_StrBuf_AppendStr_post; + int HP_StrBuf_Length_pre; + int HP_StrBuf_Length_post; + int HP_StrBuf_Value_pre; + int HP_StrBuf_Value_post; + int HP_StrBuf_Clear_pre; + int HP_StrBuf_Clear_post; + int HP_StrBuf_Destroy_pre; + int HP_StrBuf_Destroy_post; + int HP_StrBuf_Free_pre; + int HP_StrBuf_Free_post; + int HP_strlib_jstrescape_pre; + int HP_strlib_jstrescape_post; + int HP_strlib_jstrescapecpy_pre; + int HP_strlib_jstrescapecpy_post; + int HP_strlib_jmemescapecpy_pre; + int HP_strlib_jmemescapecpy_post; + int HP_strlib_remove_control_chars__pre; + int HP_strlib_remove_control_chars__post; + int HP_strlib_trim__pre; + int HP_strlib_trim__post; + int HP_strlib_normalize_name__pre; + int HP_strlib_normalize_name__post; + int HP_strlib_stristr__pre; + int HP_strlib_stristr__post; + int HP_strlib_strnlen__pre; + int HP_strlib_strnlen__post; + int HP_strlib_strtok_r__pre; + int HP_strlib_strtok_r__post; + int HP_strlib_e_mail_check__pre; + int HP_strlib_e_mail_check__post; + int HP_strlib_config_switch__pre; + int HP_strlib_config_switch__post; + int HP_strlib_safestrncpy__pre; + int HP_strlib_safestrncpy__post; + int HP_strlib_safestrnlen__pre; + int HP_strlib_safestrnlen__post; + int HP_strlib_strline__pre; + int HP_strlib_strline__post; + int HP_strlib_bin2hex__pre; + int HP_strlib_bin2hex__post; + int HP_sv_parse_next_pre; + int HP_sv_parse_next_post; + int HP_sv_parse_pre; + int HP_sv_parse_post; + int HP_sv_split_pre; + int HP_sv_split_post; + int HP_sv_escape_c_pre; + int HP_sv_escape_c_post; + int HP_sv_unescape_c_pre; + int HP_sv_unescape_c_post; + int HP_sv_skip_escaped_c_pre; + int HP_sv_skip_escaped_c_post; + int HP_sv_readdb_pre; + int HP_sv_readdb_post; + int HP_sysinfo_getpagesize_pre; + int HP_sysinfo_getpagesize_post; + int HP_sysinfo_platform_pre; + int HP_sysinfo_platform_post; + int HP_sysinfo_osversion_pre; + int HP_sysinfo_osversion_post; + int HP_sysinfo_cpu_pre; + int HP_sysinfo_cpu_post; + int HP_sysinfo_cpucores_pre; + int HP_sysinfo_cpucores_post; + int HP_sysinfo_arch_pre; + int HP_sysinfo_arch_post; + int HP_sysinfo_is64bit_pre; + int HP_sysinfo_is64bit_post; + int HP_sysinfo_compiler_pre; + int HP_sysinfo_compiler_post; + int HP_sysinfo_cflags_pre; + int HP_sysinfo_cflags_post; + int HP_sysinfo_vcstype_pre; + int HP_sysinfo_vcstype_post; + int HP_sysinfo_vcstypeid_pre; + int HP_sysinfo_vcstypeid_post; + int HP_sysinfo_vcsrevision_src_pre; + int HP_sysinfo_vcsrevision_src_post; + int HP_sysinfo_vcsrevision_scripts_pre; + int HP_sysinfo_vcsrevision_scripts_post; + int HP_sysinfo_vcsrevision_reload_pre; + int HP_sysinfo_vcsrevision_reload_post; + int HP_sysinfo_is_superuser_pre; + int HP_sysinfo_is_superuser_post; + int HP_sysinfo_init_pre; + int HP_sysinfo_init_post; + int HP_sysinfo_final_pre; + int HP_sysinfo_final_post; + int HP_timer_gettick_pre; + int HP_timer_gettick_post; + int HP_timer_gettick_nocache_pre; + int HP_timer_gettick_nocache_post; + int HP_timer_add_pre; + int HP_timer_add_post; + int HP_timer_add_interval_pre; + int HP_timer_add_interval_post; + int HP_timer_get_pre; + int HP_timer_get_post; + int HP_timer_delete_pre; + int HP_timer_delete_post; + int HP_timer_addtick_pre; + int HP_timer_addtick_post; + int HP_timer_settick_pre; + int HP_timer_settick_post; + int HP_timer_add_func_list_pre; + int HP_timer_add_func_list_post; + int HP_timer_get_uptime_pre; + int HP_timer_get_uptime_post; + int HP_timer_perform_pre; + int HP_timer_perform_post; + int HP_timer_init_pre; + int HP_timer_init_post; + int HP_timer_final_pre; + int HP_timer_final_post; } count; struct { + struct HCache_interface HCache; + struct cmdline_interface cmdline; + struct console_interface console; + struct core_interface core; + struct db_interface DB; + struct libconfig_interface libconfig; struct login_interface login; + struct malloc_interface iMalloc; + struct nullpo_interface nullpo; + struct showmsg_interface showmsg; + struct socket_interface sockt; + struct sql_interface SQL; + struct stringbuf_interface StrBuf; + struct strlib_interface strlib; + struct sv_interface sv; + struct sysinfo_interface sysinfo; + struct timer_interface timer; } source; diff --git a/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc index a4a9db119..cdcdedcb5 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc @@ -5,6 +5,102 @@ // as it will get overwritten. struct HookingPointData HookingPoints[] = { +/* HCache */ + { HP_POP(HCache->init, HP_HCache_init) }, + { HP_POP(HCache->check, HP_HCache_check) }, + { HP_POP(HCache->open, HP_HCache_open) }, +/* cmdline */ + { HP_POP(cmdline->init, HP_cmdline_init) }, + { HP_POP(cmdline->final, HP_cmdline_final) }, + { HP_POP(cmdline->arg_add, HP_cmdline_arg_add) }, + { HP_POP(cmdline->exec, HP_cmdline_exec) }, + { HP_POP(cmdline->arg_next_value, HP_cmdline_arg_next_value) }, + { HP_POP(cmdline->arg_source, HP_cmdline_arg_source) }, +/* console */ + { HP_POP(console->init, HP_console_init) }, + { HP_POP(console->final, HP_console_final) }, + { HP_POP(console->display_title, HP_console_display_title) }, +/* core */ + { HP_POP(core->shutdown_callback, HP_core_shutdown_callback) }, +/* DB */ + { HP_POP(DB->fix_options, HP_DB_fix_options) }, + { HP_POP(DB->default_cmp, HP_DB_default_cmp) }, + { HP_POP(DB->default_hash, HP_DB_default_hash) }, + { HP_POP(DB->default_release, HP_DB_default_release) }, + { HP_POP(DB->custom_release, HP_DB_custom_release) }, + { HP_POP(DB->alloc, HP_DB_alloc) }, + { HP_POP(DB->i2key, HP_DB_i2key) }, + { HP_POP(DB->ui2key, HP_DB_ui2key) }, + { HP_POP(DB->str2key, HP_DB_str2key) }, + { HP_POP(DB->i642key, HP_DB_i642key) }, + { HP_POP(DB->ui642key, HP_DB_ui642key) }, + { HP_POP(DB->i2data, HP_DB_i2data) }, + { HP_POP(DB->ui2data, HP_DB_ui2data) }, + { HP_POP(DB->ptr2data, HP_DB_ptr2data) }, + { HP_POP(DB->data2i, HP_DB_data2i) }, + { HP_POP(DB->data2ui, HP_DB_data2ui) }, + { HP_POP(DB->data2ptr, HP_DB_data2ptr) }, + { HP_POP(DB->init, HP_DB_init) }, + { HP_POP(DB->final, HP_DB_final) }, +/* libconfig */ + { HP_POP(libconfig->read, HP_libconfig_read) }, + { HP_POP(libconfig->write, HP_libconfig_write) }, + { HP_POP(libconfig->set_auto_convert, HP_libconfig_set_auto_convert) }, + { HP_POP(libconfig->get_auto_convert, HP_libconfig_get_auto_convert) }, + { HP_POP(libconfig->read_string, HP_libconfig_read_string) }, + { HP_POP(libconfig->read_file_src, HP_libconfig_read_file_src) }, + { HP_POP(libconfig->write_file, HP_libconfig_write_file) }, + { HP_POP(libconfig->set_destructor, HP_libconfig_set_destructor) }, + { HP_POP(libconfig->set_include_dir, HP_libconfig_set_include_dir) }, + { HP_POP(libconfig->init, HP_libconfig_init) }, + { HP_POP(libconfig->destroy, HP_libconfig_destroy) }, + { HP_POP(libconfig->setting_get_int, HP_libconfig_setting_get_int) }, + { HP_POP(libconfig->setting_get_int64, HP_libconfig_setting_get_int64) }, + { HP_POP(libconfig->setting_get_float, HP_libconfig_setting_get_float) }, + { HP_POP(libconfig->setting_get_bool, HP_libconfig_setting_get_bool) }, + { HP_POP(libconfig->setting_get_string, HP_libconfig_setting_get_string) }, + { HP_POP(libconfig->setting_lookup_int, HP_libconfig_setting_lookup_int) }, + { HP_POP(libconfig->setting_lookup_int64, HP_libconfig_setting_lookup_int64) }, + { HP_POP(libconfig->setting_lookup_float, HP_libconfig_setting_lookup_float) }, + { HP_POP(libconfig->setting_lookup_bool, HP_libconfig_setting_lookup_bool) }, + { HP_POP(libconfig->setting_lookup_string, HP_libconfig_setting_lookup_string) }, + { HP_POP(libconfig->setting_set_int, HP_libconfig_setting_set_int) }, + { HP_POP(libconfig->setting_set_int64, HP_libconfig_setting_set_int64) }, + { HP_POP(libconfig->setting_set_float, HP_libconfig_setting_set_float) }, + { HP_POP(libconfig->setting_set_bool, HP_libconfig_setting_set_bool) }, + { HP_POP(libconfig->setting_set_string, HP_libconfig_setting_set_string) }, + { HP_POP(libconfig->setting_set_format, HP_libconfig_setting_set_format) }, + { HP_POP(libconfig->setting_get_format, HP_libconfig_setting_get_format) }, + { HP_POP(libconfig->setting_get_int_elem, HP_libconfig_setting_get_int_elem) }, + { HP_POP(libconfig->setting_get_int64_elem, HP_libconfig_setting_get_int64_elem) }, + { HP_POP(libconfig->setting_get_float_elem, HP_libconfig_setting_get_float_elem) }, + { HP_POP(libconfig->setting_get_bool_elem, HP_libconfig_setting_get_bool_elem) }, + { HP_POP(libconfig->setting_get_string_elem, HP_libconfig_setting_get_string_elem) }, + { HP_POP(libconfig->setting_set_int_elem, HP_libconfig_setting_set_int_elem) }, + { HP_POP(libconfig->setting_set_int64_elem, HP_libconfig_setting_set_int64_elem) }, + { HP_POP(libconfig->setting_set_float_elem, HP_libconfig_setting_set_float_elem) }, + { HP_POP(libconfig->setting_set_bool_elem, HP_libconfig_setting_set_bool_elem) }, + { HP_POP(libconfig->setting_set_string_elem, HP_libconfig_setting_set_string_elem) }, + { HP_POP(libconfig->setting_index, HP_libconfig_setting_index) }, + { HP_POP(libconfig->setting_length, HP_libconfig_setting_length) }, + { HP_POP(libconfig->setting_get_elem, HP_libconfig_setting_get_elem) }, + { HP_POP(libconfig->setting_get_member, HP_libconfig_setting_get_member) }, + { HP_POP(libconfig->setting_add, HP_libconfig_setting_add) }, + { HP_POP(libconfig->setting_remove, HP_libconfig_setting_remove) }, + { HP_POP(libconfig->setting_remove_elem, HP_libconfig_setting_remove_elem) }, + { HP_POP(libconfig->setting_set_hook, HP_libconfig_setting_set_hook) }, + { HP_POP(libconfig->lookup, HP_libconfig_lookup) }, + { HP_POP(libconfig->lookup_from, HP_libconfig_lookup_from) }, + { HP_POP(libconfig->lookup_int, HP_libconfig_lookup_int) }, + { HP_POP(libconfig->lookup_int64, HP_libconfig_lookup_int64) }, + { HP_POP(libconfig->lookup_float, HP_libconfig_lookup_float) }, + { HP_POP(libconfig->lookup_bool, HP_libconfig_lookup_bool) }, + { HP_POP(libconfig->lookup_string, HP_libconfig_lookup_string) }, + { HP_POP(libconfig->read_file, HP_libconfig_read_file) }, + { HP_POP(libconfig->setting_copy_simple, HP_libconfig_setting_copy_simple) }, + { HP_POP(libconfig->setting_copy_elem, HP_libconfig_setting_copy_elem) }, + { HP_POP(libconfig->setting_copy_aggregate, HP_libconfig_setting_copy_aggregate) }, + { HP_POP(libconfig->setting_copy, HP_libconfig_setting_copy) }, /* login */ { HP_POP(login->mmo_auth, HP_login_mmo_auth) }, { HP_POP(login->mmo_auth_new, HP_login_mmo_auth_new) }, @@ -18,8 +114,7 @@ struct HookingPointData HookingPoints[] = { { HP_POP(login->sync_ip_addresses, HP_login_sync_ip_addresses) }, { HP_POP(login->check_encrypted, HP_login_check_encrypted) }, { HP_POP(login->check_password, HP_login_check_password) }, - { HP_POP(login->lan_subnetcheck, HP_login_lan_subnetcheck) }, - { HP_POP(login->lan_config_read, HP_login_lan_config_read) }, + { HP_POP(login->lan_subnet_check, HP_login_lan_subnet_check) }, { HP_POP(login->fromchar_accinfo, HP_login_fromchar_accinfo) }, { HP_POP(login->fromchar_account, HP_login_fromchar_account) }, { HP_POP(login->fromchar_account_update_other, HP_login_fromchar_account_update_other) }, @@ -61,6 +156,156 @@ struct HookingPointData HookingPoints[] = { { HP_POP(login->char_server_connection_status, HP_login_char_server_connection_status) }, { HP_POP(login->parse_request_connection, HP_login_parse_request_connection) }, { HP_POP(login->parse_login, HP_login_parse_login) }, +/* iMalloc */ + { HP_POP(iMalloc->init, HP_iMalloc_init) }, + { HP_POP(iMalloc->final, HP_iMalloc_final) }, + { HP_POP(iMalloc->malloc, HP_iMalloc_malloc) }, + { HP_POP(iMalloc->calloc, HP_iMalloc_calloc) }, + { HP_POP(iMalloc->realloc, HP_iMalloc_realloc) }, + { HP_POP(iMalloc->reallocz, HP_iMalloc_reallocz) }, + { HP_POP(iMalloc->astrdup, HP_iMalloc_astrdup) }, + { HP_POP(iMalloc->free, HP_iMalloc_free) }, + { HP_POP(iMalloc->memory_check, HP_iMalloc_memory_check) }, + { HP_POP(iMalloc->verify_ptr, HP_iMalloc_verify_ptr) }, + { HP_POP(iMalloc->usage, HP_iMalloc_usage) }, + { HP_POP(iMalloc->post_shutdown, HP_iMalloc_post_shutdown) }, + { HP_POP(iMalloc->init_messages, HP_iMalloc_init_messages) }, +/* nullpo */ + { HP_POP(nullpo->assert_report, HP_nullpo_assert_report) }, +/* showmsg */ + { HP_POP(showmsg->init, HP_showmsg_init) }, + { HP_POP(showmsg->final, HP_showmsg_final) }, + { HP_POP(showmsg->clearScreen, HP_showmsg_clearScreen) }, + { HP_POP(showmsg->showMessageV, HP_showmsg_showMessageV) }, +/* sockt */ + { HP_POP(sockt->init, HP_sockt_init) }, + { HP_POP(sockt->final, HP_sockt_final) }, + { HP_POP(sockt->perform, HP_sockt_perform) }, + { HP_POP(sockt->datasync, HP_sockt_datasync) }, + { HP_POP(sockt->make_listen_bind, HP_sockt_make_listen_bind) }, + { HP_POP(sockt->make_connection, HP_sockt_make_connection) }, + { HP_POP(sockt->realloc_fifo, HP_sockt_realloc_fifo) }, + { HP_POP(sockt->realloc_writefifo, HP_sockt_realloc_writefifo) }, + { HP_POP(sockt->wfifoset, HP_sockt_wfifoset) }, + { HP_POP(sockt->rfifoskip, HP_sockt_rfifoskip) }, + { HP_POP(sockt->close, HP_sockt_close) }, + { HP_POP(sockt->session_is_valid, HP_sockt_session_is_valid) }, + { HP_POP(sockt->session_is_active, HP_sockt_session_is_active) }, + { HP_POP(sockt->flush, HP_sockt_flush) }, + { HP_POP(sockt->flush_fifos, HP_sockt_flush_fifos) }, + { HP_POP(sockt->set_nonblocking, HP_sockt_set_nonblocking) }, + { HP_POP(sockt->set_defaultparse, HP_sockt_set_defaultparse) }, + { HP_POP(sockt->host2ip, HP_sockt_host2ip) }, + { HP_POP(sockt->ip2str, HP_sockt_ip2str) }, + { HP_POP(sockt->str2ip, HP_sockt_str2ip) }, + { HP_POP(sockt->ntows, HP_sockt_ntows) }, + { HP_POP(sockt->getips, HP_sockt_getips) }, + { HP_POP(sockt->eof, HP_sockt_eof) }, + { HP_POP(sockt->lan_subnet_check, HP_sockt_lan_subnet_check) }, + { HP_POP(sockt->allowed_ip_check, HP_sockt_allowed_ip_check) }, + { HP_POP(sockt->trusted_ip_check, HP_sockt_trusted_ip_check) }, + { HP_POP(sockt->net_config_read_sub, HP_sockt_net_config_read_sub) }, + { HP_POP(sockt->net_config_read, HP_sockt_net_config_read) }, +/* SQL */ + { HP_POP(SQL->Connect, HP_SQL_Connect) }, + { HP_POP(SQL->GetTimeout, HP_SQL_GetTimeout) }, + { HP_POP(SQL->GetColumnNames, HP_SQL_GetColumnNames) }, + { HP_POP(SQL->SetEncoding, HP_SQL_SetEncoding) }, + { HP_POP(SQL->Ping, HP_SQL_Ping) }, + { HP_POP(SQL->EscapeString, HP_SQL_EscapeString) }, + { HP_POP(SQL->EscapeStringLen, HP_SQL_EscapeStringLen) }, + { HP_POP(SQL->QueryV, HP_SQL_QueryV) }, + { HP_POP(SQL->QueryStr, HP_SQL_QueryStr) }, + { HP_POP(SQL->LastInsertId, HP_SQL_LastInsertId) }, + { HP_POP(SQL->NumColumns, HP_SQL_NumColumns) }, + { HP_POP(SQL->NumRows, HP_SQL_NumRows) }, + { HP_POP(SQL->NextRow, HP_SQL_NextRow) }, + { HP_POP(SQL->GetData, HP_SQL_GetData) }, + { HP_POP(SQL->FreeResult, HP_SQL_FreeResult) }, + { HP_POP(SQL->ShowDebug_, HP_SQL_ShowDebug_) }, + { HP_POP(SQL->Free, HP_SQL_Free) }, + { HP_POP(SQL->Malloc, HP_SQL_Malloc) }, + { HP_POP(SQL->StmtMalloc, HP_SQL_StmtMalloc) }, + { HP_POP(SQL->StmtPrepareV, HP_SQL_StmtPrepareV) }, + { HP_POP(SQL->StmtPrepareStr, HP_SQL_StmtPrepareStr) }, + { HP_POP(SQL->StmtNumParams, HP_SQL_StmtNumParams) }, + { HP_POP(SQL->StmtBindParam, HP_SQL_StmtBindParam) }, + { HP_POP(SQL->StmtExecute, HP_SQL_StmtExecute) }, + { HP_POP(SQL->StmtLastInsertId, HP_SQL_StmtLastInsertId) }, + { HP_POP(SQL->StmtNumColumns, HP_SQL_StmtNumColumns) }, + { HP_POP(SQL->StmtBindColumn, HP_SQL_StmtBindColumn) }, + { HP_POP(SQL->StmtNumRows, HP_SQL_StmtNumRows) }, + { HP_POP(SQL->StmtNextRow, HP_SQL_StmtNextRow) }, + { HP_POP(SQL->StmtFreeResult, HP_SQL_StmtFreeResult) }, + { HP_POP(SQL->StmtFree, HP_SQL_StmtFree) }, + { HP_POP(SQL->StmtShowDebug_, HP_SQL_StmtShowDebug_) }, +/* StrBuf */ + { HP_POP(StrBuf->Malloc, HP_StrBuf_Malloc) }, + { HP_POP(StrBuf->Init, HP_StrBuf_Init) }, + { HP_POP(StrBuf->Vprintf, HP_StrBuf_Vprintf) }, + { HP_POP(StrBuf->Append, HP_StrBuf_Append) }, + { HP_POP(StrBuf->AppendStr, HP_StrBuf_AppendStr) }, + { HP_POP(StrBuf->Length, HP_StrBuf_Length) }, + { HP_POP(StrBuf->Value, HP_StrBuf_Value) }, + { HP_POP(StrBuf->Clear, HP_StrBuf_Clear) }, + { HP_POP(StrBuf->Destroy, HP_StrBuf_Destroy) }, + { HP_POP(StrBuf->Free, HP_StrBuf_Free) }, +/* strlib */ + { HP_POP(strlib->jstrescape, HP_strlib_jstrescape) }, + { HP_POP(strlib->jstrescapecpy, HP_strlib_jstrescapecpy) }, + { HP_POP(strlib->jmemescapecpy, HP_strlib_jmemescapecpy) }, + { HP_POP(strlib->remove_control_chars_, HP_strlib_remove_control_chars_) }, + { HP_POP(strlib->trim_, HP_strlib_trim_) }, + { HP_POP(strlib->normalize_name_, HP_strlib_normalize_name_) }, + { HP_POP(strlib->stristr_, HP_strlib_stristr_) }, + { HP_POP(strlib->strnlen_, HP_strlib_strnlen_) }, + { HP_POP(strlib->strtok_r_, HP_strlib_strtok_r_) }, + { HP_POP(strlib->e_mail_check_, HP_strlib_e_mail_check_) }, + { HP_POP(strlib->config_switch_, HP_strlib_config_switch_) }, + { HP_POP(strlib->safestrncpy_, HP_strlib_safestrncpy_) }, + { HP_POP(strlib->safestrnlen_, HP_strlib_safestrnlen_) }, + { HP_POP(strlib->strline_, HP_strlib_strline_) }, + { HP_POP(strlib->bin2hex_, HP_strlib_bin2hex_) }, +/* sv */ + { HP_POP(sv->parse_next, HP_sv_parse_next) }, + { HP_POP(sv->parse, HP_sv_parse) }, + { HP_POP(sv->split, HP_sv_split) }, + { HP_POP(sv->escape_c, HP_sv_escape_c) }, + { HP_POP(sv->unescape_c, HP_sv_unescape_c) }, + { HP_POP(sv->skip_escaped_c, HP_sv_skip_escaped_c) }, + { HP_POP(sv->readdb, HP_sv_readdb) }, +/* sysinfo */ + { HP_POP(sysinfo->getpagesize, HP_sysinfo_getpagesize) }, + { HP_POP(sysinfo->platform, HP_sysinfo_platform) }, + { HP_POP(sysinfo->osversion, HP_sysinfo_osversion) }, + { HP_POP(sysinfo->cpu, HP_sysinfo_cpu) }, + { HP_POP(sysinfo->cpucores, HP_sysinfo_cpucores) }, + { HP_POP(sysinfo->arch, HP_sysinfo_arch) }, + { HP_POP(sysinfo->is64bit, HP_sysinfo_is64bit) }, + { HP_POP(sysinfo->compiler, HP_sysinfo_compiler) }, + { HP_POP(sysinfo->cflags, HP_sysinfo_cflags) }, + { HP_POP(sysinfo->vcstype, HP_sysinfo_vcstype) }, + { HP_POP(sysinfo->vcstypeid, HP_sysinfo_vcstypeid) }, + { HP_POP(sysinfo->vcsrevision_src, HP_sysinfo_vcsrevision_src) }, + { HP_POP(sysinfo->vcsrevision_scripts, HP_sysinfo_vcsrevision_scripts) }, + { HP_POP(sysinfo->vcsrevision_reload, HP_sysinfo_vcsrevision_reload) }, + { HP_POP(sysinfo->is_superuser, HP_sysinfo_is_superuser) }, + { HP_POP(sysinfo->init, HP_sysinfo_init) }, + { HP_POP(sysinfo->final, HP_sysinfo_final) }, +/* timer */ + { HP_POP(timer->gettick, HP_timer_gettick) }, + { HP_POP(timer->gettick_nocache, HP_timer_gettick_nocache) }, + { HP_POP(timer->add, HP_timer_add) }, + { HP_POP(timer->add_interval, HP_timer_add_interval) }, + { HP_POP(timer->get, HP_timer_get) }, + { HP_POP(timer->delete, HP_timer_delete) }, + { HP_POP(timer->addtick, HP_timer_addtick) }, + { HP_POP(timer->settick, HP_timer_settick) }, + { HP_POP(timer->add_func_list, HP_timer_add_func_list) }, + { HP_POP(timer->get_uptime, HP_timer_get_uptime) }, + { HP_POP(timer->perform, HP_timer_perform) }, + { HP_POP(timer->init, HP_timer_init) }, + { HP_POP(timer->final, HP_timer_final) }, }; int HookingPointsLenMax = 42; diff --git a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc index 1ebd9fd1a..94b298d36 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc @@ -4,6 +4,2431 @@ // NOTE: This file was auto-generated and should never be manually edited, // as it will get overwritten. +/* HCache */ +void HP_HCache_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_HCache_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.HCache.init(); + } + if( HPMHooks.count.HP_HCache_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_HCache_check(const char *file) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_HCache_check_pre ) { + bool (*preHookFunc) (const char *file); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_check_pre[hIndex].func; + retVal___ = preHookFunc(file); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.HCache.check(file); + } + if( HPMHooks.count.HP_HCache_check_post ) { + bool (*postHookFunc) (bool retVal___, const char *file); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file); + } + } + return retVal___; +} +FILE* HP_HCache_open(const char *file, const char *opt) { + int hIndex = 0; + FILE* retVal___ = NULL; + if( HPMHooks.count.HP_HCache_open_pre ) { + FILE* (*preHookFunc) (const char *file, const char *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_open_pre[hIndex].func; + retVal___ = preHookFunc(file, opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.HCache.open(file, opt); + } + if( HPMHooks.count.HP_HCache_open_post ) { + FILE* (*postHookFunc) (FILE* retVal___, const char *file, const char *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_open_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file, opt); + } + } + return retVal___; +} +/* cmdline */ +void HP_cmdline_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_cmdline_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.cmdline.init(); + } + if( HPMHooks.count.HP_cmdline_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_cmdline_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_cmdline_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.cmdline.final(); + } + if( HPMHooks.count.HP_cmdline_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_cmdline_arg_add_pre ) { + bool (*preHookFunc) (unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_add_pre[hIndex].func; + retVal___ = preHookFunc(&pluginID, name, &shortname, &func, help, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_add(pluginID, name, shortname, func, help, options); + } + if( HPMHooks.count.HP_cmdline_arg_add_post ) { + bool (*postHookFunc) (bool retVal___, unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &pluginID, name, &shortname, &func, help, &options); + } + } + return retVal___; +} +int HP_cmdline_exec(int argc, char **argv, unsigned int options) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_cmdline_exec_pre ) { + int (*preHookFunc) (int *argc, char **argv, unsigned int *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_exec_pre[hIndex].func; + retVal___ = preHookFunc(&argc, argv, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.exec(argc, argv, options); + } + if( HPMHooks.count.HP_cmdline_exec_post ) { + int (*postHookFunc) (int retVal___, int *argc, char **argv, unsigned int *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_exec_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &argc, argv, &options); + } + } + return retVal___; +} +bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_cmdline_arg_next_value_pre ) { + bool (*preHookFunc) (const char *name, int *current_arg, int *argc); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_pre[hIndex].func; + retVal___ = preHookFunc(name, ¤t_arg, &argc); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_next_value(name, current_arg, argc); + } + if( HPMHooks.count.HP_cmdline_arg_next_value_post ) { + bool (*postHookFunc) (bool retVal___, const char *name, int *current_arg, int *argc); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_post[hIndex].func; + retVal___ = postHookFunc(retVal___, name, ¤t_arg, &argc); + } + } + return retVal___; +} +const char* HP_cmdline_arg_source(struct CmdlineArgData *arg) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_cmdline_arg_source_pre ) { + const char* (*preHookFunc) (struct CmdlineArgData *arg); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_source_pre[hIndex].func; + retVal___ = preHookFunc(arg); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_source(arg); + } + if( HPMHooks.count.HP_cmdline_arg_source_post ) { + const char* (*postHookFunc) (const char* retVal___, struct CmdlineArgData *arg); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_source_post[hIndex].func; + retVal___ = postHookFunc(retVal___, arg); + } + } + return retVal___; +} +/* console */ +void HP_console_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.init(); + } + if( HPMHooks.count.HP_console_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_console_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.final(); + } + if( HPMHooks.count.HP_console_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_console_display_title(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_display_title_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_display_title_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.display_title(); + } + if( HPMHooks.count.HP_console_display_title_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_display_title_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* core */ +void HP_core_shutdown_callback(void) { + int hIndex = 0; + if( HPMHooks.count.HP_core_shutdown_callback_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_core_shutdown_callback_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.core.shutdown_callback(); + } + if( HPMHooks.count.HP_core_shutdown_callback_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_core_shutdown_callback_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* DB */ +DBOptions HP_DB_fix_options(DBType type, DBOptions options) { + int hIndex = 0; + DBOptions retVal___ = DB_OPT_BASE; + if( HPMHooks.count.HP_DB_fix_options_pre ) { + DBOptions (*preHookFunc) (DBType *type, DBOptions *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_fix_options_pre[hIndex].func; + retVal___ = preHookFunc(&type, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.fix_options(type, options); + } + if( HPMHooks.count.HP_DB_fix_options_post ) { + DBOptions (*postHookFunc) (DBOptions retVal___, DBType *type, DBOptions *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_fix_options_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type, &options); + } + } + return retVal___; +} +DBComparator HP_DB_default_cmp(DBType type) { + int hIndex = 0; + DBComparator retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_cmp_pre ) { + DBComparator (*preHookFunc) (DBType *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_cmp_pre[hIndex].func; + retVal___ = preHookFunc(&type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_cmp(type); + } + if( HPMHooks.count.HP_DB_default_cmp_post ) { + DBComparator (*postHookFunc) (DBComparator retVal___, DBType *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_cmp_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type); + } + } + return retVal___; +} +DBHasher HP_DB_default_hash(DBType type) { + int hIndex = 0; + DBHasher retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_hash_pre ) { + DBHasher (*preHookFunc) (DBType *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_hash_pre[hIndex].func; + retVal___ = preHookFunc(&type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_hash(type); + } + if( HPMHooks.count.HP_DB_default_hash_post ) { + DBHasher (*postHookFunc) (DBHasher retVal___, DBType *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_hash_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type); + } + } + return retVal___; +} +DBReleaser HP_DB_default_release(DBType type, DBOptions options) { + int hIndex = 0; + DBReleaser retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_release_pre ) { + DBReleaser (*preHookFunc) (DBType *type, DBOptions *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_release_pre[hIndex].func; + retVal___ = preHookFunc(&type, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_release(type, options); + } + if( HPMHooks.count.HP_DB_default_release_post ) { + DBReleaser (*postHookFunc) (DBReleaser retVal___, DBType *type, DBOptions *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_release_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type, &options); + } + } + return retVal___; +} +DBReleaser HP_DB_custom_release(DBRelease which) { + int hIndex = 0; + DBReleaser retVal___ = NULL; + if( HPMHooks.count.HP_DB_custom_release_pre ) { + DBReleaser (*preHookFunc) (DBRelease *which); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_custom_release_pre[hIndex].func; + retVal___ = preHookFunc(&which); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.custom_release(which); + } + if( HPMHooks.count.HP_DB_custom_release_post ) { + DBReleaser (*postHookFunc) (DBReleaser retVal___, DBRelease *which); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_custom_release_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &which); + } + } + return retVal___; +} +DBMap* HP_DB_alloc(const char *file, const char *func, int line, DBType type, DBOptions options, unsigned short maxlen) { + int hIndex = 0; + DBMap* retVal___ = NULL; + if( HPMHooks.count.HP_DB_alloc_pre ) { + DBMap* (*preHookFunc) (const char *file, const char *func, int *line, DBType *type, DBOptions *options, unsigned short *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_alloc_pre[hIndex].func; + retVal___ = preHookFunc(file, func, &line, &type, &options, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen); + } + if( HPMHooks.count.HP_DB_alloc_post ) { + DBMap* (*postHookFunc) (DBMap* retVal___, const char *file, const char *func, int *line, DBType *type, DBOptions *options, unsigned short *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_alloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file, func, &line, &type, &options, &maxlen); + } + } + return retVal___; +} +DBKey HP_DB_i2key(int key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_i2key_pre ) { + DBKey (*preHookFunc) (int *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i2key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i2key(key); + } + if( HPMHooks.count.HP_DB_i2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, int *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_ui2key(unsigned int key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_ui2key_pre ) { + DBKey (*preHookFunc) (unsigned int *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui2key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui2key(key); + } + if( HPMHooks.count.HP_DB_ui2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, unsigned int *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_str2key(const char *key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_str2key_pre ) { + DBKey (*preHookFunc) (const char *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_str2key_pre[hIndex].func; + retVal___ = preHookFunc(key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.str2key(key); + } + if( HPMHooks.count.HP_DB_str2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, const char *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_str2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, key); + } + } + return retVal___; +} +DBKey HP_DB_i642key(int64 key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_i642key_pre ) { + DBKey (*preHookFunc) (int64 *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i642key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i642key(key); + } + if( HPMHooks.count.HP_DB_i642key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, int64 *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i642key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_ui642key(uint64 key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_ui642key_pre ) { + DBKey (*preHookFunc) (uint64 *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui642key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui642key(key); + } + if( HPMHooks.count.HP_DB_ui642key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, uint64 *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui642key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBData HP_DB_i2data(int data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_i2data_pre ) { + DBData (*preHookFunc) (int *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i2data_pre[hIndex].func; + retVal___ = preHookFunc(&data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i2data(data); + } + if( HPMHooks.count.HP_DB_i2data_post ) { + DBData (*postHookFunc) (DBData retVal___, int *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &data); + } + } + return retVal___; +} +DBData HP_DB_ui2data(unsigned int data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_ui2data_pre ) { + DBData (*preHookFunc) (unsigned int *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui2data_pre[hIndex].func; + retVal___ = preHookFunc(&data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui2data(data); + } + if( HPMHooks.count.HP_DB_ui2data_post ) { + DBData (*postHookFunc) (DBData retVal___, unsigned int *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &data); + } + } + return retVal___; +} +DBData HP_DB_ptr2data(void *data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_ptr2data_pre ) { + DBData (*preHookFunc) (void *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ptr2data_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ptr2data(data); + } + if( HPMHooks.count.HP_DB_ptr2data_post ) { + DBData (*postHookFunc) (DBData retVal___, void *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ptr2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +int HP_DB_data2i(DBData *data) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_DB_data2i_pre ) { + int (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2i_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2i(data); + } + if( HPMHooks.count.HP_DB_data2i_post ) { + int (*postHookFunc) (int retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2i_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +unsigned int HP_DB_data2ui(DBData *data) { + int hIndex = 0; + unsigned int retVal___ = 0; + if( HPMHooks.count.HP_DB_data2ui_pre ) { + unsigned int (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2ui_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2ui(data); + } + if( HPMHooks.count.HP_DB_data2ui_post ) { + unsigned int (*postHookFunc) (unsigned int retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2ui_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +void* HP_DB_data2ptr(DBData *data) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_DB_data2ptr_pre ) { + void* (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2ptr_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2ptr(data); + } + if( HPMHooks.count.HP_DB_data2ptr_post ) { + void* (*postHookFunc) (void* retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2ptr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +void HP_DB_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_DB_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.DB.init(); + } + if( HPMHooks.count.HP_DB_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_DB_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_DB_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.DB.final(); + } + if( HPMHooks.count.HP_DB_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* libconfig */ +int HP_libconfig_read(config_t *config, FILE *stream) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_pre ) { + int (*preHookFunc) (config_t *config, FILE *stream); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_pre[hIndex].func; + retVal___ = preHookFunc(config, stream); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read(config, stream); + } + if( HPMHooks.count.HP_libconfig_read_post ) { + int (*postHookFunc) (int retVal___, config_t *config, FILE *stream); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, stream); + } + } + return retVal___; +} +void HP_libconfig_write(const config_t *config, FILE *stream) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_write_pre ) { + void (*preHookFunc) (const config_t *config, FILE *stream); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_write_pre[hIndex].func; + preHookFunc(config, stream); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.write(config, stream); + } + if( HPMHooks.count.HP_libconfig_write_post ) { + void (*postHookFunc) (const config_t *config, FILE *stream); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_write_post[hIndex].func; + postHookFunc(config, stream); + } + } + return; +} +void HP_libconfig_set_auto_convert(config_t *config, int flag) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_auto_convert_pre ) { + void (*preHookFunc) (config_t *config, int *flag); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_auto_convert_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_auto_convert_pre[hIndex].func; + preHookFunc(config, &flag); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_auto_convert(config, flag); + } + if( HPMHooks.count.HP_libconfig_set_auto_convert_post ) { + void (*postHookFunc) (config_t *config, int *flag); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_auto_convert_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_auto_convert_post[hIndex].func; + postHookFunc(config, &flag); + } + } + return; +} +int HP_libconfig_get_auto_convert(const config_t *config) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_get_auto_convert_pre ) { + int (*preHookFunc) (const config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_auto_convert_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_get_auto_convert_pre[hIndex].func; + retVal___ = preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.get_auto_convert(config); + } + if( HPMHooks.count.HP_libconfig_get_auto_convert_post ) { + int (*postHookFunc) (int retVal___, const config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_auto_convert_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_get_auto_convert_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config); + } + } + return retVal___; +} +int HP_libconfig_read_string(config_t *config, const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_string_pre ) { + int (*preHookFunc) (config_t *config, const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_string_pre[hIndex].func; + retVal___ = preHookFunc(config, str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_string(config, str); + } + if( HPMHooks.count.HP_libconfig_read_string_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, str); + } + } + return retVal___; +} +int HP_libconfig_read_file_src(config_t *config, const char *filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_file_src_pre ) { + int (*preHookFunc) (config_t *config, const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_file_src_pre[hIndex].func; + retVal___ = preHookFunc(config, filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_file_src(config, filename); + } + if( HPMHooks.count.HP_libconfig_read_file_src_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_file_src_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filename); + } + } + return retVal___; +} +int HP_libconfig_write_file(config_t *config, const char *filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_write_file_pre ) { + int (*preHookFunc) (config_t *config, const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_write_file_pre[hIndex].func; + retVal___ = preHookFunc(config, filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.write_file(config, filename); + } + if( HPMHooks.count.HP_libconfig_write_file_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_write_file_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filename); + } + } + return retVal___; +} +void HP_libconfig_set_destructor(config_t *config, void ( *destructor ) (void *)) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_destructor_pre ) { + void (*preHookFunc) (config_t *config, void ( *destructor ) (void *)); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_destructor_pre[hIndex].func; + preHookFunc(config, destructor); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_destructor(config, destructor); + } + if( HPMHooks.count.HP_libconfig_set_destructor_post ) { + void (*postHookFunc) (config_t *config, void ( *destructor ) (void *)); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_destructor_post[hIndex].func; + postHookFunc(config, destructor); + } + } + return; +} +void HP_libconfig_set_include_dir(config_t *config, const char *include_dir) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) { + void (*preHookFunc) (config_t *config, const char *include_dir); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_pre[hIndex].func; + preHookFunc(config, include_dir); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_include_dir(config, include_dir); + } + if( HPMHooks.count.HP_libconfig_set_include_dir_post ) { + void (*postHookFunc) (config_t *config, const char *include_dir); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_post[hIndex].func; + postHookFunc(config, include_dir); + } + } + return; +} +void HP_libconfig_init(config_t *config) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_init_pre ) { + void (*preHookFunc) (config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_init_pre[hIndex].func; + preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.init(config); + } + if( HPMHooks.count.HP_libconfig_init_post ) { + void (*postHookFunc) (config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_init_post[hIndex].func; + postHookFunc(config); + } + } + return; +} +void HP_libconfig_destroy(config_t *config) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_destroy_pre ) { + void (*preHookFunc) (config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_destroy_pre[hIndex].func; + preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.destroy(config); + } + if( HPMHooks.count.HP_libconfig_destroy_post ) { + void (*postHookFunc) (config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_destroy_post[hIndex].func; + postHookFunc(config); + } + } + return; +} +int HP_libconfig_setting_get_int(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_int_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +long long HP_libconfig_setting_get_int64(const config_setting_t *setting) { + int hIndex = 0; + long long retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) { + long long (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int64(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_int64_post ) { + long long (*postHookFunc) (long long retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +double HP_libconfig_setting_get_float(const config_setting_t *setting) { + int hIndex = 0; + double retVal___ = 0.; + if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) { + double (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_float(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_float_post ) { + double (*postHookFunc) (double retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_get_bool(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_bool(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_bool_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +const char* HP_libconfig_setting_get_string(const config_setting_t *setting) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) { + const char* (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_string(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_string_post ) { + const char* (*postHookFunc) (const char* retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_int(const config_setting_t *setting, const char *name, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_int(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_int_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_int64(const config_setting_t *setting, const char *name, long long *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_int64(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_int64_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_float(const config_setting_t *setting, const char *name, double *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_float(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_float_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_bool(const config_setting_t *setting, const char *name, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_bool(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_bool_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_string(const config_setting_t *setting, const char *name, const char **value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, const char **value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_string(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_string_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, const char **value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_int(config_setting_t *setting, int value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) { + int (*preHookFunc) (config_setting_t *setting, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_int64(config_setting_t *setting, long long value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) { + int (*preHookFunc) (config_setting_t *setting, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_float(config_setting_t *setting, double value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) { + int (*preHookFunc) (config_setting_t *setting, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_float_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_bool(config_setting_t *setting, int value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) { + int (*preHookFunc) (config_setting_t *setting, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_string(config_setting_t *setting, const char *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) { + int (*preHookFunc) (config_setting_t *setting, const char *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_pre[hIndex].func; + retVal___ = preHookFunc(setting, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_string(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_string_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, const char *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_format(config_setting_t *setting, short format) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) { + int (*preHookFunc) (config_setting_t *setting, short *format); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_pre[hIndex].func; + retVal___ = preHookFunc(setting, &format); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format); + } + if( HPMHooks.count.HP_libconfig_setting_set_format_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, short *format); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &format); + } + } + return retVal___; +} +short HP_libconfig_setting_get_format(const config_setting_t *setting) { + int hIndex = 0; + short retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) { + short (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_format(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_format_post ) { + short (*postHookFunc) (short retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_get_int_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) { + int (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_int_elem_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +long long HP_libconfig_setting_get_int64_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + long long retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) { + long long (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int64_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_post ) { + long long (*postHookFunc) (long long retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +double HP_libconfig_setting_get_float_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + double retVal___ = 0.; + if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) { + double (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_float_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_float_elem_post ) { + double (*postHookFunc) (double retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +int HP_libconfig_setting_get_bool_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) { + int (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_bool_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +const char* HP_libconfig_setting_get_string_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) { + const char* (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_string_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_string_elem_post ) { + const char* (*postHookFunc) (const char* retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_int_elem(config_setting_t *setting, int idx, int value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_int64_elem(config_setting_t *setting, int idx, long long value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_float_elem(config_setting_t *setting, int idx, double value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_bool_elem(config_setting_t *setting, int idx, int value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_string_elem(config_setting_t *setting, int idx, const char *value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, const char *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, const char *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, value); + } + } + return retVal___; +} +int HP_libconfig_setting_index(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_index_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_index_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_index(setting); + } + if( HPMHooks.count.HP_libconfig_setting_index_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_index_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_length(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_length_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_length_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_length(setting); + } + if( HPMHooks.count.HP_libconfig_setting_length_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_length_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_get_elem(const config_setting_t *setting, unsigned int idx) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) { + config_setting_t* (*preHookFunc) (const config_setting_t *setting, unsigned int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_setting_t *setting, unsigned int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_get_member(const config_setting_t *setting, const char *name) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) { + config_setting_t* (*preHookFunc) (const config_setting_t *setting, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_pre[hIndex].func; + retVal___ = preHookFunc(setting, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_member(setting, name); + } + if( HPMHooks.count.HP_libconfig_setting_get_member_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_setting_t *setting, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_add(config_setting_t *parent, const char *name, int type) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_add_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *parent, const char *name, int *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_add_pre[hIndex].func; + retVal___ = preHookFunc(parent, name, &type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type); + } + if( HPMHooks.count.HP_libconfig_setting_add_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *parent, const char *name, int *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, name, &type); + } + } + return retVal___; +} +int HP_libconfig_setting_remove(config_setting_t *parent, const char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_remove_pre ) { + int (*preHookFunc) (config_setting_t *parent, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_pre[hIndex].func; + retVal___ = preHookFunc(parent, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_remove(parent, name); + } + if( HPMHooks.count.HP_libconfig_setting_remove_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, name); + } + } + return retVal___; +} +int HP_libconfig_setting_remove_elem(config_setting_t *parent, unsigned int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) { + int (*preHookFunc) (config_setting_t *parent, unsigned int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_pre[hIndex].func; + retVal___ = preHookFunc(parent, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx); + } + if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, unsigned int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, &idx); + } + } + return retVal___; +} +void HP_libconfig_setting_set_hook(config_setting_t *setting, void *hook) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) { + void (*preHookFunc) (config_setting_t *setting, void *hook); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_pre[hIndex].func; + preHookFunc(setting, hook); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_set_hook(setting, hook); + } + if( HPMHooks.count.HP_libconfig_setting_set_hook_post ) { + void (*postHookFunc) (config_setting_t *setting, void *hook); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_post[hIndex].func; + postHookFunc(setting, hook); + } + } + return; +} +config_setting_t* HP_libconfig_lookup(const config_t *config, const char *filepath) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_lookup_pre ) { + config_setting_t* (*preHookFunc) (const config_t *config, const char *filepath); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup(config, filepath); + } + if( HPMHooks.count.HP_libconfig_lookup_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_t *config, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_lookup_from(config_setting_t *setting, const char *filepath) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_lookup_from_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, const char *filepath); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_from_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_from_pre[hIndex].func; + retVal___ = preHookFunc(setting, filepath); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_from(setting, filepath); + } + if( HPMHooks.count.HP_libconfig_lookup_from_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_from_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_from_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, filepath); + } + } + return retVal___; +} +int HP_libconfig_lookup_int(const config_t *config, const char *filepath, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_int_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_int_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_int(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_int_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_int64(const config_t *config, const char *filepath, long long *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_int64(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_int64_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_float(const config_t *config, const char *filepath, double *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_float_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_float_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_float(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_float_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_bool(const config_t *config, const char *filepath, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_bool(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_bool_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_string(const config_t *config, const char *filepath, const char **value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_string_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, const char **value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_string_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_string(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_string_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, const char **value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_read_file(config_t *config, const char *config_filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_file_pre ) { + int (*preHookFunc) (config_t *config, const char *config_filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_file_pre[hIndex].func; + retVal___ = preHookFunc(config, config_filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_file(config, config_filename); + } + if( HPMHooks.count.HP_libconfig_read_file_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *config_filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_file_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, config_filename); + } + } + return retVal___; +} +void HP_libconfig_setting_copy_simple(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_simple(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_simple_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +void HP_libconfig_setting_copy_elem(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_elem(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_elem_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +void HP_libconfig_setting_copy_aggregate(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_aggregate(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +int HP_libconfig_setting_copy(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_pre ) { + int (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_pre[hIndex].func; + retVal___ = preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_copy(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, src); + } + } + return retVal___; +} /* login */ int HP_login_mmo_auth(struct login_session_data *sd, bool isServer) { int hIndex = 0; @@ -347,14 +2772,14 @@ bool HP_login_check_password(const char *md5key, int passwdenc, const char *pass } return retVal___; } -int HP_login_lan_subnetcheck(uint32 ip) { +uint32 HP_login_lan_subnet_check(uint32 ip) { int hIndex = 0; - int retVal___ = 0; - if( HPMHooks.count.HP_login_lan_subnetcheck_pre ) { - int (*preHookFunc) (uint32 *ip); + uint32 retVal___ = 0; + if( HPMHooks.count.HP_login_lan_subnet_check_pre ) { + uint32 (*preHookFunc) (uint32 *ip); *HPMforce_return = false; - for(hIndex = 0; hIndex < HPMHooks.count.HP_login_lan_subnetcheck_pre; hIndex++ ) { - preHookFunc = HPMHooks.list.HP_login_lan_subnetcheck_pre[hIndex].func; + for(hIndex = 0; hIndex < HPMHooks.count.HP_login_lan_subnet_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_login_lan_subnet_check_pre[hIndex].func; retVal___ = preHookFunc(&ip); } if( *HPMforce_return ) { @@ -363,44 +2788,17 @@ int HP_login_lan_subnetcheck(uint32 ip) { } } { - retVal___ = HPMHooks.source.login.lan_subnetcheck(ip); + retVal___ = HPMHooks.source.login.lan_subnet_check(ip); } - if( HPMHooks.count.HP_login_lan_subnetcheck_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip); - for(hIndex = 0; hIndex < HPMHooks.count.HP_login_lan_subnetcheck_post; hIndex++ ) { - postHookFunc = HPMHooks.list.HP_login_lan_subnetcheck_post[hIndex].func; + if( HPMHooks.count.HP_login_lan_subnet_check_post ) { + uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_login_lan_subnet_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_login_lan_subnet_check_post[hIndex].func; retVal___ = postHookFunc(retVal___, &ip); } } return retVal___; } -int HP_login_lan_config_read(const char *lancfgName) { - int hIndex = 0; - int retVal___ = 0; - if( HPMHooks.count.HP_login_lan_config_read_pre ) { - int (*preHookFunc) (const char *lancfgName); - *HPMforce_return = false; - for(hIndex = 0; hIndex < HPMHooks.count.HP_login_lan_config_read_pre; hIndex++ ) { - preHookFunc = HPMHooks.list.HP_login_lan_config_read_pre[hIndex].func; - retVal___ = preHookFunc(lancfgName); - } - if( *HPMforce_return ) { - *HPMforce_return = false; - return retVal___; - } - } - { - retVal___ = HPMHooks.source.login.lan_config_read(lancfgName); - } - if( HPMHooks.count.HP_login_lan_config_read_post ) { - int (*postHookFunc) (int retVal___, const char *lancfgName); - for(hIndex = 0; hIndex < HPMHooks.count.HP_login_lan_config_read_post; hIndex++ ) { - postHookFunc = HPMHooks.list.HP_login_lan_config_read_post[hIndex].func; - retVal___ = postHookFunc(retVal___, lancfgName); - } - } - return retVal___; -} void HP_login_fromchar_accinfo(int fd, int account_id, int u_fd, int u_aid, int u_group, int map_fd, struct mmo_account *acc) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_accinfo_pre ) { @@ -1418,14 +3816,14 @@ void HP_login_char_server_connection_status(int fd, struct login_session_data *s } return; } -void HP_login_parse_request_connection(int fd, struct login_session_data *sd, const char *ip) { +void HP_login_parse_request_connection(int fd, struct login_session_data *sd, const char *ip, uint32 ipl) { int hIndex = 0; if( HPMHooks.count.HP_login_parse_request_connection_pre ) { - void (*preHookFunc) (int *fd, struct login_session_data *sd, const char *ip); + void (*preHookFunc) (int *fd, struct login_session_data *sd, const char *ip, uint32 *ipl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_parse_request_connection_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_parse_request_connection_pre[hIndex].func; - preHookFunc(&fd, sd, ip); + preHookFunc(&fd, sd, ip, &ipl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1433,13 +3831,13 @@ void HP_login_parse_request_connection(int fd, struct login_session_data *sd, co } } { - HPMHooks.source.login.parse_request_connection(fd, sd, ip); + HPMHooks.source.login.parse_request_connection(fd, sd, ip, ipl); } if( HPMHooks.count.HP_login_parse_request_connection_post ) { - void (*postHookFunc) (int *fd, struct login_session_data *sd, const char *ip); + void (*postHookFunc) (int *fd, struct login_session_data *sd, const char *ip, uint32 *ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_parse_request_connection_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_parse_request_connection_post[hIndex].func; - postHookFunc(&fd, sd, ip); + postHookFunc(&fd, sd, ip, &ipl); } } return; @@ -1471,3 +3869,3782 @@ int HP_login_parse_login(int fd) { } return retVal___; } +/* iMalloc */ +void HP_iMalloc_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.init(); + } + if( HPMHooks.count.HP_iMalloc_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_iMalloc_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.final(); + } + if( HPMHooks.count.HP_iMalloc_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_malloc_pre ) { + void* (*preHookFunc) (size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func; + retVal___ = preHookFunc(&size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_malloc_post ) { + void* (*postHookFunc) (void* retVal___, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_calloc_pre ) { + void* (*preHookFunc) (size_t *num, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func; + retVal___ = preHookFunc(&num, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_calloc_post ) { + void* (*postHookFunc) (void* retVal___, size_t *num, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &num, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_realloc_pre ) { + void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func; + retVal___ = preHookFunc(p, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_realloc_post ) { + void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_reallocz_pre ) { + void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func; + retVal___ = preHookFunc(p, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_reallocz_post ) { + void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + } + } + return retVal___; +} +char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char *func) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_astrdup_pre ) { + char* (*preHookFunc) (const char *p, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func; + retVal___ = preHookFunc(p, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_astrdup_post ) { + char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, file, &line, func); + } + } + return retVal___; +} +void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_free_pre ) { + void (*preHookFunc) (void *p, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func; + preHookFunc(p, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.free(p, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_free_post ) { + void (*postHookFunc) (void *p, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func; + postHookFunc(p, file, &line, func); + } + } + return; +} +void HP_iMalloc_memory_check(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_memory_check_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_memory_check_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.memory_check(); + } + if( HPMHooks.count.HP_iMalloc_memory_check_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_memory_check_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_iMalloc_verify_ptr(void *ptr) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) { + bool (*preHookFunc) (void *ptr); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func; + retVal___ = preHookFunc(ptr); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.verify_ptr(ptr); + } + if( HPMHooks.count.HP_iMalloc_verify_ptr_post ) { + bool (*postHookFunc) (bool retVal___, void *ptr); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ptr); + } + } + return retVal___; +} +size_t HP_iMalloc_usage(void) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_iMalloc_usage_pre ) { + size_t (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_usage_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.usage(); + } + if( HPMHooks.count.HP_iMalloc_usage_post ) { + size_t (*postHookFunc) (size_t retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_usage_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_iMalloc_post_shutdown(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_post_shutdown_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.post_shutdown(); + } + if( HPMHooks.count.HP_iMalloc_post_shutdown_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_iMalloc_init_messages(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_init_messages_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_init_messages_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.init_messages(); + } + if( HPMHooks.count.HP_iMalloc_init_messages_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_init_messages_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* nullpo */ +void HP_nullpo_assert_report(const char *file, int line, const char *func, const char *targetname, const char *title) { + int hIndex = 0; + if( HPMHooks.count.HP_nullpo_assert_report_pre ) { + void (*preHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_nullpo_assert_report_pre[hIndex].func; + preHookFunc(file, &line, func, targetname, title); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.nullpo.assert_report(file, line, func, targetname, title); + } + if( HPMHooks.count.HP_nullpo_assert_report_post ) { + void (*postHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_nullpo_assert_report_post[hIndex].func; + postHookFunc(file, &line, func, targetname, title); + } + } + return; +} +/* showmsg */ +void HP_showmsg_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.init(); + } + if( HPMHooks.count.HP_showmsg_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_showmsg_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.final(); + } + if( HPMHooks.count.HP_showmsg_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_showmsg_clearScreen(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_clearScreen_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_clearScreen_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.clearScreen(); + } + if( HPMHooks.count.HP_showmsg_clearScreen_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_clearScreen_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_showmsg_showMessageV(const char *string, va_list ap) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_showmsg_showMessageV_pre ) { + int (*preHookFunc) (const char *string, va_list ap); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_pre; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + preHookFunc = HPMHooks.list.HP_showmsg_showMessageV_pre[hIndex].func; + retVal___ = preHookFunc(string, ap___copy); + va_end(ap___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list ap___copy; va_copy(ap___copy, ap); + retVal___ = HPMHooks.source.showmsg.showMessageV(string, ap___copy); + va_end(ap___copy); + } + if( HPMHooks.count.HP_showmsg_showMessageV_post ) { + int (*postHookFunc) (int retVal___, const char *string, va_list ap); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_post; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + postHookFunc = HPMHooks.list.HP_showmsg_showMessageV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, ap___copy); + va_end(ap___copy); + } + } + return retVal___; +} +/* sockt */ +void HP_sockt_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.init(); + } + if( HPMHooks.count.HP_sockt_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sockt_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.final(); + } + if( HPMHooks.count.HP_sockt_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_sockt_perform(int next) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_perform_pre ) { + int (*preHookFunc) (int *next); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_perform_pre[hIndex].func; + retVal___ = preHookFunc(&next); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.perform(next); + } + if( HPMHooks.count.HP_sockt_perform_post ) { + int (*postHookFunc) (int retVal___, int *next); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_perform_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &next); + } + } + return retVal___; +} +void HP_sockt_datasync(int fd, bool send) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_datasync_pre ) { + void (*preHookFunc) (int *fd, bool *send); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_datasync_pre[hIndex].func; + preHookFunc(&fd, &send); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.datasync(fd, send); + } + if( HPMHooks.count.HP_sockt_datasync_post ) { + void (*postHookFunc) (int *fd, bool *send); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_datasync_post[hIndex].func; + postHookFunc(&fd, &send); + } + } + return; +} +int HP_sockt_make_listen_bind(uint32 ip, uint16 port) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_make_listen_bind_pre ) { + int (*preHookFunc) (uint32 *ip, uint16 *port); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_pre[hIndex].func; + retVal___ = preHookFunc(&ip, &port); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.make_listen_bind(ip, port); + } + if( HPMHooks.count.HP_sockt_make_listen_bind_post ) { + int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, &port); + } + } + return retVal___; +} +int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_make_connection_pre ) { + int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_make_connection_pre[hIndex].func; + retVal___ = preHookFunc(&ip, &port, opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.make_connection(ip, port, opt); + } + if( HPMHooks.count.HP_sockt_make_connection_post ) { + int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port, struct hSockOpt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_make_connection_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, &port, opt); + } + } + return retVal___; +} +int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_size) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_realloc_fifo_pre ) { + int (*preHookFunc) (int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &rfifo_size, &wfifo_size); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.realloc_fifo(fd, rfifo_size, wfifo_size); + } + if( HPMHooks.count.HP_sockt_realloc_fifo_post ) { + int (*postHookFunc) (int retVal___, int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &rfifo_size, &wfifo_size); + } + } + return retVal___; +} +int HP_sockt_realloc_writefifo(int fd, size_t addition) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_realloc_writefifo_pre ) { + int (*preHookFunc) (int *fd, size_t *addition); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &addition); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.realloc_writefifo(fd, addition); + } + if( HPMHooks.count.HP_sockt_realloc_writefifo_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *addition); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &addition); + } + } + return retVal___; +} +int HP_sockt_wfifoset(int fd, size_t len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_wfifoset_pre ) { + int (*preHookFunc) (int *fd, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_wfifoset_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.wfifoset(fd, len); + } + if( HPMHooks.count.HP_sockt_wfifoset_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &len); + } + } + return retVal___; +} +int HP_sockt_rfifoskip(int fd, size_t len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_rfifoskip_pre ) { + int (*preHookFunc) (int *fd, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_rfifoskip_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len); + } + if( HPMHooks.count.HP_sockt_rfifoskip_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_rfifoskip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &len); + } + } + return retVal___; +} +void HP_sockt_close(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_close_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_close_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.close(fd); + } + if( HPMHooks.count.HP_sockt_close_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_close_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +bool HP_sockt_session_is_valid(int fd) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_session_is_valid_pre ) { + bool (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_session_is_valid_pre[hIndex].func; + retVal___ = preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.session_is_valid(fd); + } + if( HPMHooks.count.HP_sockt_session_is_valid_post ) { + bool (*postHookFunc) (bool retVal___, int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_session_is_valid_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd); + } + } + return retVal___; +} +bool HP_sockt_session_is_active(int fd) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_session_is_active_pre ) { + bool (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_session_is_active_pre[hIndex].func; + retVal___ = preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.session_is_active(fd); + } + if( HPMHooks.count.HP_sockt_session_is_active_post ) { + bool (*postHookFunc) (bool retVal___, int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_session_is_active_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd); + } + } + return retVal___; +} +void HP_sockt_flush(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_flush_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_flush_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.flush(fd); + } + if( HPMHooks.count.HP_sockt_flush_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_flush_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +void HP_sockt_flush_fifos(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_flush_fifos_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_flush_fifos_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.flush_fifos(); + } + if( HPMHooks.count.HP_sockt_flush_fifos_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_flush_fifos_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sockt_set_nonblocking(int fd, unsigned long yes) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_set_nonblocking_pre ) { + void (*preHookFunc) (int *fd, unsigned long *yes); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_pre[hIndex].func; + preHookFunc(&fd, &yes); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.set_nonblocking(fd, yes); + } + if( HPMHooks.count.HP_sockt_set_nonblocking_post ) { + void (*postHookFunc) (int *fd, unsigned long *yes); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_post[hIndex].func; + postHookFunc(&fd, &yes); + } + } + return; +} +void HP_sockt_set_defaultparse(ParseFunc defaultparse) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_set_defaultparse_pre ) { + void (*preHookFunc) (ParseFunc *defaultparse); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_pre[hIndex].func; + preHookFunc(&defaultparse); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.set_defaultparse(defaultparse); + } + if( HPMHooks.count.HP_sockt_set_defaultparse_post ) { + void (*postHookFunc) (ParseFunc *defaultparse); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_post[hIndex].func; + postHookFunc(&defaultparse); + } + } + return; +} +uint32 HP_sockt_host2ip(const char *hostname) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_host2ip_pre ) { + uint32 (*preHookFunc) (const char *hostname); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_host2ip_pre[hIndex].func; + retVal___ = preHookFunc(hostname); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.host2ip(hostname); + } + if( HPMHooks.count.HP_sockt_host2ip_post ) { + uint32 (*postHookFunc) (uint32 retVal___, const char *hostname); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_host2ip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, hostname); + } + } + return retVal___; +} +const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sockt_ip2str_pre ) { + const char* (*preHookFunc) (uint32 *ip, char *ip_str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_ip2str_pre[hIndex].func; + retVal___ = preHookFunc(&ip, ip_str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.ip2str(ip, ip_str); + } + if( HPMHooks.count.HP_sockt_ip2str_post ) { + const char* (*postHookFunc) (const char* retVal___, uint32 *ip, char *ip_str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_ip2str_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, ip_str); + } + } + return retVal___; +} +uint32 HP_sockt_str2ip(const char *ip_str) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_str2ip_pre ) { + uint32 (*preHookFunc) (const char *ip_str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_str2ip_pre[hIndex].func; + retVal___ = preHookFunc(ip_str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.str2ip(ip_str); + } + if( HPMHooks.count.HP_sockt_str2ip_post ) { + uint32 (*postHookFunc) (uint32 retVal___, const char *ip_str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_str2ip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ip_str); + } + } + return retVal___; +} +uint16 HP_sockt_ntows(uint16 netshort) { + int hIndex = 0; + uint16 retVal___ = 0; + if( HPMHooks.count.HP_sockt_ntows_pre ) { + uint16 (*preHookFunc) (uint16 *netshort); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_ntows_pre[hIndex].func; + retVal___ = preHookFunc(&netshort); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.ntows(netshort); + } + if( HPMHooks.count.HP_sockt_ntows_post ) { + uint16 (*postHookFunc) (uint16 retVal___, uint16 *netshort); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_ntows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &netshort); + } + } + return retVal___; +} +int HP_sockt_getips(uint32 *ips, int max) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_getips_pre ) { + int (*preHookFunc) (uint32 *ips, int *max); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_getips_pre[hIndex].func; + retVal___ = preHookFunc(ips, &max); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.getips(ips, max); + } + if( HPMHooks.count.HP_sockt_getips_post ) { + int (*postHookFunc) (int retVal___, uint32 *ips, int *max); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_getips_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ips, &max); + } + } + return retVal___; +} +void HP_sockt_eof(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_eof_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_eof_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.eof(fd); + } + if( HPMHooks.count.HP_sockt_eof_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_eof_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_lan_subnet_check_pre ) { + uint32 (*preHookFunc) (uint32 *ip, struct s_subnet *info); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip, info); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.lan_subnet_check(ip, info); + } + if( HPMHooks.count.HP_sockt_lan_subnet_check_post ) { + uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip, struct s_subnet *info); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, info); + } + } + return retVal___; +} +bool HP_sockt_allowed_ip_check(uint32 ip) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_allowed_ip_check_pre ) { + bool (*preHookFunc) (uint32 *ip); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip); + } + if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) { + bool (*postHookFunc) (bool retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip); + } + } + return retVal___; +} +bool HP_sockt_trusted_ip_check(uint32 ip) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_trusted_ip_check_pre ) { + bool (*preHookFunc) (uint32 *ip); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip); + } + if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) { + bool (*postHookFunc) (bool retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip); + } + } + return retVal___; +} +int HP_sockt_net_config_read_sub(config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) { + int (*preHookFunc) (config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_pre[hIndex].func; + retVal___ = preHookFunc(t, list, count, filename, groupname); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.net_config_read_sub(t, list, count, filename, groupname); + } + if( HPMHooks.count.HP_sockt_net_config_read_sub_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_post[hIndex].func; + retVal___ = postHookFunc(retVal___, t, list, count, filename, groupname); + } + } + return retVal___; +} +void HP_sockt_net_config_read(const char *filename) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_net_config_read_pre ) { + void (*preHookFunc) (const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_net_config_read_pre[hIndex].func; + preHookFunc(filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.net_config_read(filename); + } + if( HPMHooks.count.HP_sockt_net_config_read_post ) { + void (*postHookFunc) (const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_net_config_read_post[hIndex].func; + postHookFunc(filename); + } + } + return; +} +/* SQL */ +int HP_SQL_Connect(Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_Connect_pre ) { + int (*preHookFunc) (Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Connect_pre[hIndex].func; + retVal___ = preHookFunc(self, user, passwd, host, &port, db); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db); + } + if( HPMHooks.count.HP_SQL_Connect_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Connect_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, user, passwd, host, &port, db); + } + } + return retVal___; +} +int HP_SQL_GetTimeout(Sql *self, uint32 *out_timeout) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetTimeout_pre ) { + int (*preHookFunc) (Sql *self, uint32 *out_timeout); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetTimeout_pre[hIndex].func; + retVal___ = preHookFunc(self, out_timeout); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetTimeout(self, out_timeout); + } + if( HPMHooks.count.HP_SQL_GetTimeout_post ) { + int (*postHookFunc) (int retVal___, Sql *self, uint32 *out_timeout); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetTimeout_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_timeout); + } + } + return retVal___; +} +int HP_SQL_GetColumnNames(Sql *self, const char *table, char *out_buf, size_t buf_len, char sep) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) { + int (*preHookFunc) (Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_pre[hIndex].func; + retVal___ = preHookFunc(self, table, out_buf, &buf_len, &sep); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep); + } + if( HPMHooks.count.HP_SQL_GetColumnNames_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, table, out_buf, &buf_len, &sep); + } + } + return retVal___; +} +int HP_SQL_SetEncoding(Sql *self, const char *encoding) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_SetEncoding_pre ) { + int (*preHookFunc) (Sql *self, const char *encoding); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_SetEncoding_pre[hIndex].func; + retVal___ = preHookFunc(self, encoding); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.SetEncoding(self, encoding); + } + if( HPMHooks.count.HP_SQL_SetEncoding_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *encoding); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_SetEncoding_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, encoding); + } + } + return retVal___; +} +int HP_SQL_Ping(Sql *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_Ping_pre ) { + int (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Ping_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Ping(self); + } + if( HPMHooks.count.HP_SQL_Ping_post ) { + int (*postHookFunc) (int retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Ping_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +size_t HP_SQL_EscapeString(Sql *self, char *out_to, const char *from) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_EscapeString_pre ) { + size_t (*preHookFunc) (Sql *self, char *out_to, const char *from); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_EscapeString_pre[hIndex].func; + retVal___ = preHookFunc(self, out_to, from); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.EscapeString(self, out_to, from); + } + if( HPMHooks.count.HP_SQL_EscapeString_post ) { + size_t (*postHookFunc) (size_t retVal___, Sql *self, char *out_to, const char *from); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_EscapeString_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_to, from); + } + } + return retVal___; +} +size_t HP_SQL_EscapeStringLen(Sql *self, char *out_to, const char *from, size_t from_len) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) { + size_t (*preHookFunc) (Sql *self, char *out_to, const char *from, size_t *from_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_pre[hIndex].func; + retVal___ = preHookFunc(self, out_to, from, &from_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len); + } + if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) { + size_t (*postHookFunc) (size_t retVal___, Sql *self, char *out_to, const char *from, size_t *from_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_to, from, &from_len); + } + } + return retVal___; +} +int HP_SQL_QueryV(Sql *self, const char *query, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_QueryV_pre ) { + int (*preHookFunc) (Sql *self, const char *query, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_SQL_QueryV_pre[hIndex].func; + retVal___ = preHookFunc(self, query, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.SQL.QueryV(self, query, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_SQL_QueryV_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *query, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_SQL_QueryV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_SQL_QueryStr(Sql *self, const char *query) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_QueryStr_pre ) { + int (*preHookFunc) (Sql *self, const char *query); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_QueryStr_pre[hIndex].func; + retVal___ = preHookFunc(self, query); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.QueryStr(self, query); + } + if( HPMHooks.count.HP_SQL_QueryStr_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *query); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_QueryStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query); + } + } + return retVal___; +} +uint64 HP_SQL_LastInsertId(Sql *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_LastInsertId_pre ) { + uint64 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_LastInsertId_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.LastInsertId(self); + } + if( HPMHooks.count.HP_SQL_LastInsertId_post ) { + uint64 (*postHookFunc) (uint64 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_LastInsertId_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint32 HP_SQL_NumColumns(Sql *self) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_SQL_NumColumns_pre ) { + uint32 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NumColumns_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NumColumns(self); + } + if( HPMHooks.count.HP_SQL_NumColumns_post ) { + uint32 (*postHookFunc) (uint32 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NumColumns_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint64 HP_SQL_NumRows(Sql *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_NumRows_pre ) { + uint64 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NumRows_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NumRows(self); + } + if( HPMHooks.count.HP_SQL_NumRows_post ) { + uint64 (*postHookFunc) (uint64 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NumRows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_NextRow(Sql *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_NextRow_pre ) { + int (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NextRow_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NextRow(self); + } + if( HPMHooks.count.HP_SQL_NextRow_post ) { + int (*postHookFunc) (int retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NextRow_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_GetData(Sql *self, size_t col, char **out_buf, size_t *out_len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetData_pre ) { + int (*preHookFunc) (Sql *self, size_t *col, char **out_buf, size_t *out_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetData_pre[hIndex].func; + retVal___ = preHookFunc(self, &col, out_buf, out_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len); + } + if( HPMHooks.count.HP_SQL_GetData_post ) { + int (*postHookFunc) (int retVal___, Sql *self, size_t *col, char **out_buf, size_t *out_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetData_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &col, out_buf, out_len); + } + } + return retVal___; +} +void HP_SQL_FreeResult(Sql *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_FreeResult_pre ) { + void (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_FreeResult_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.FreeResult(self); + } + if( HPMHooks.count.HP_SQL_FreeResult_post ) { + void (*postHookFunc) (Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_FreeResult_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_ShowDebug_(Sql *self, const char *debug_file, const unsigned long debug_line) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_ShowDebug__pre ) { + void (*preHookFunc) (Sql *self, const char *debug_file, const unsigned long *debug_line); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_ShowDebug__pre[hIndex].func; + preHookFunc(self, debug_file, &debug_line); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line); + } + if( HPMHooks.count.HP_SQL_ShowDebug__post ) { + void (*postHookFunc) (Sql *self, const char *debug_file, const unsigned long *debug_line); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_ShowDebug__post[hIndex].func; + postHookFunc(self, debug_file, &debug_line); + } + } + return; +} +void HP_SQL_Free(Sql *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_Free_pre ) { + void (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Free_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.Free(self); + } + if( HPMHooks.count.HP_SQL_Free_post ) { + void (*postHookFunc) (Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Free_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +struct Sql* HP_SQL_Malloc(void) { + int hIndex = 0; + struct Sql* retVal___ = NULL; + if( HPMHooks.count.HP_SQL_Malloc_pre ) { + struct Sql* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Malloc_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Malloc(); + } + if( HPMHooks.count.HP_SQL_Malloc_post ) { + struct Sql* (*postHookFunc) (struct Sql* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +struct SqlStmt* HP_SQL_StmtMalloc(Sql *sql) { + int hIndex = 0; + struct SqlStmt* retVal___ = NULL; + if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) { + struct SqlStmt* (*preHookFunc) (Sql *sql); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_pre[hIndex].func; + retVal___ = preHookFunc(sql); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtMalloc(sql); + } + if( HPMHooks.count.HP_SQL_StmtMalloc_post ) { + struct SqlStmt* (*postHookFunc) (struct SqlStmt* retVal___, Sql *sql); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, sql); + } + } + return retVal___; +} +int HP_SQL_StmtPrepareV(SqlStmt *self, const char *query, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) { + int (*preHookFunc) (SqlStmt *self, const char *query, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_pre[hIndex].func; + retVal___ = preHookFunc(self, query, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.SQL.StmtPrepareV(self, query, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_SQL_StmtPrepareV_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, const char *query, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_SQL_StmtPrepareStr(SqlStmt *self, const char *query) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) { + int (*preHookFunc) (SqlStmt *self, const char *query); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_pre[hIndex].func; + retVal___ = preHookFunc(self, query); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtPrepareStr(self, query); + } + if( HPMHooks.count.HP_SQL_StmtPrepareStr_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, const char *query); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query); + } + } + return retVal___; +} +size_t HP_SQL_StmtNumParams(SqlStmt *self) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) { + size_t (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumParams(self); + } + if( HPMHooks.count.HP_SQL_StmtNumParams_post ) { + size_t (*postHookFunc) (size_t retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtBindParam(SqlStmt *self, size_t idx, SqlDataType buffer_type, void *buffer, size_t buffer_len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) { + int (*preHookFunc) (SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_pre[hIndex].func; + retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len); + } + if( HPMHooks.count.HP_SQL_StmtBindParam_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len); + } + } + return retVal___; +} +int HP_SQL_StmtExecute(SqlStmt *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtExecute_pre ) { + int (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtExecute_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtExecute(self); + } + if( HPMHooks.count.HP_SQL_StmtExecute_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtExecute_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint64 HP_SQL_StmtLastInsertId(SqlStmt *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) { + uint64 (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtLastInsertId(self); + } + if( HPMHooks.count.HP_SQL_StmtLastInsertId_post ) { + uint64 (*postHookFunc) (uint64 retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +size_t HP_SQL_StmtNumColumns(SqlStmt *self) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) { + size_t (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumColumns(self); + } + if( HPMHooks.count.HP_SQL_StmtNumColumns_post ) { + size_t (*postHookFunc) (size_t retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtBindColumn(SqlStmt *self, size_t idx, SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) { + int (*preHookFunc) (SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_pre[hIndex].func; + retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtBindColumn(self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); + } + if( HPMHooks.count.HP_SQL_StmtBindColumn_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + } + } + return retVal___; +} +uint64 HP_SQL_StmtNumRows(SqlStmt *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) { + uint64 (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumRows(self); + } + if( HPMHooks.count.HP_SQL_StmtNumRows_post ) { + uint64 (*postHookFunc) (uint64 retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtNextRow(SqlStmt *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) { + int (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNextRow(self); + } + if( HPMHooks.count.HP_SQL_StmtNextRow_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +void HP_SQL_StmtFreeResult(SqlStmt *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) { + void (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtFreeResult(self); + } + if( HPMHooks.count.HP_SQL_StmtFreeResult_post ) { + void (*postHookFunc) (SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_StmtFree(SqlStmt *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtFree_pre ) { + void (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtFree_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtFree(self); + } + if( HPMHooks.count.HP_SQL_StmtFree_post ) { + void (*postHookFunc) (SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtFree_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_StmtShowDebug_(SqlStmt *self, const char *debug_file, const unsigned long debug_line) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) { + void (*preHookFunc) (SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__pre[hIndex].func; + preHookFunc(self, debug_file, &debug_line); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line); + } + if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) { + void (*postHookFunc) (SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__post[hIndex].func; + postHookFunc(self, debug_file, &debug_line); + } + } + return; +} +/* StrBuf */ +StringBuf* HP_StrBuf_Malloc(void) { + int hIndex = 0; + StringBuf* retVal___ = NULL; + if( HPMHooks.count.HP_StrBuf_Malloc_pre ) { + StringBuf* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Malloc_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Malloc(); + } + if( HPMHooks.count.HP_StrBuf_Malloc_post ) { + StringBuf* (*postHookFunc) (StringBuf* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_StrBuf_Init(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Init_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Init_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Init(self); + } + if( HPMHooks.count.HP_StrBuf_Init_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Init_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +int HP_StrBuf_Vprintf(StringBuf *self, const char *fmt, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Vprintf_pre ) { + int (*preHookFunc) (StringBuf *self, const char *fmt, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_pre[hIndex].func; + retVal___ = preHookFunc(self, fmt, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.StrBuf.Vprintf(self, fmt, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_StrBuf_Vprintf_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const char *fmt, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, fmt, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_StrBuf_Append(StringBuf *self, const StringBuf *sbuf) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Append_pre ) { + int (*preHookFunc) (StringBuf *self, const StringBuf *sbuf); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Append_pre[hIndex].func; + retVal___ = preHookFunc(self, sbuf); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Append(self, sbuf); + } + if( HPMHooks.count.HP_StrBuf_Append_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const StringBuf *sbuf); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Append_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, sbuf); + } + } + return retVal___; +} +int HP_StrBuf_AppendStr(StringBuf *self, const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_AppendStr_pre ) { + int (*preHookFunc) (StringBuf *self, const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_pre[hIndex].func; + retVal___ = preHookFunc(self, str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.AppendStr(self, str); + } + if( HPMHooks.count.HP_StrBuf_AppendStr_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, str); + } + } + return retVal___; +} +int HP_StrBuf_Length(StringBuf *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Length_pre ) { + int (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Length_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Length(self); + } + if( HPMHooks.count.HP_StrBuf_Length_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Length_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +char* HP_StrBuf_Value(StringBuf *self) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_StrBuf_Value_pre ) { + char* (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Value_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Value(self); + } + if( HPMHooks.count.HP_StrBuf_Value_post ) { + char* (*postHookFunc) (char* retVal___, StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Value_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +void HP_StrBuf_Clear(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Clear_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Clear_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Clear(self); + } + if( HPMHooks.count.HP_StrBuf_Clear_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Clear_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_StrBuf_Destroy(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Destroy_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Destroy_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Destroy(self); + } + if( HPMHooks.count.HP_StrBuf_Destroy_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Destroy_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_StrBuf_Free(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Free_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Free_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Free(self); + } + if( HPMHooks.count.HP_StrBuf_Free_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Free_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +/* strlib */ +char* HP_strlib_jstrescape(char *pt) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_jstrescape_pre ) { + char* (*preHookFunc) (char *pt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jstrescape_pre[hIndex].func; + retVal___ = preHookFunc(pt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jstrescape(pt); + } + if( HPMHooks.count.HP_strlib_jstrescape_post ) { + char* (*postHookFunc) (char* retVal___, char *pt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jstrescape_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt); + } + } + return retVal___; +} +char* HP_strlib_jstrescapecpy(char *pt, const char *spt) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_jstrescapecpy_pre ) { + char* (*preHookFunc) (char *pt, const char *spt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_pre[hIndex].func; + retVal___ = preHookFunc(pt, spt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jstrescapecpy(pt, spt); + } + if( HPMHooks.count.HP_strlib_jstrescapecpy_post ) { + char* (*postHookFunc) (char* retVal___, char *pt, const char *spt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt, spt); + } + } + return retVal___; +} +int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_jmemescapecpy_pre ) { + int (*preHookFunc) (char *pt, const char *spt, int *size); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_pre[hIndex].func; + retVal___ = preHookFunc(pt, spt, &size); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jmemescapecpy(pt, spt, size); + } + if( HPMHooks.count.HP_strlib_jmemescapecpy_post ) { + int (*postHookFunc) (int retVal___, char *pt, const char *spt, int *size); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt, spt, &size); + } + } + return retVal___; +} +int HP_strlib_remove_control_chars_(char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_remove_control_chars__pre ) { + int (*preHookFunc) (char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.remove_control_chars_(str); + } + if( HPMHooks.count.HP_strlib_remove_control_chars__post ) { + int (*postHookFunc) (int retVal___, char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_trim_(char *str) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_trim__pre ) { + char* (*preHookFunc) (char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_trim__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.trim_(str); + } + if( HPMHooks.count.HP_strlib_trim__post ) { + char* (*postHookFunc) (char* retVal___, char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_trim__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_normalize_name_(char *str, const char *delims) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_normalize_name__pre ) { + char* (*preHookFunc) (char *str, const char *delims); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_normalize_name__pre[hIndex].func; + retVal___ = preHookFunc(str, delims); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.normalize_name_(str, delims); + } + if( HPMHooks.count.HP_strlib_normalize_name__post ) { + char* (*postHookFunc) (char* retVal___, char *str, const char *delims); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_normalize_name__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, delims); + } + } + return retVal___; +} +const char* HP_strlib_stristr_(const char *haystack, const char *needle) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_stristr__pre ) { + const char* (*preHookFunc) (const char *haystack, const char *needle); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_stristr__pre[hIndex].func; + retVal___ = preHookFunc(haystack, needle); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.stristr_(haystack, needle); + } + if( HPMHooks.count.HP_strlib_stristr__post ) { + const char* (*postHookFunc) (const char* retVal___, const char *haystack, const char *needle); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_stristr__post[hIndex].func; + retVal___ = postHookFunc(retVal___, haystack, needle); + } + } + return retVal___; +} +size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_strlib_strnlen__pre ) { + size_t (*preHookFunc) (const char *string, size_t *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strnlen__pre[hIndex].func; + retVal___ = preHookFunc(string, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strnlen_(string, maxlen); + } + if( HPMHooks.count.HP_strlib_strnlen__post ) { + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strnlen__post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, &maxlen); + } + } + return retVal___; +} +char* HP_strlib_strtok_r_(char *s1, const char *s2, char **lasts) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_strtok_r__pre ) { + char* (*preHookFunc) (char *s1, const char *s2, char **lasts); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strtok_r__pre[hIndex].func; + retVal___ = preHookFunc(s1, s2, lasts); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strtok_r_(s1, s2, lasts); + } + if( HPMHooks.count.HP_strlib_strtok_r__post ) { + char* (*postHookFunc) (char* retVal___, char *s1, const char *s2, char **lasts); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strtok_r__post[hIndex].func; + retVal___ = postHookFunc(retVal___, s1, s2, lasts); + } + } + return retVal___; +} +int HP_strlib_e_mail_check_(char *email) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_e_mail_check__pre ) { + int (*preHookFunc) (char *email); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_e_mail_check__pre[hIndex].func; + retVal___ = preHookFunc(email); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.e_mail_check_(email); + } + if( HPMHooks.count.HP_strlib_e_mail_check__post ) { + int (*postHookFunc) (int retVal___, char *email); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_e_mail_check__post[hIndex].func; + retVal___ = postHookFunc(retVal___, email); + } + } + return retVal___; +} +int HP_strlib_config_switch_(const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_config_switch__pre ) { + int (*preHookFunc) (const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_config_switch__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.config_switch_(str); + } + if( HPMHooks.count.HP_strlib_config_switch__post ) { + int (*postHookFunc) (int retVal___, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_config_switch__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_safestrncpy__pre ) { + char* (*preHookFunc) (char *dst, const char *src, size_t *n); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_safestrncpy__pre[hIndex].func; + retVal___ = preHookFunc(dst, src, &n); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.safestrncpy_(dst, src, n); + } + if( HPMHooks.count.HP_strlib_safestrncpy__post ) { + char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t *n); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_safestrncpy__post[hIndex].func; + retVal___ = postHookFunc(retVal___, dst, src, &n); + } + } + return retVal___; +} +size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_strlib_safestrnlen__pre ) { + size_t (*preHookFunc) (const char *string, size_t *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_safestrnlen__pre[hIndex].func; + retVal___ = preHookFunc(string, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.safestrnlen_(string, maxlen); + } + if( HPMHooks.count.HP_strlib_safestrnlen__post ) { + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_safestrnlen__post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, &maxlen); + } + } + return retVal___; +} +int HP_strlib_strline_(const char *str, size_t pos) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_strline__pre ) { + int (*preHookFunc) (const char *str, size_t *pos); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strline__pre[hIndex].func; + retVal___ = preHookFunc(str, &pos); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strline_(str, pos); + } + if( HPMHooks.count.HP_strlib_strline__post ) { + int (*postHookFunc) (int retVal___, const char *str, size_t *pos); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strline__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &pos); + } + } + return retVal___; +} +bool HP_strlib_bin2hex_(char *output, unsigned char *input, size_t count) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_strlib_bin2hex__pre ) { + bool (*preHookFunc) (char *output, unsigned char *input, size_t *count); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_bin2hex__pre[hIndex].func; + retVal___ = preHookFunc(output, input, &count); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count); + } + if( HPMHooks.count.HP_strlib_bin2hex__post ) { + bool (*postHookFunc) (bool retVal___, char *output, unsigned char *input, size_t *count); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_bin2hex__post[hIndex].func; + retVal___ = postHookFunc(retVal___, output, input, &count); + } + } + return retVal___; +} +/* sv */ +int HP_sv_parse_next(struct s_svstate *svstate) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_parse_next_pre ) { + int (*preHookFunc) (struct s_svstate *svstate); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_parse_next_pre[hIndex].func; + retVal___ = preHookFunc(svstate); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.parse_next(svstate); + } + if( HPMHooks.count.HP_sv_parse_next_post ) { + int (*postHookFunc) (int retVal___, struct s_svstate *svstate); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_parse_next_post[hIndex].func; + retVal___ = postHookFunc(retVal___, svstate); + } + } + return retVal___; +} +int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_parse_pre ) { + int (*preHookFunc) (const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_parse_pre[hIndex].func; + retVal___ = preHookFunc(str, &len, &startoff, &delim, out_pos, &npos, &opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.parse(str, len, startoff, delim, out_pos, npos, opt); + } + if( HPMHooks.count.HP_sv_parse_post ) { + int (*postHookFunc) (int retVal___, const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_parse_post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_pos, &npos, &opt); + } + } + return retVal___; +} +int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_split_pre ) { + int (*preHookFunc) (char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_split_pre[hIndex].func; + retVal___ = preHookFunc(str, &len, &startoff, &delim, out_fields, &nfields, &opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.split(str, len, startoff, delim, out_fields, nfields, opt); + } + if( HPMHooks.count.HP_sv_split_post ) { + int (*postHookFunc) (int retVal___, char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_split_post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_fields, &nfields, &opt); + } + } + return retVal___; +} +size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *escapes) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_sv_escape_c_pre ) { + size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len, const char *escapes); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_escape_c_pre[hIndex].func; + retVal___ = preHookFunc(out_dest, src, &len, escapes); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.escape_c(out_dest, src, len, escapes); + } + if( HPMHooks.count.HP_sv_escape_c_post ) { + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len, const char *escapes); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_escape_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, out_dest, src, &len, escapes); + } + } + return retVal___; +} +size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_sv_unescape_c_pre ) { + size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_unescape_c_pre[hIndex].func; + retVal___ = preHookFunc(out_dest, src, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.unescape_c(out_dest, src, len); + } + if( HPMHooks.count.HP_sv_unescape_c_post ) { + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_unescape_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, out_dest, src, &len); + } + } + return retVal___; +} +const char* HP_sv_skip_escaped_c(const char *p) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sv_skip_escaped_c_pre ) { + const char* (*preHookFunc) (const char *p); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_pre[hIndex].func; + retVal___ = preHookFunc(p); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.skip_escaped_c(p); + } + if( HPMHooks.count.HP_sv_skip_escaped_c_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *p); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p); + } + } + return retVal___; +} +bool HP_sv_readdb(const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sv_readdb_pre ) { + bool (*preHookFunc) (const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_readdb_pre[hIndex].func; + retVal___ = preHookFunc(directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.readdb(directory, filename, delim, mincols, maxcols, maxrows, parseproc); + } + if( HPMHooks.count.HP_sv_readdb_post ) { + bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_readdb_post[hIndex].func; + retVal___ = postHookFunc(retVal___, directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + } + } + return retVal___; +} +/* sysinfo */ +int HP_sysinfo_getpagesize(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_getpagesize_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.getpagesize(); + } + if( HPMHooks.count.HP_sysinfo_getpagesize_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_platform(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_platform_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_platform_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.platform(); + } + if( HPMHooks.count.HP_sysinfo_platform_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_platform_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_osversion(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_osversion_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_osversion_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.osversion(); + } + if( HPMHooks.count.HP_sysinfo_osversion_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_osversion_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_cpu(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_cpu_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cpu_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cpu(); + } + if( HPMHooks.count.HP_sysinfo_cpu_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cpu_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_sysinfo_cpucores(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_cpucores_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cpucores_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cpucores(); + } + if( HPMHooks.count.HP_sysinfo_cpucores_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cpucores_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_arch(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_arch_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_arch_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.arch(); + } + if( HPMHooks.count.HP_sysinfo_arch_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_arch_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +bool HP_sysinfo_is64bit(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sysinfo_is64bit_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_is64bit_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.is64bit(); + } + if( HPMHooks.count.HP_sysinfo_is64bit_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_is64bit_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_compiler(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_compiler_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_compiler_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.compiler(); + } + if( HPMHooks.count.HP_sysinfo_compiler_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_compiler_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_cflags(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_cflags_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cflags_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cflags(); + } + if( HPMHooks.count.HP_sysinfo_cflags_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cflags_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcstype(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcstype_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcstype_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcstype(); + } + if( HPMHooks.count.HP_sysinfo_vcstype_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcstype_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_sysinfo_vcstypeid(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_vcstypeid_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcstypeid(); + } + if( HPMHooks.count.HP_sysinfo_vcstypeid_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcsrevision_src(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcsrevision_src_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcsrevision_src(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_src_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcsrevision_scripts(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcsrevision_scripts(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_sysinfo_vcsrevision_reload(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.vcsrevision_reload(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_sysinfo_is_superuser(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sysinfo_is_superuser_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.is_superuser(); + } + if( HPMHooks.count.HP_sysinfo_is_superuser_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_sysinfo_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.init(); + } + if( HPMHooks.count.HP_sysinfo_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sysinfo_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.final(); + } + if( HPMHooks.count.HP_sysinfo_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* timer */ +int64 HP_timer_gettick(void) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_gettick_pre ) { + int64 (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_gettick_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.gettick(); + } + if( HPMHooks.count.HP_timer_gettick_post ) { + int64 (*postHookFunc) (int64 retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_gettick_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int64 HP_timer_gettick_nocache(void) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_gettick_nocache_pre ) { + int64 (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_gettick_nocache_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.gettick_nocache(); + } + if( HPMHooks.count.HP_timer_gettick_nocache_post ) { + int64 (*postHookFunc) (int64 retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_gettick_nocache_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_pre ) { + int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_pre[hIndex].func; + retVal___ = preHookFunc(&tick, &func, &id, &data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add(tick, func, id, data); + } + if( HPMHooks.count.HP_timer_add_post ) { + int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data); + } + } + return retVal___; +} +int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int interval) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_interval_pre ) { + int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_interval_pre[hIndex].func; + retVal___ = preHookFunc(&tick, &func, &id, &data, &interval); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add_interval(tick, func, id, data, interval); + } + if( HPMHooks.count.HP_timer_add_interval_post ) { + int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_interval_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data, &interval); + } + } + return retVal___; +} +const struct TimerData* HP_timer_get(int tid) { + int hIndex = 0; + const struct TimerData* retVal___ = NULL; + if( HPMHooks.count.HP_timer_get_pre ) { + const struct TimerData* (*preHookFunc) (int *tid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_get_pre[hIndex].func; + retVal___ = preHookFunc(&tid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.get(tid); + } + if( HPMHooks.count.HP_timer_get_post ) { + const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int *tid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_get_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid); + } + } + return retVal___; +} +int HP_timer_delete(int tid, TimerFunc func) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_delete_pre ) { + int (*preHookFunc) (int *tid, TimerFunc *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_delete_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.delete(tid, func); + } + if( HPMHooks.count.HP_timer_delete_post ) { + int (*postHookFunc) (int retVal___, int *tid, TimerFunc *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_delete_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &func); + } + } + return retVal___; +} +int64 HP_timer_addtick(int tid, int64 tick) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_addtick_pre ) { + int64 (*preHookFunc) (int *tid, int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_addtick_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.addtick(tid, tick); + } + if( HPMHooks.count.HP_timer_addtick_post ) { + int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_addtick_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &tick); + } + } + return retVal___; +} +int64 HP_timer_settick(int tid, int64 tick) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_settick_pre ) { + int64 (*preHookFunc) (int *tid, int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_settick_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.settick(tid, tick); + } + if( HPMHooks.count.HP_timer_settick_post ) { + int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_settick_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &tick); + } + } + return retVal___; +} +int HP_timer_add_func_list(TimerFunc func, char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_func_list_pre ) { + int (*preHookFunc) (TimerFunc *func, char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_func_list_pre[hIndex].func; + retVal___ = preHookFunc(&func, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add_func_list(func, name); + } + if( HPMHooks.count.HP_timer_add_func_list_post ) { + int (*postHookFunc) (int retVal___, TimerFunc *func, char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_func_list_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &func, name); + } + } + return retVal___; +} +unsigned long HP_timer_get_uptime(void) { + int hIndex = 0; + unsigned long retVal___ = 0; + if( HPMHooks.count.HP_timer_get_uptime_pre ) { + unsigned long (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_get_uptime_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.get_uptime(); + } + if( HPMHooks.count.HP_timer_get_uptime_post ) { + unsigned long (*postHookFunc) (unsigned long retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_get_uptime_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_timer_perform(int64 tick) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_perform_pre ) { + int (*preHookFunc) (int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_perform_pre[hIndex].func; + retVal___ = preHookFunc(&tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.perform(tick); + } + if( HPMHooks.count.HP_timer_perform_post ) { + int (*postHookFunc) (int retVal___, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_perform_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick); + } + } + return retVal___; +} +void HP_timer_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_timer_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.timer.init(); + } + if( HPMHooks.count.HP_timer_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_timer_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_timer_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.timer.final(); + } + if( HPMHooks.count.HP_timer_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} diff --git a/src/plugins/HPMHooking/HPMHooking_login.sources.inc b/src/plugins/HPMHooking/HPMHooking_login.sources.inc index aa1bb2625..aed0dc77f 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.sources.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.sources.inc @@ -4,4 +4,20 @@ // NOTE: This file was auto-generated and should never be manually edited, // as it will get overwritten. +memcpy(&HPMHooks.source.HCache, HCache, sizeof(struct HCache_interface)); +memcpy(&HPMHooks.source.cmdline, cmdline, sizeof(struct cmdline_interface)); +memcpy(&HPMHooks.source.console, console, sizeof(struct console_interface)); +memcpy(&HPMHooks.source.core, core, sizeof(struct core_interface)); +memcpy(&HPMHooks.source.DB, DB, sizeof(struct db_interface)); +memcpy(&HPMHooks.source.libconfig, libconfig, sizeof(struct libconfig_interface)); memcpy(&HPMHooks.source.login, login, sizeof(struct login_interface)); +memcpy(&HPMHooks.source.iMalloc, iMalloc, sizeof(struct malloc_interface)); +memcpy(&HPMHooks.source.nullpo, nullpo, sizeof(struct nullpo_interface)); +memcpy(&HPMHooks.source.showmsg, showmsg, sizeof(struct showmsg_interface)); +memcpy(&HPMHooks.source.sockt, sockt, sizeof(struct socket_interface)); +memcpy(&HPMHooks.source.SQL, SQL, sizeof(struct sql_interface)); +memcpy(&HPMHooks.source.StrBuf, StrBuf, sizeof(struct stringbuf_interface)); +memcpy(&HPMHooks.source.strlib, strlib, sizeof(struct strlib_interface)); +memcpy(&HPMHooks.source.sv, sv, sizeof(struct sv_interface)); +memcpy(&HPMHooks.source.sysinfo, sysinfo, sizeof(struct sysinfo_interface)); +memcpy(&HPMHooks.source.timer, timer, sizeof(struct timer_interface)); diff --git a/src/plugins/HPMHooking/HPMHooking_map.GetSymbol.inc b/src/plugins/HPMHooking/HPMHooking_map.GetSymbol.inc deleted file mode 100644 index 88fe7745a..000000000 --- a/src/plugins/HPMHooking/HPMHooking_map.GetSymbol.inc +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright (c) Hercules Dev Team, licensed under GNU GPL. -// See the LICENSE file -// -// NOTE: This file was auto-generated and should never be manually edited, -// as it will get overwritten. - -if( !(atcommand = GET_SYMBOL("atcommand") ) ) return "atcommand"; -if( !(battle = GET_SYMBOL("battle") ) ) return "battle"; -if( !(bg = GET_SYMBOL("battlegrounds") ) ) return "battlegrounds"; -if( !(buyingstore = GET_SYMBOL("buyingstore") ) ) return "buyingstore"; -if( !(channel = GET_SYMBOL("channel") ) ) return "channel"; -if( !(chat = GET_SYMBOL("chat") ) ) return "chat"; -if( !(chrif = GET_SYMBOL("chrif") ) ) return "chrif"; -if( !(clif = GET_SYMBOL("clif") ) ) return "clif"; -if( !(duel = GET_SYMBOL("duel") ) ) return "duel"; -if( !(elemental = GET_SYMBOL("elemental") ) ) return "elemental"; -if( !(guild = GET_SYMBOL("guild") ) ) return "guild"; -if( !(gstorage = GET_SYMBOL("gstorage") ) ) return "gstorage"; -if( !(homun = GET_SYMBOL("homun") ) ) return "homun"; -if( !(instance = GET_SYMBOL("instance") ) ) return "instance"; -if( !(intif = GET_SYMBOL("intif") ) ) return "intif"; -if( !(ircbot = GET_SYMBOL("ircbot") ) ) return "ircbot"; -if( !(itemdb = GET_SYMBOL("itemdb") ) ) return "itemdb"; -if( !(logs = GET_SYMBOL("logs") ) ) return "logs"; -if( !(mail = GET_SYMBOL("mail") ) ) return "mail"; -if( !(map = GET_SYMBOL("map") ) ) return "map"; -if( !(mapit = GET_SYMBOL("mapit") ) ) return "mapit"; -if( !(mapreg = GET_SYMBOL("mapreg") ) ) return "mapreg"; -if( !(mercenary = GET_SYMBOL("mercenary") ) ) return "mercenary"; -if( !(mob = GET_SYMBOL("mob") ) ) return "mob"; -if( !(npc = GET_SYMBOL("npc") ) ) return "npc"; -if( !(party = GET_SYMBOL("party") ) ) return "party"; -if( !(path = GET_SYMBOL("path") ) ) return "path"; -if( !(pcg = GET_SYMBOL("pc_groups") ) ) return "pc_groups"; -if( !(pc = GET_SYMBOL("pc") ) ) return "pc"; -if( !(pet = GET_SYMBOL("pet") ) ) return "pet"; -if( !(quest = GET_SYMBOL("quest") ) ) return "quest"; -if( !(script = GET_SYMBOL("script") ) ) return "script"; -if( !(searchstore = GET_SYMBOL("searchstore") ) ) return "searchstore"; -if( !(skill = GET_SYMBOL("skill") ) ) return "skill"; -if( !(status = GET_SYMBOL("status") ) ) return "status"; -if( !(storage = GET_SYMBOL("storage") ) ) return "storage"; -if( !(trade = GET_SYMBOL("trade") ) ) return "trade"; -if( !(unit = GET_SYMBOL("unit") ) ) return "unit"; -if( !(vending = GET_SYMBOL("vending") ) ) return "vending"; diff --git a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc index f3e3711c1..28892e84d 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc @@ -5,6 +5,12 @@ // as it will get overwritten. struct { + struct HPMHookPoint *HP_HCache_init_pre; + struct HPMHookPoint *HP_HCache_init_post; + struct HPMHookPoint *HP_HCache_check_pre; + struct HPMHookPoint *HP_HCache_check_post; + struct HPMHookPoint *HP_HCache_open_pre; + struct HPMHookPoint *HP_HCache_open_post; struct HPMHookPoint *HP_atcommand_init_pre; struct HPMHookPoint *HP_atcommand_init_post; struct HPMHookPoint *HP_atcommand_final_pre; @@ -1807,6 +1813,64 @@ struct { struct HPMHookPoint *HP_clif_pNPCMarketClosed_post; struct HPMHookPoint *HP_clif_pNPCMarketPurchase_pre; struct HPMHookPoint *HP_clif_pNPCMarketPurchase_post; + struct HPMHookPoint *HP_cmdline_init_pre; + struct HPMHookPoint *HP_cmdline_init_post; + struct HPMHookPoint *HP_cmdline_final_pre; + struct HPMHookPoint *HP_cmdline_final_post; + struct HPMHookPoint *HP_cmdline_arg_add_pre; + struct HPMHookPoint *HP_cmdline_arg_add_post; + struct HPMHookPoint *HP_cmdline_exec_pre; + struct HPMHookPoint *HP_cmdline_exec_post; + struct HPMHookPoint *HP_cmdline_arg_next_value_pre; + struct HPMHookPoint *HP_cmdline_arg_next_value_post; + struct HPMHookPoint *HP_cmdline_arg_source_pre; + struct HPMHookPoint *HP_cmdline_arg_source_post; + struct HPMHookPoint *HP_console_init_pre; + struct HPMHookPoint *HP_console_init_post; + struct HPMHookPoint *HP_console_final_pre; + struct HPMHookPoint *HP_console_final_post; + struct HPMHookPoint *HP_console_display_title_pre; + struct HPMHookPoint *HP_console_display_title_post; + struct HPMHookPoint *HP_core_shutdown_callback_pre; + struct HPMHookPoint *HP_core_shutdown_callback_post; + struct HPMHookPoint *HP_DB_fix_options_pre; + struct HPMHookPoint *HP_DB_fix_options_post; + struct HPMHookPoint *HP_DB_default_cmp_pre; + struct HPMHookPoint *HP_DB_default_cmp_post; + struct HPMHookPoint *HP_DB_default_hash_pre; + struct HPMHookPoint *HP_DB_default_hash_post; + struct HPMHookPoint *HP_DB_default_release_pre; + struct HPMHookPoint *HP_DB_default_release_post; + struct HPMHookPoint *HP_DB_custom_release_pre; + struct HPMHookPoint *HP_DB_custom_release_post; + struct HPMHookPoint *HP_DB_alloc_pre; + struct HPMHookPoint *HP_DB_alloc_post; + struct HPMHookPoint *HP_DB_i2key_pre; + struct HPMHookPoint *HP_DB_i2key_post; + struct HPMHookPoint *HP_DB_ui2key_pre; + struct HPMHookPoint *HP_DB_ui2key_post; + struct HPMHookPoint *HP_DB_str2key_pre; + struct HPMHookPoint *HP_DB_str2key_post; + struct HPMHookPoint *HP_DB_i642key_pre; + struct HPMHookPoint *HP_DB_i642key_post; + struct HPMHookPoint *HP_DB_ui642key_pre; + struct HPMHookPoint *HP_DB_ui642key_post; + struct HPMHookPoint *HP_DB_i2data_pre; + struct HPMHookPoint *HP_DB_i2data_post; + struct HPMHookPoint *HP_DB_ui2data_pre; + struct HPMHookPoint *HP_DB_ui2data_post; + struct HPMHookPoint *HP_DB_ptr2data_pre; + struct HPMHookPoint *HP_DB_ptr2data_post; + struct HPMHookPoint *HP_DB_data2i_pre; + struct HPMHookPoint *HP_DB_data2i_post; + struct HPMHookPoint *HP_DB_data2ui_pre; + struct HPMHookPoint *HP_DB_data2ui_post; + struct HPMHookPoint *HP_DB_data2ptr_pre; + struct HPMHookPoint *HP_DB_data2ptr_post; + struct HPMHookPoint *HP_DB_init_pre; + struct HPMHookPoint *HP_DB_init_post; + struct HPMHookPoint *HP_DB_final_pre; + struct HPMHookPoint *HP_DB_final_post; struct HPMHookPoint *HP_duel_create_pre; struct HPMHookPoint *HP_duel_create_post; struct HPMHookPoint *HP_duel_invite_pre; @@ -2635,6 +2699,122 @@ struct { struct HPMHookPoint *HP_itemdb_is_item_usable_post; struct HPMHookPoint *HP_itemdb_lookup_const_pre; struct HPMHookPoint *HP_itemdb_lookup_const_post; + struct HPMHookPoint *HP_libconfig_read_pre; + struct HPMHookPoint *HP_libconfig_read_post; + struct HPMHookPoint *HP_libconfig_write_pre; + struct HPMHookPoint *HP_libconfig_write_post; + struct HPMHookPoint *HP_libconfig_set_auto_convert_pre; + struct HPMHookPoint *HP_libconfig_set_auto_convert_post; + struct HPMHookPoint *HP_libconfig_get_auto_convert_pre; + struct HPMHookPoint *HP_libconfig_get_auto_convert_post; + struct HPMHookPoint *HP_libconfig_read_string_pre; + struct HPMHookPoint *HP_libconfig_read_string_post; + struct HPMHookPoint *HP_libconfig_read_file_src_pre; + struct HPMHookPoint *HP_libconfig_read_file_src_post; + struct HPMHookPoint *HP_libconfig_write_file_pre; + struct HPMHookPoint *HP_libconfig_write_file_post; + struct HPMHookPoint *HP_libconfig_set_destructor_pre; + struct HPMHookPoint *HP_libconfig_set_destructor_post; + struct HPMHookPoint *HP_libconfig_set_include_dir_pre; + struct HPMHookPoint *HP_libconfig_set_include_dir_post; + struct HPMHookPoint *HP_libconfig_init_pre; + struct HPMHookPoint *HP_libconfig_init_post; + struct HPMHookPoint *HP_libconfig_destroy_pre; + struct HPMHookPoint *HP_libconfig_destroy_post; + struct HPMHookPoint *HP_libconfig_setting_get_int_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int_post; + struct HPMHookPoint *HP_libconfig_setting_get_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int64_post; + struct HPMHookPoint *HP_libconfig_setting_get_float_pre; + struct HPMHookPoint *HP_libconfig_setting_get_float_post; + struct HPMHookPoint *HP_libconfig_setting_get_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_get_bool_post; + struct HPMHookPoint *HP_libconfig_setting_get_string_pre; + struct HPMHookPoint *HP_libconfig_setting_get_string_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_int_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_int_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_int64_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_float_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_float_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_bool_post; + struct HPMHookPoint *HP_libconfig_setting_lookup_string_pre; + struct HPMHookPoint *HP_libconfig_setting_lookup_string_post; + struct HPMHookPoint *HP_libconfig_setting_set_int_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int_post; + struct HPMHookPoint *HP_libconfig_setting_set_int64_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int64_post; + struct HPMHookPoint *HP_libconfig_setting_set_float_pre; + struct HPMHookPoint *HP_libconfig_setting_set_float_post; + struct HPMHookPoint *HP_libconfig_setting_set_bool_pre; + struct HPMHookPoint *HP_libconfig_setting_set_bool_post; + struct HPMHookPoint *HP_libconfig_setting_set_string_pre; + struct HPMHookPoint *HP_libconfig_setting_set_string_post; + struct HPMHookPoint *HP_libconfig_setting_set_format_pre; + struct HPMHookPoint *HP_libconfig_setting_set_format_post; + struct HPMHookPoint *HP_libconfig_setting_get_format_pre; + struct HPMHookPoint *HP_libconfig_setting_get_format_post; + struct HPMHookPoint *HP_libconfig_setting_get_int_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_int64_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_int64_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_float_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_float_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_bool_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_bool_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_string_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_string_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_int_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_int64_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_int64_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_float_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_float_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_bool_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_bool_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_string_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_set_string_elem_post; + struct HPMHookPoint *HP_libconfig_setting_index_pre; + struct HPMHookPoint *HP_libconfig_setting_index_post; + struct HPMHookPoint *HP_libconfig_setting_length_pre; + struct HPMHookPoint *HP_libconfig_setting_length_post; + struct HPMHookPoint *HP_libconfig_setting_get_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_get_elem_post; + struct HPMHookPoint *HP_libconfig_setting_get_member_pre; + struct HPMHookPoint *HP_libconfig_setting_get_member_post; + struct HPMHookPoint *HP_libconfig_setting_add_pre; + struct HPMHookPoint *HP_libconfig_setting_add_post; + struct HPMHookPoint *HP_libconfig_setting_remove_pre; + struct HPMHookPoint *HP_libconfig_setting_remove_post; + struct HPMHookPoint *HP_libconfig_setting_remove_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_remove_elem_post; + struct HPMHookPoint *HP_libconfig_setting_set_hook_pre; + struct HPMHookPoint *HP_libconfig_setting_set_hook_post; + struct HPMHookPoint *HP_libconfig_lookup_pre; + struct HPMHookPoint *HP_libconfig_lookup_post; + struct HPMHookPoint *HP_libconfig_lookup_from_pre; + struct HPMHookPoint *HP_libconfig_lookup_from_post; + struct HPMHookPoint *HP_libconfig_lookup_int_pre; + struct HPMHookPoint *HP_libconfig_lookup_int_post; + struct HPMHookPoint *HP_libconfig_lookup_int64_pre; + struct HPMHookPoint *HP_libconfig_lookup_int64_post; + struct HPMHookPoint *HP_libconfig_lookup_float_pre; + struct HPMHookPoint *HP_libconfig_lookup_float_post; + struct HPMHookPoint *HP_libconfig_lookup_bool_pre; + struct HPMHookPoint *HP_libconfig_lookup_bool_post; + struct HPMHookPoint *HP_libconfig_lookup_string_pre; + struct HPMHookPoint *HP_libconfig_lookup_string_post; + struct HPMHookPoint *HP_libconfig_read_file_pre; + struct HPMHookPoint *HP_libconfig_read_file_post; + struct HPMHookPoint *HP_libconfig_setting_copy_simple_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_simple_post; + struct HPMHookPoint *HP_libconfig_setting_copy_elem_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_elem_post; + struct HPMHookPoint *HP_libconfig_setting_copy_aggregate_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_aggregate_post; + struct HPMHookPoint *HP_libconfig_setting_copy_pre; + struct HPMHookPoint *HP_libconfig_setting_copy_post; struct HPMHookPoint *HP_logs_pick_pc_pre; struct HPMHookPoint *HP_logs_pick_pc_post; struct HPMHookPoint *HP_logs_pick_mob_pre; @@ -2697,6 +2877,32 @@ struct { struct HPMHookPoint *HP_mail_deliveryfail_post; struct HPMHookPoint *HP_mail_invalid_operation_pre; struct HPMHookPoint *HP_mail_invalid_operation_post; + struct HPMHookPoint *HP_iMalloc_init_pre; + struct HPMHookPoint *HP_iMalloc_init_post; + struct HPMHookPoint *HP_iMalloc_final_pre; + struct HPMHookPoint *HP_iMalloc_final_post; + struct HPMHookPoint *HP_iMalloc_malloc_pre; + struct HPMHookPoint *HP_iMalloc_malloc_post; + struct HPMHookPoint *HP_iMalloc_calloc_pre; + struct HPMHookPoint *HP_iMalloc_calloc_post; + struct HPMHookPoint *HP_iMalloc_realloc_pre; + struct HPMHookPoint *HP_iMalloc_realloc_post; + struct HPMHookPoint *HP_iMalloc_reallocz_pre; + struct HPMHookPoint *HP_iMalloc_reallocz_post; + struct HPMHookPoint *HP_iMalloc_astrdup_pre; + struct HPMHookPoint *HP_iMalloc_astrdup_post; + struct HPMHookPoint *HP_iMalloc_free_pre; + struct HPMHookPoint *HP_iMalloc_free_post; + struct HPMHookPoint *HP_iMalloc_memory_check_pre; + struct HPMHookPoint *HP_iMalloc_memory_check_post; + struct HPMHookPoint *HP_iMalloc_verify_ptr_pre; + struct HPMHookPoint *HP_iMalloc_verify_ptr_post; + struct HPMHookPoint *HP_iMalloc_usage_pre; + struct HPMHookPoint *HP_iMalloc_usage_post; + struct HPMHookPoint *HP_iMalloc_post_shutdown_pre; + struct HPMHookPoint *HP_iMalloc_post_shutdown_post; + struct HPMHookPoint *HP_iMalloc_init_messages_pre; + struct HPMHookPoint *HP_iMalloc_init_messages_post; struct HPMHookPoint *HP_map_zone_init_pre; struct HPMHookPoint *HP_map_zone_init_post; struct HPMHookPoint *HP_map_zone_remove_pre; @@ -2953,6 +3159,24 @@ struct { struct HPMHookPoint *HP_map_merge_zone_post; struct HPMHookPoint *HP_map_zone_clear_single_pre; struct HPMHookPoint *HP_map_zone_clear_single_post; + struct HPMHookPoint *HP_mapindex_init_pre; + struct HPMHookPoint *HP_mapindex_init_post; + struct HPMHookPoint *HP_mapindex_final_pre; + struct HPMHookPoint *HP_mapindex_final_post; + struct HPMHookPoint *HP_mapindex_addmap_pre; + struct HPMHookPoint *HP_mapindex_addmap_post; + struct HPMHookPoint *HP_mapindex_removemap_pre; + struct HPMHookPoint *HP_mapindex_removemap_post; + struct HPMHookPoint *HP_mapindex_getmapname_pre; + struct HPMHookPoint *HP_mapindex_getmapname_post; + struct HPMHookPoint *HP_mapindex_getmapname_ext_pre; + struct HPMHookPoint *HP_mapindex_getmapname_ext_post; + struct HPMHookPoint *HP_mapindex_name2id_pre; + struct HPMHookPoint *HP_mapindex_name2id_post; + struct HPMHookPoint *HP_mapindex_id2name_pre; + struct HPMHookPoint *HP_mapindex_id2name_post; + struct HPMHookPoint *HP_mapindex_check_default_pre; + struct HPMHookPoint *HP_mapindex_check_default_post; struct HPMHookPoint *HP_mapit_alloc_pre; struct HPMHookPoint *HP_mapit_alloc_post; struct HPMHookPoint *HP_mapit_free_pre; @@ -3441,6 +3665,8 @@ struct { struct HPMHookPoint *HP_npc_db_checkid_post; struct HPMHookPoint *HP_npc_secure_timeout_timer_pre; struct HPMHookPoint *HP_npc_secure_timeout_timer_post; + struct HPMHookPoint *HP_nullpo_assert_report_pre; + struct HPMHookPoint *HP_nullpo_assert_report_post; struct HPMHookPoint *HP_party_init_pre; struct HPMHookPoint *HP_party_init_post; struct HPMHookPoint *HP_party_final_pre; @@ -4159,6 +4385,10 @@ struct { struct HPMHookPoint *HP_script_label_add_post; struct HPMHookPoint *HP_script_run_pre; struct HPMHookPoint *HP_script_run_post; + struct HPMHookPoint *HP_script_run_npc_pre; + struct HPMHookPoint *HP_script_run_npc_post; + struct HPMHookPoint *HP_script_run_pet_pre; + struct HPMHookPoint *HP_script_run_pet_post; struct HPMHookPoint *HP_script_run_main_pre; struct HPMHookPoint *HP_script_run_main_post; struct HPMHookPoint *HP_script_run_timer_pre; @@ -4391,6 +4621,12 @@ struct { struct HPMHookPoint *HP_script_get_translation_file_name_post; struct HPMHookPoint *HP_script_parser_clean_leftovers_pre; struct HPMHookPoint *HP_script_parser_clean_leftovers_post; + struct HPMHookPoint *HP_script_run_use_script_pre; + struct HPMHookPoint *HP_script_run_use_script_post; + struct HPMHookPoint *HP_script_run_item_equip_script_pre; + struct HPMHookPoint *HP_script_run_item_equip_script_post; + struct HPMHookPoint *HP_script_run_item_unequip_script_pre; + struct HPMHookPoint *HP_script_run_item_unequip_script_post; struct HPMHookPoint *HP_searchstore_open_pre; struct HPMHookPoint *HP_searchstore_open_post; struct HPMHookPoint *HP_searchstore_query_pre; @@ -4411,6 +4647,14 @@ struct { struct HPMHookPoint *HP_searchstore_clearremote_post; struct HPMHookPoint *HP_searchstore_result_pre; struct HPMHookPoint *HP_searchstore_result_post; + struct HPMHookPoint *HP_showmsg_init_pre; + struct HPMHookPoint *HP_showmsg_init_post; + struct HPMHookPoint *HP_showmsg_final_pre; + struct HPMHookPoint *HP_showmsg_final_post; + struct HPMHookPoint *HP_showmsg_clearScreen_pre; + struct HPMHookPoint *HP_showmsg_clearScreen_post; + struct HPMHookPoint *HP_showmsg_showMessageV_pre; + struct HPMHookPoint *HP_showmsg_showMessageV_post; struct HPMHookPoint *HP_skill_init_pre; struct HPMHookPoint *HP_skill_init_post; struct HPMHookPoint *HP_skill_final_pre; @@ -4845,6 +5089,126 @@ struct { struct HPMHookPoint *HP_skill_get_requirement_item_unknown_post; struct HPMHookPoint *HP_skill_get_requirement_unknown_pre; struct HPMHookPoint *HP_skill_get_requirement_unknown_post; + struct HPMHookPoint *HP_sockt_init_pre; + struct HPMHookPoint *HP_sockt_init_post; + struct HPMHookPoint *HP_sockt_final_pre; + struct HPMHookPoint *HP_sockt_final_post; + struct HPMHookPoint *HP_sockt_perform_pre; + struct HPMHookPoint *HP_sockt_perform_post; + struct HPMHookPoint *HP_sockt_datasync_pre; + struct HPMHookPoint *HP_sockt_datasync_post; + struct HPMHookPoint *HP_sockt_make_listen_bind_pre; + struct HPMHookPoint *HP_sockt_make_listen_bind_post; + struct HPMHookPoint *HP_sockt_make_connection_pre; + struct HPMHookPoint *HP_sockt_make_connection_post; + struct HPMHookPoint *HP_sockt_realloc_fifo_pre; + struct HPMHookPoint *HP_sockt_realloc_fifo_post; + struct HPMHookPoint *HP_sockt_realloc_writefifo_pre; + struct HPMHookPoint *HP_sockt_realloc_writefifo_post; + struct HPMHookPoint *HP_sockt_wfifoset_pre; + struct HPMHookPoint *HP_sockt_wfifoset_post; + struct HPMHookPoint *HP_sockt_rfifoskip_pre; + struct HPMHookPoint *HP_sockt_rfifoskip_post; + struct HPMHookPoint *HP_sockt_close_pre; + struct HPMHookPoint *HP_sockt_close_post; + struct HPMHookPoint *HP_sockt_session_is_valid_pre; + struct HPMHookPoint *HP_sockt_session_is_valid_post; + struct HPMHookPoint *HP_sockt_session_is_active_pre; + struct HPMHookPoint *HP_sockt_session_is_active_post; + struct HPMHookPoint *HP_sockt_flush_pre; + struct HPMHookPoint *HP_sockt_flush_post; + struct HPMHookPoint *HP_sockt_flush_fifos_pre; + struct HPMHookPoint *HP_sockt_flush_fifos_post; + struct HPMHookPoint *HP_sockt_set_nonblocking_pre; + struct HPMHookPoint *HP_sockt_set_nonblocking_post; + struct HPMHookPoint *HP_sockt_set_defaultparse_pre; + struct HPMHookPoint *HP_sockt_set_defaultparse_post; + struct HPMHookPoint *HP_sockt_host2ip_pre; + struct HPMHookPoint *HP_sockt_host2ip_post; + struct HPMHookPoint *HP_sockt_ip2str_pre; + struct HPMHookPoint *HP_sockt_ip2str_post; + struct HPMHookPoint *HP_sockt_str2ip_pre; + struct HPMHookPoint *HP_sockt_str2ip_post; + struct HPMHookPoint *HP_sockt_ntows_pre; + struct HPMHookPoint *HP_sockt_ntows_post; + struct HPMHookPoint *HP_sockt_getips_pre; + struct HPMHookPoint *HP_sockt_getips_post; + struct HPMHookPoint *HP_sockt_eof_pre; + struct HPMHookPoint *HP_sockt_eof_post; + struct HPMHookPoint *HP_sockt_lan_subnet_check_pre; + struct HPMHookPoint *HP_sockt_lan_subnet_check_post; + struct HPMHookPoint *HP_sockt_allowed_ip_check_pre; + struct HPMHookPoint *HP_sockt_allowed_ip_check_post; + struct HPMHookPoint *HP_sockt_trusted_ip_check_pre; + struct HPMHookPoint *HP_sockt_trusted_ip_check_post; + struct HPMHookPoint *HP_sockt_net_config_read_sub_pre; + struct HPMHookPoint *HP_sockt_net_config_read_sub_post; + struct HPMHookPoint *HP_sockt_net_config_read_pre; + struct HPMHookPoint *HP_sockt_net_config_read_post; + struct HPMHookPoint *HP_SQL_Connect_pre; + struct HPMHookPoint *HP_SQL_Connect_post; + struct HPMHookPoint *HP_SQL_GetTimeout_pre; + struct HPMHookPoint *HP_SQL_GetTimeout_post; + struct HPMHookPoint *HP_SQL_GetColumnNames_pre; + struct HPMHookPoint *HP_SQL_GetColumnNames_post; + struct HPMHookPoint *HP_SQL_SetEncoding_pre; + struct HPMHookPoint *HP_SQL_SetEncoding_post; + struct HPMHookPoint *HP_SQL_Ping_pre; + struct HPMHookPoint *HP_SQL_Ping_post; + struct HPMHookPoint *HP_SQL_EscapeString_pre; + struct HPMHookPoint *HP_SQL_EscapeString_post; + struct HPMHookPoint *HP_SQL_EscapeStringLen_pre; + struct HPMHookPoint *HP_SQL_EscapeStringLen_post; + struct HPMHookPoint *HP_SQL_QueryV_pre; + struct HPMHookPoint *HP_SQL_QueryV_post; + struct HPMHookPoint *HP_SQL_QueryStr_pre; + struct HPMHookPoint *HP_SQL_QueryStr_post; + struct HPMHookPoint *HP_SQL_LastInsertId_pre; + struct HPMHookPoint *HP_SQL_LastInsertId_post; + struct HPMHookPoint *HP_SQL_NumColumns_pre; + struct HPMHookPoint *HP_SQL_NumColumns_post; + struct HPMHookPoint *HP_SQL_NumRows_pre; + struct HPMHookPoint *HP_SQL_NumRows_post; + struct HPMHookPoint *HP_SQL_NextRow_pre; + struct HPMHookPoint *HP_SQL_NextRow_post; + struct HPMHookPoint *HP_SQL_GetData_pre; + struct HPMHookPoint *HP_SQL_GetData_post; + struct HPMHookPoint *HP_SQL_FreeResult_pre; + struct HPMHookPoint *HP_SQL_FreeResult_post; + struct HPMHookPoint *HP_SQL_ShowDebug__pre; + struct HPMHookPoint *HP_SQL_ShowDebug__post; + struct HPMHookPoint *HP_SQL_Free_pre; + struct HPMHookPoint *HP_SQL_Free_post; + struct HPMHookPoint *HP_SQL_Malloc_pre; + struct HPMHookPoint *HP_SQL_Malloc_post; + struct HPMHookPoint *HP_SQL_StmtMalloc_pre; + struct HPMHookPoint *HP_SQL_StmtMalloc_post; + struct HPMHookPoint *HP_SQL_StmtPrepareV_pre; + struct HPMHookPoint *HP_SQL_StmtPrepareV_post; + struct HPMHookPoint *HP_SQL_StmtPrepareStr_pre; + struct HPMHookPoint *HP_SQL_StmtPrepareStr_post; + struct HPMHookPoint *HP_SQL_StmtNumParams_pre; + struct HPMHookPoint *HP_SQL_StmtNumParams_post; + struct HPMHookPoint *HP_SQL_StmtBindParam_pre; + struct HPMHookPoint *HP_SQL_StmtBindParam_post; + struct HPMHookPoint *HP_SQL_StmtExecute_pre; + struct HPMHookPoint *HP_SQL_StmtExecute_post; + struct HPMHookPoint *HP_SQL_StmtLastInsertId_pre; + struct HPMHookPoint *HP_SQL_StmtLastInsertId_post; + struct HPMHookPoint *HP_SQL_StmtNumColumns_pre; + struct HPMHookPoint *HP_SQL_StmtNumColumns_post; + struct HPMHookPoint *HP_SQL_StmtBindColumn_pre; + struct HPMHookPoint *HP_SQL_StmtBindColumn_post; + struct HPMHookPoint *HP_SQL_StmtNumRows_pre; + struct HPMHookPoint *HP_SQL_StmtNumRows_post; + struct HPMHookPoint *HP_SQL_StmtNextRow_pre; + struct HPMHookPoint *HP_SQL_StmtNextRow_post; + struct HPMHookPoint *HP_SQL_StmtFreeResult_pre; + struct HPMHookPoint *HP_SQL_StmtFreeResult_post; + struct HPMHookPoint *HP_SQL_StmtFree_pre; + struct HPMHookPoint *HP_SQL_StmtFree_post; + struct HPMHookPoint *HP_SQL_StmtShowDebug__pre; + struct HPMHookPoint *HP_SQL_StmtShowDebug__post; struct HPMHookPoint *HP_status_init_pre; struct HPMHookPoint *HP_status_init_post; struct HPMHookPoint *HP_status_final_pre; @@ -4941,6 +5305,8 @@ struct { struct HPMHookPoint *HP_status_calc_pet__post; struct HPMHookPoint *HP_status_calc_pc__pre; struct HPMHookPoint *HP_status_calc_pc__post; + struct HPMHookPoint *HP_status_calc_pc_additional_pre; + struct HPMHookPoint *HP_status_calc_pc_additional_post; struct HPMHookPoint *HP_status_calc_homunculus__pre; struct HPMHookPoint *HP_status_calc_homunculus__post; struct HPMHookPoint *HP_status_calc_mercenary__pre; @@ -5091,6 +5457,130 @@ struct { struct HPMHookPoint *HP_storage_sortitem_post; struct HPMHookPoint *HP_storage_reconnect_sub_pre; struct HPMHookPoint *HP_storage_reconnect_sub_post; + struct HPMHookPoint *HP_StrBuf_Malloc_pre; + struct HPMHookPoint *HP_StrBuf_Malloc_post; + struct HPMHookPoint *HP_StrBuf_Init_pre; + struct HPMHookPoint *HP_StrBuf_Init_post; + struct HPMHookPoint *HP_StrBuf_Vprintf_pre; + struct HPMHookPoint *HP_StrBuf_Vprintf_post; + struct HPMHookPoint *HP_StrBuf_Append_pre; + struct HPMHookPoint *HP_StrBuf_Append_post; + struct HPMHookPoint *HP_StrBuf_AppendStr_pre; + struct HPMHookPoint *HP_StrBuf_AppendStr_post; + struct HPMHookPoint *HP_StrBuf_Length_pre; + struct HPMHookPoint *HP_StrBuf_Length_post; + struct HPMHookPoint *HP_StrBuf_Value_pre; + struct HPMHookPoint *HP_StrBuf_Value_post; + struct HPMHookPoint *HP_StrBuf_Clear_pre; + struct HPMHookPoint *HP_StrBuf_Clear_post; + struct HPMHookPoint *HP_StrBuf_Destroy_pre; + struct HPMHookPoint *HP_StrBuf_Destroy_post; + struct HPMHookPoint *HP_StrBuf_Free_pre; + struct HPMHookPoint *HP_StrBuf_Free_post; + struct HPMHookPoint *HP_strlib_jstrescape_pre; + struct HPMHookPoint *HP_strlib_jstrescape_post; + struct HPMHookPoint *HP_strlib_jstrescapecpy_pre; + struct HPMHookPoint *HP_strlib_jstrescapecpy_post; + struct HPMHookPoint *HP_strlib_jmemescapecpy_pre; + struct HPMHookPoint *HP_strlib_jmemescapecpy_post; + struct HPMHookPoint *HP_strlib_remove_control_chars__pre; + struct HPMHookPoint *HP_strlib_remove_control_chars__post; + struct HPMHookPoint *HP_strlib_trim__pre; + struct HPMHookPoint *HP_strlib_trim__post; + struct HPMHookPoint *HP_strlib_normalize_name__pre; + struct HPMHookPoint *HP_strlib_normalize_name__post; + struct HPMHookPoint *HP_strlib_stristr__pre; + struct HPMHookPoint *HP_strlib_stristr__post; + struct HPMHookPoint *HP_strlib_strnlen__pre; + struct HPMHookPoint *HP_strlib_strnlen__post; + struct HPMHookPoint *HP_strlib_strtok_r__pre; + struct HPMHookPoint *HP_strlib_strtok_r__post; + struct HPMHookPoint *HP_strlib_e_mail_check__pre; + struct HPMHookPoint *HP_strlib_e_mail_check__post; + struct HPMHookPoint *HP_strlib_config_switch__pre; + struct HPMHookPoint *HP_strlib_config_switch__post; + struct HPMHookPoint *HP_strlib_safestrncpy__pre; + struct HPMHookPoint *HP_strlib_safestrncpy__post; + struct HPMHookPoint *HP_strlib_safestrnlen__pre; + struct HPMHookPoint *HP_strlib_safestrnlen__post; + struct HPMHookPoint *HP_strlib_strline__pre; + struct HPMHookPoint *HP_strlib_strline__post; + struct HPMHookPoint *HP_strlib_bin2hex__pre; + struct HPMHookPoint *HP_strlib_bin2hex__post; + struct HPMHookPoint *HP_sv_parse_next_pre; + struct HPMHookPoint *HP_sv_parse_next_post; + struct HPMHookPoint *HP_sv_parse_pre; + struct HPMHookPoint *HP_sv_parse_post; + struct HPMHookPoint *HP_sv_split_pre; + struct HPMHookPoint *HP_sv_split_post; + struct HPMHookPoint *HP_sv_escape_c_pre; + struct HPMHookPoint *HP_sv_escape_c_post; + struct HPMHookPoint *HP_sv_unescape_c_pre; + struct HPMHookPoint *HP_sv_unescape_c_post; + struct HPMHookPoint *HP_sv_skip_escaped_c_pre; + struct HPMHookPoint *HP_sv_skip_escaped_c_post; + struct HPMHookPoint *HP_sv_readdb_pre; + struct HPMHookPoint *HP_sv_readdb_post; + struct HPMHookPoint *HP_sysinfo_getpagesize_pre; + struct HPMHookPoint *HP_sysinfo_getpagesize_post; + struct HPMHookPoint *HP_sysinfo_platform_pre; + struct HPMHookPoint *HP_sysinfo_platform_post; + struct HPMHookPoint *HP_sysinfo_osversion_pre; + struct HPMHookPoint *HP_sysinfo_osversion_post; + struct HPMHookPoint *HP_sysinfo_cpu_pre; + struct HPMHookPoint *HP_sysinfo_cpu_post; + struct HPMHookPoint *HP_sysinfo_cpucores_pre; + struct HPMHookPoint *HP_sysinfo_cpucores_post; + struct HPMHookPoint *HP_sysinfo_arch_pre; + struct HPMHookPoint *HP_sysinfo_arch_post; + struct HPMHookPoint *HP_sysinfo_is64bit_pre; + struct HPMHookPoint *HP_sysinfo_is64bit_post; + struct HPMHookPoint *HP_sysinfo_compiler_pre; + struct HPMHookPoint *HP_sysinfo_compiler_post; + struct HPMHookPoint *HP_sysinfo_cflags_pre; + struct HPMHookPoint *HP_sysinfo_cflags_post; + struct HPMHookPoint *HP_sysinfo_vcstype_pre; + struct HPMHookPoint *HP_sysinfo_vcstype_post; + struct HPMHookPoint *HP_sysinfo_vcstypeid_pre; + struct HPMHookPoint *HP_sysinfo_vcstypeid_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_src_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_src_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_scripts_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_scripts_post; + struct HPMHookPoint *HP_sysinfo_vcsrevision_reload_pre; + struct HPMHookPoint *HP_sysinfo_vcsrevision_reload_post; + struct HPMHookPoint *HP_sysinfo_is_superuser_pre; + struct HPMHookPoint *HP_sysinfo_is_superuser_post; + struct HPMHookPoint *HP_sysinfo_init_pre; + struct HPMHookPoint *HP_sysinfo_init_post; + struct HPMHookPoint *HP_sysinfo_final_pre; + struct HPMHookPoint *HP_sysinfo_final_post; + struct HPMHookPoint *HP_timer_gettick_pre; + struct HPMHookPoint *HP_timer_gettick_post; + struct HPMHookPoint *HP_timer_gettick_nocache_pre; + struct HPMHookPoint *HP_timer_gettick_nocache_post; + struct HPMHookPoint *HP_timer_add_pre; + struct HPMHookPoint *HP_timer_add_post; + struct HPMHookPoint *HP_timer_add_interval_pre; + struct HPMHookPoint *HP_timer_add_interval_post; + struct HPMHookPoint *HP_timer_get_pre; + struct HPMHookPoint *HP_timer_get_post; + struct HPMHookPoint *HP_timer_delete_pre; + struct HPMHookPoint *HP_timer_delete_post; + struct HPMHookPoint *HP_timer_addtick_pre; + struct HPMHookPoint *HP_timer_addtick_post; + struct HPMHookPoint *HP_timer_settick_pre; + struct HPMHookPoint *HP_timer_settick_post; + struct HPMHookPoint *HP_timer_add_func_list_pre; + struct HPMHookPoint *HP_timer_add_func_list_post; + struct HPMHookPoint *HP_timer_get_uptime_pre; + struct HPMHookPoint *HP_timer_get_uptime_post; + struct HPMHookPoint *HP_timer_perform_pre; + struct HPMHookPoint *HP_timer_perform_post; + struct HPMHookPoint *HP_timer_init_pre; + struct HPMHookPoint *HP_timer_init_post; + struct HPMHookPoint *HP_timer_final_pre; + struct HPMHookPoint *HP_timer_final_post; struct HPMHookPoint *HP_trade_request_pre; struct HPMHookPoint *HP_trade_request_post; struct HPMHookPoint *HP_trade_ack_pre; @@ -5224,6 +5714,12 @@ struct { } list; struct { + int HP_HCache_init_pre; + int HP_HCache_init_post; + int HP_HCache_check_pre; + int HP_HCache_check_post; + int HP_HCache_open_pre; + int HP_HCache_open_post; int HP_atcommand_init_pre; int HP_atcommand_init_post; int HP_atcommand_final_pre; @@ -7026,6 +7522,64 @@ struct { int HP_clif_pNPCMarketClosed_post; int HP_clif_pNPCMarketPurchase_pre; int HP_clif_pNPCMarketPurchase_post; + int HP_cmdline_init_pre; + int HP_cmdline_init_post; + int HP_cmdline_final_pre; + int HP_cmdline_final_post; + int HP_cmdline_arg_add_pre; + int HP_cmdline_arg_add_post; + int HP_cmdline_exec_pre; + int HP_cmdline_exec_post; + int HP_cmdline_arg_next_value_pre; + int HP_cmdline_arg_next_value_post; + int HP_cmdline_arg_source_pre; + int HP_cmdline_arg_source_post; + int HP_console_init_pre; + int HP_console_init_post; + int HP_console_final_pre; + int HP_console_final_post; + int HP_console_display_title_pre; + int HP_console_display_title_post; + int HP_core_shutdown_callback_pre; + int HP_core_shutdown_callback_post; + int HP_DB_fix_options_pre; + int HP_DB_fix_options_post; + int HP_DB_default_cmp_pre; + int HP_DB_default_cmp_post; + int HP_DB_default_hash_pre; + int HP_DB_default_hash_post; + int HP_DB_default_release_pre; + int HP_DB_default_release_post; + int HP_DB_custom_release_pre; + int HP_DB_custom_release_post; + int HP_DB_alloc_pre; + int HP_DB_alloc_post; + int HP_DB_i2key_pre; + int HP_DB_i2key_post; + int HP_DB_ui2key_pre; + int HP_DB_ui2key_post; + int HP_DB_str2key_pre; + int HP_DB_str2key_post; + int HP_DB_i642key_pre; + int HP_DB_i642key_post; + int HP_DB_ui642key_pre; + int HP_DB_ui642key_post; + int HP_DB_i2data_pre; + int HP_DB_i2data_post; + int HP_DB_ui2data_pre; + int HP_DB_ui2data_post; + int HP_DB_ptr2data_pre; + int HP_DB_ptr2data_post; + int HP_DB_data2i_pre; + int HP_DB_data2i_post; + int HP_DB_data2ui_pre; + int HP_DB_data2ui_post; + int HP_DB_data2ptr_pre; + int HP_DB_data2ptr_post; + int HP_DB_init_pre; + int HP_DB_init_post; + int HP_DB_final_pre; + int HP_DB_final_post; int HP_duel_create_pre; int HP_duel_create_post; int HP_duel_invite_pre; @@ -7854,6 +8408,122 @@ struct { int HP_itemdb_is_item_usable_post; int HP_itemdb_lookup_const_pre; int HP_itemdb_lookup_const_post; + int HP_libconfig_read_pre; + int HP_libconfig_read_post; + int HP_libconfig_write_pre; + int HP_libconfig_write_post; + int HP_libconfig_set_auto_convert_pre; + int HP_libconfig_set_auto_convert_post; + int HP_libconfig_get_auto_convert_pre; + int HP_libconfig_get_auto_convert_post; + int HP_libconfig_read_string_pre; + int HP_libconfig_read_string_post; + int HP_libconfig_read_file_src_pre; + int HP_libconfig_read_file_src_post; + int HP_libconfig_write_file_pre; + int HP_libconfig_write_file_post; + int HP_libconfig_set_destructor_pre; + int HP_libconfig_set_destructor_post; + int HP_libconfig_set_include_dir_pre; + int HP_libconfig_set_include_dir_post; + int HP_libconfig_init_pre; + int HP_libconfig_init_post; + int HP_libconfig_destroy_pre; + int HP_libconfig_destroy_post; + int HP_libconfig_setting_get_int_pre; + int HP_libconfig_setting_get_int_post; + int HP_libconfig_setting_get_int64_pre; + int HP_libconfig_setting_get_int64_post; + int HP_libconfig_setting_get_float_pre; + int HP_libconfig_setting_get_float_post; + int HP_libconfig_setting_get_bool_pre; + int HP_libconfig_setting_get_bool_post; + int HP_libconfig_setting_get_string_pre; + int HP_libconfig_setting_get_string_post; + int HP_libconfig_setting_lookup_int_pre; + int HP_libconfig_setting_lookup_int_post; + int HP_libconfig_setting_lookup_int64_pre; + int HP_libconfig_setting_lookup_int64_post; + int HP_libconfig_setting_lookup_float_pre; + int HP_libconfig_setting_lookup_float_post; + int HP_libconfig_setting_lookup_bool_pre; + int HP_libconfig_setting_lookup_bool_post; + int HP_libconfig_setting_lookup_string_pre; + int HP_libconfig_setting_lookup_string_post; + int HP_libconfig_setting_set_int_pre; + int HP_libconfig_setting_set_int_post; + int HP_libconfig_setting_set_int64_pre; + int HP_libconfig_setting_set_int64_post; + int HP_libconfig_setting_set_float_pre; + int HP_libconfig_setting_set_float_post; + int HP_libconfig_setting_set_bool_pre; + int HP_libconfig_setting_set_bool_post; + int HP_libconfig_setting_set_string_pre; + int HP_libconfig_setting_set_string_post; + int HP_libconfig_setting_set_format_pre; + int HP_libconfig_setting_set_format_post; + int HP_libconfig_setting_get_format_pre; + int HP_libconfig_setting_get_format_post; + int HP_libconfig_setting_get_int_elem_pre; + int HP_libconfig_setting_get_int_elem_post; + int HP_libconfig_setting_get_int64_elem_pre; + int HP_libconfig_setting_get_int64_elem_post; + int HP_libconfig_setting_get_float_elem_pre; + int HP_libconfig_setting_get_float_elem_post; + int HP_libconfig_setting_get_bool_elem_pre; + int HP_libconfig_setting_get_bool_elem_post; + int HP_libconfig_setting_get_string_elem_pre; + int HP_libconfig_setting_get_string_elem_post; + int HP_libconfig_setting_set_int_elem_pre; + int HP_libconfig_setting_set_int_elem_post; + int HP_libconfig_setting_set_int64_elem_pre; + int HP_libconfig_setting_set_int64_elem_post; + int HP_libconfig_setting_set_float_elem_pre; + int HP_libconfig_setting_set_float_elem_post; + int HP_libconfig_setting_set_bool_elem_pre; + int HP_libconfig_setting_set_bool_elem_post; + int HP_libconfig_setting_set_string_elem_pre; + int HP_libconfig_setting_set_string_elem_post; + int HP_libconfig_setting_index_pre; + int HP_libconfig_setting_index_post; + int HP_libconfig_setting_length_pre; + int HP_libconfig_setting_length_post; + int HP_libconfig_setting_get_elem_pre; + int HP_libconfig_setting_get_elem_post; + int HP_libconfig_setting_get_member_pre; + int HP_libconfig_setting_get_member_post; + int HP_libconfig_setting_add_pre; + int HP_libconfig_setting_add_post; + int HP_libconfig_setting_remove_pre; + int HP_libconfig_setting_remove_post; + int HP_libconfig_setting_remove_elem_pre; + int HP_libconfig_setting_remove_elem_post; + int HP_libconfig_setting_set_hook_pre; + int HP_libconfig_setting_set_hook_post; + int HP_libconfig_lookup_pre; + int HP_libconfig_lookup_post; + int HP_libconfig_lookup_from_pre; + int HP_libconfig_lookup_from_post; + int HP_libconfig_lookup_int_pre; + int HP_libconfig_lookup_int_post; + int HP_libconfig_lookup_int64_pre; + int HP_libconfig_lookup_int64_post; + int HP_libconfig_lookup_float_pre; + int HP_libconfig_lookup_float_post; + int HP_libconfig_lookup_bool_pre; + int HP_libconfig_lookup_bool_post; + int HP_libconfig_lookup_string_pre; + int HP_libconfig_lookup_string_post; + int HP_libconfig_read_file_pre; + int HP_libconfig_read_file_post; + int HP_libconfig_setting_copy_simple_pre; + int HP_libconfig_setting_copy_simple_post; + int HP_libconfig_setting_copy_elem_pre; + int HP_libconfig_setting_copy_elem_post; + int HP_libconfig_setting_copy_aggregate_pre; + int HP_libconfig_setting_copy_aggregate_post; + int HP_libconfig_setting_copy_pre; + int HP_libconfig_setting_copy_post; int HP_logs_pick_pc_pre; int HP_logs_pick_pc_post; int HP_logs_pick_mob_pre; @@ -7916,6 +8586,32 @@ struct { int HP_mail_deliveryfail_post; int HP_mail_invalid_operation_pre; int HP_mail_invalid_operation_post; + int HP_iMalloc_init_pre; + int HP_iMalloc_init_post; + int HP_iMalloc_final_pre; + int HP_iMalloc_final_post; + int HP_iMalloc_malloc_pre; + int HP_iMalloc_malloc_post; + int HP_iMalloc_calloc_pre; + int HP_iMalloc_calloc_post; + int HP_iMalloc_realloc_pre; + int HP_iMalloc_realloc_post; + int HP_iMalloc_reallocz_pre; + int HP_iMalloc_reallocz_post; + int HP_iMalloc_astrdup_pre; + int HP_iMalloc_astrdup_post; + int HP_iMalloc_free_pre; + int HP_iMalloc_free_post; + int HP_iMalloc_memory_check_pre; + int HP_iMalloc_memory_check_post; + int HP_iMalloc_verify_ptr_pre; + int HP_iMalloc_verify_ptr_post; + int HP_iMalloc_usage_pre; + int HP_iMalloc_usage_post; + int HP_iMalloc_post_shutdown_pre; + int HP_iMalloc_post_shutdown_post; + int HP_iMalloc_init_messages_pre; + int HP_iMalloc_init_messages_post; int HP_map_zone_init_pre; int HP_map_zone_init_post; int HP_map_zone_remove_pre; @@ -8172,6 +8868,24 @@ struct { int HP_map_merge_zone_post; int HP_map_zone_clear_single_pre; int HP_map_zone_clear_single_post; + int HP_mapindex_init_pre; + int HP_mapindex_init_post; + int HP_mapindex_final_pre; + int HP_mapindex_final_post; + int HP_mapindex_addmap_pre; + int HP_mapindex_addmap_post; + int HP_mapindex_removemap_pre; + int HP_mapindex_removemap_post; + int HP_mapindex_getmapname_pre; + int HP_mapindex_getmapname_post; + int HP_mapindex_getmapname_ext_pre; + int HP_mapindex_getmapname_ext_post; + int HP_mapindex_name2id_pre; + int HP_mapindex_name2id_post; + int HP_mapindex_id2name_pre; + int HP_mapindex_id2name_post; + int HP_mapindex_check_default_pre; + int HP_mapindex_check_default_post; int HP_mapit_alloc_pre; int HP_mapit_alloc_post; int HP_mapit_free_pre; @@ -8660,6 +9374,8 @@ struct { int HP_npc_db_checkid_post; int HP_npc_secure_timeout_timer_pre; int HP_npc_secure_timeout_timer_post; + int HP_nullpo_assert_report_pre; + int HP_nullpo_assert_report_post; int HP_party_init_pre; int HP_party_init_post; int HP_party_final_pre; @@ -9378,6 +10094,10 @@ struct { int HP_script_label_add_post; int HP_script_run_pre; int HP_script_run_post; + int HP_script_run_npc_pre; + int HP_script_run_npc_post; + int HP_script_run_pet_pre; + int HP_script_run_pet_post; int HP_script_run_main_pre; int HP_script_run_main_post; int HP_script_run_timer_pre; @@ -9610,6 +10330,12 @@ struct { int HP_script_get_translation_file_name_post; int HP_script_parser_clean_leftovers_pre; int HP_script_parser_clean_leftovers_post; + int HP_script_run_use_script_pre; + int HP_script_run_use_script_post; + int HP_script_run_item_equip_script_pre; + int HP_script_run_item_equip_script_post; + int HP_script_run_item_unequip_script_pre; + int HP_script_run_item_unequip_script_post; int HP_searchstore_open_pre; int HP_searchstore_open_post; int HP_searchstore_query_pre; @@ -9630,6 +10356,14 @@ struct { int HP_searchstore_clearremote_post; int HP_searchstore_result_pre; int HP_searchstore_result_post; + int HP_showmsg_init_pre; + int HP_showmsg_init_post; + int HP_showmsg_final_pre; + int HP_showmsg_final_post; + int HP_showmsg_clearScreen_pre; + int HP_showmsg_clearScreen_post; + int HP_showmsg_showMessageV_pre; + int HP_showmsg_showMessageV_post; int HP_skill_init_pre; int HP_skill_init_post; int HP_skill_final_pre; @@ -10064,6 +10798,126 @@ struct { int HP_skill_get_requirement_item_unknown_post; int HP_skill_get_requirement_unknown_pre; int HP_skill_get_requirement_unknown_post; + int HP_sockt_init_pre; + int HP_sockt_init_post; + int HP_sockt_final_pre; + int HP_sockt_final_post; + int HP_sockt_perform_pre; + int HP_sockt_perform_post; + int HP_sockt_datasync_pre; + int HP_sockt_datasync_post; + int HP_sockt_make_listen_bind_pre; + int HP_sockt_make_listen_bind_post; + int HP_sockt_make_connection_pre; + int HP_sockt_make_connection_post; + int HP_sockt_realloc_fifo_pre; + int HP_sockt_realloc_fifo_post; + int HP_sockt_realloc_writefifo_pre; + int HP_sockt_realloc_writefifo_post; + int HP_sockt_wfifoset_pre; + int HP_sockt_wfifoset_post; + int HP_sockt_rfifoskip_pre; + int HP_sockt_rfifoskip_post; + int HP_sockt_close_pre; + int HP_sockt_close_post; + int HP_sockt_session_is_valid_pre; + int HP_sockt_session_is_valid_post; + int HP_sockt_session_is_active_pre; + int HP_sockt_session_is_active_post; + int HP_sockt_flush_pre; + int HP_sockt_flush_post; + int HP_sockt_flush_fifos_pre; + int HP_sockt_flush_fifos_post; + int HP_sockt_set_nonblocking_pre; + int HP_sockt_set_nonblocking_post; + int HP_sockt_set_defaultparse_pre; + int HP_sockt_set_defaultparse_post; + int HP_sockt_host2ip_pre; + int HP_sockt_host2ip_post; + int HP_sockt_ip2str_pre; + int HP_sockt_ip2str_post; + int HP_sockt_str2ip_pre; + int HP_sockt_str2ip_post; + int HP_sockt_ntows_pre; + int HP_sockt_ntows_post; + int HP_sockt_getips_pre; + int HP_sockt_getips_post; + int HP_sockt_eof_pre; + int HP_sockt_eof_post; + int HP_sockt_lan_subnet_check_pre; + int HP_sockt_lan_subnet_check_post; + int HP_sockt_allowed_ip_check_pre; + int HP_sockt_allowed_ip_check_post; + int HP_sockt_trusted_ip_check_pre; + int HP_sockt_trusted_ip_check_post; + int HP_sockt_net_config_read_sub_pre; + int HP_sockt_net_config_read_sub_post; + int HP_sockt_net_config_read_pre; + int HP_sockt_net_config_read_post; + int HP_SQL_Connect_pre; + int HP_SQL_Connect_post; + int HP_SQL_GetTimeout_pre; + int HP_SQL_GetTimeout_post; + int HP_SQL_GetColumnNames_pre; + int HP_SQL_GetColumnNames_post; + int HP_SQL_SetEncoding_pre; + int HP_SQL_SetEncoding_post; + int HP_SQL_Ping_pre; + int HP_SQL_Ping_post; + int HP_SQL_EscapeString_pre; + int HP_SQL_EscapeString_post; + int HP_SQL_EscapeStringLen_pre; + int HP_SQL_EscapeStringLen_post; + int HP_SQL_QueryV_pre; + int HP_SQL_QueryV_post; + int HP_SQL_QueryStr_pre; + int HP_SQL_QueryStr_post; + int HP_SQL_LastInsertId_pre; + int HP_SQL_LastInsertId_post; + int HP_SQL_NumColumns_pre; + int HP_SQL_NumColumns_post; + int HP_SQL_NumRows_pre; + int HP_SQL_NumRows_post; + int HP_SQL_NextRow_pre; + int HP_SQL_NextRow_post; + int HP_SQL_GetData_pre; + int HP_SQL_GetData_post; + int HP_SQL_FreeResult_pre; + int HP_SQL_FreeResult_post; + int HP_SQL_ShowDebug__pre; + int HP_SQL_ShowDebug__post; + int HP_SQL_Free_pre; + int HP_SQL_Free_post; + int HP_SQL_Malloc_pre; + int HP_SQL_Malloc_post; + int HP_SQL_StmtMalloc_pre; + int HP_SQL_StmtMalloc_post; + int HP_SQL_StmtPrepareV_pre; + int HP_SQL_StmtPrepareV_post; + int HP_SQL_StmtPrepareStr_pre; + int HP_SQL_StmtPrepareStr_post; + int HP_SQL_StmtNumParams_pre; + int HP_SQL_StmtNumParams_post; + int HP_SQL_StmtBindParam_pre; + int HP_SQL_StmtBindParam_post; + int HP_SQL_StmtExecute_pre; + int HP_SQL_StmtExecute_post; + int HP_SQL_StmtLastInsertId_pre; + int HP_SQL_StmtLastInsertId_post; + int HP_SQL_StmtNumColumns_pre; + int HP_SQL_StmtNumColumns_post; + int HP_SQL_StmtBindColumn_pre; + int HP_SQL_StmtBindColumn_post; + int HP_SQL_StmtNumRows_pre; + int HP_SQL_StmtNumRows_post; + int HP_SQL_StmtNextRow_pre; + int HP_SQL_StmtNextRow_post; + int HP_SQL_StmtFreeResult_pre; + int HP_SQL_StmtFreeResult_post; + int HP_SQL_StmtFree_pre; + int HP_SQL_StmtFree_post; + int HP_SQL_StmtShowDebug__pre; + int HP_SQL_StmtShowDebug__post; int HP_status_init_pre; int HP_status_init_post; int HP_status_final_pre; @@ -10160,6 +11014,8 @@ struct { int HP_status_calc_pet__post; int HP_status_calc_pc__pre; int HP_status_calc_pc__post; + int HP_status_calc_pc_additional_pre; + int HP_status_calc_pc_additional_post; int HP_status_calc_homunculus__pre; int HP_status_calc_homunculus__post; int HP_status_calc_mercenary__pre; @@ -10310,6 +11166,130 @@ struct { int HP_storage_sortitem_post; int HP_storage_reconnect_sub_pre; int HP_storage_reconnect_sub_post; + int HP_StrBuf_Malloc_pre; + int HP_StrBuf_Malloc_post; + int HP_StrBuf_Init_pre; + int HP_StrBuf_Init_post; + int HP_StrBuf_Vprintf_pre; + int HP_StrBuf_Vprintf_post; + int HP_StrBuf_Append_pre; + int HP_StrBuf_Append_post; + int HP_StrBuf_AppendStr_pre; + int HP_StrBuf_AppendStr_post; + int HP_StrBuf_Length_pre; + int HP_StrBuf_Length_post; + int HP_StrBuf_Value_pre; + int HP_StrBuf_Value_post; + int HP_StrBuf_Clear_pre; + int HP_StrBuf_Clear_post; + int HP_StrBuf_Destroy_pre; + int HP_StrBuf_Destroy_post; + int HP_StrBuf_Free_pre; + int HP_StrBuf_Free_post; + int HP_strlib_jstrescape_pre; + int HP_strlib_jstrescape_post; + int HP_strlib_jstrescapecpy_pre; + int HP_strlib_jstrescapecpy_post; + int HP_strlib_jmemescapecpy_pre; + int HP_strlib_jmemescapecpy_post; + int HP_strlib_remove_control_chars__pre; + int HP_strlib_remove_control_chars__post; + int HP_strlib_trim__pre; + int HP_strlib_trim__post; + int HP_strlib_normalize_name__pre; + int HP_strlib_normalize_name__post; + int HP_strlib_stristr__pre; + int HP_strlib_stristr__post; + int HP_strlib_strnlen__pre; + int HP_strlib_strnlen__post; + int HP_strlib_strtok_r__pre; + int HP_strlib_strtok_r__post; + int HP_strlib_e_mail_check__pre; + int HP_strlib_e_mail_check__post; + int HP_strlib_config_switch__pre; + int HP_strlib_config_switch__post; + int HP_strlib_safestrncpy__pre; + int HP_strlib_safestrncpy__post; + int HP_strlib_safestrnlen__pre; + int HP_strlib_safestrnlen__post; + int HP_strlib_strline__pre; + int HP_strlib_strline__post; + int HP_strlib_bin2hex__pre; + int HP_strlib_bin2hex__post; + int HP_sv_parse_next_pre; + int HP_sv_parse_next_post; + int HP_sv_parse_pre; + int HP_sv_parse_post; + int HP_sv_split_pre; + int HP_sv_split_post; + int HP_sv_escape_c_pre; + int HP_sv_escape_c_post; + int HP_sv_unescape_c_pre; + int HP_sv_unescape_c_post; + int HP_sv_skip_escaped_c_pre; + int HP_sv_skip_escaped_c_post; + int HP_sv_readdb_pre; + int HP_sv_readdb_post; + int HP_sysinfo_getpagesize_pre; + int HP_sysinfo_getpagesize_post; + int HP_sysinfo_platform_pre; + int HP_sysinfo_platform_post; + int HP_sysinfo_osversion_pre; + int HP_sysinfo_osversion_post; + int HP_sysinfo_cpu_pre; + int HP_sysinfo_cpu_post; + int HP_sysinfo_cpucores_pre; + int HP_sysinfo_cpucores_post; + int HP_sysinfo_arch_pre; + int HP_sysinfo_arch_post; + int HP_sysinfo_is64bit_pre; + int HP_sysinfo_is64bit_post; + int HP_sysinfo_compiler_pre; + int HP_sysinfo_compiler_post; + int HP_sysinfo_cflags_pre; + int HP_sysinfo_cflags_post; + int HP_sysinfo_vcstype_pre; + int HP_sysinfo_vcstype_post; + int HP_sysinfo_vcstypeid_pre; + int HP_sysinfo_vcstypeid_post; + int HP_sysinfo_vcsrevision_src_pre; + int HP_sysinfo_vcsrevision_src_post; + int HP_sysinfo_vcsrevision_scripts_pre; + int HP_sysinfo_vcsrevision_scripts_post; + int HP_sysinfo_vcsrevision_reload_pre; + int HP_sysinfo_vcsrevision_reload_post; + int HP_sysinfo_is_superuser_pre; + int HP_sysinfo_is_superuser_post; + int HP_sysinfo_init_pre; + int HP_sysinfo_init_post; + int HP_sysinfo_final_pre; + int HP_sysinfo_final_post; + int HP_timer_gettick_pre; + int HP_timer_gettick_post; + int HP_timer_gettick_nocache_pre; + int HP_timer_gettick_nocache_post; + int HP_timer_add_pre; + int HP_timer_add_post; + int HP_timer_add_interval_pre; + int HP_timer_add_interval_post; + int HP_timer_get_pre; + int HP_timer_get_post; + int HP_timer_delete_pre; + int HP_timer_delete_post; + int HP_timer_addtick_pre; + int HP_timer_addtick_post; + int HP_timer_settick_pre; + int HP_timer_settick_post; + int HP_timer_add_func_list_pre; + int HP_timer_add_func_list_post; + int HP_timer_get_uptime_pre; + int HP_timer_get_uptime_post; + int HP_timer_perform_pre; + int HP_timer_perform_post; + int HP_timer_init_pre; + int HP_timer_init_post; + int HP_timer_final_pre; + int HP_timer_final_post; int HP_trade_request_pre; int HP_trade_request_post; int HP_trade_ack_pre; @@ -10443,6 +11423,7 @@ struct { } count; struct { + struct HCache_interface HCache; struct atcommand_interface atcommand; struct battle_interface battle; struct battleground_interface bg; @@ -10451,6 +11432,10 @@ struct { struct chat_interface chat; struct chrif_interface chrif; struct clif_interface clif; + struct cmdline_interface cmdline; + struct console_interface console; + struct core_interface core; + struct db_interface DB; struct duel_interface duel; struct elemental_interface elemental; struct guild_interface guild; @@ -10460,14 +11445,18 @@ struct { struct intif_interface intif; struct irc_bot_interface ircbot; struct itemdb_interface itemdb; + struct libconfig_interface libconfig; struct log_interface logs; struct mail_interface mail; + struct malloc_interface iMalloc; struct map_interface map; + struct mapindex_interface mapindex; struct mapit_interface mapit; struct mapreg_interface mapreg; struct mercenary_interface mercenary; struct mob_interface mob; struct npc_interface npc; + struct nullpo_interface nullpo; struct party_interface party; struct path_interface path; struct pc_groups_interface pcg; @@ -10476,9 +11465,17 @@ struct { struct quest_interface quest; struct script_interface script; struct searchstore_interface searchstore; + struct showmsg_interface showmsg; struct skill_interface skill; + struct socket_interface sockt; + struct sql_interface SQL; struct status_interface status; struct storage_interface storage; + struct stringbuf_interface StrBuf; + struct strlib_interface strlib; + struct sv_interface sv; + struct sysinfo_interface sysinfo; + struct timer_interface timer; struct trade_interface trade; struct unit_interface unit; struct vending_interface vending; diff --git a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc index 4e23425ec..cc96d3171 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc @@ -5,6 +5,10 @@ // as it will get overwritten. struct HookingPointData HookingPoints[] = { +/* HCache */ + { HP_POP(HCache->init, HP_HCache_init) }, + { HP_POP(HCache->check, HP_HCache_check) }, + { HP_POP(HCache->open, HP_HCache_open) }, /* atcommand */ { HP_POP(atcommand->init, HP_atcommand_init) }, { HP_POP(atcommand->final, HP_atcommand_final) }, @@ -914,6 +918,39 @@ struct HookingPointData HookingPoints[] = { { HP_POP(clif->pNPCShopClosed, HP_clif_pNPCShopClosed) }, { HP_POP(clif->pNPCMarketClosed, HP_clif_pNPCMarketClosed) }, { HP_POP(clif->pNPCMarketPurchase, HP_clif_pNPCMarketPurchase) }, +/* cmdline */ + { HP_POP(cmdline->init, HP_cmdline_init) }, + { HP_POP(cmdline->final, HP_cmdline_final) }, + { HP_POP(cmdline->arg_add, HP_cmdline_arg_add) }, + { HP_POP(cmdline->exec, HP_cmdline_exec) }, + { HP_POP(cmdline->arg_next_value, HP_cmdline_arg_next_value) }, + { HP_POP(cmdline->arg_source, HP_cmdline_arg_source) }, +/* console */ + { HP_POP(console->init, HP_console_init) }, + { HP_POP(console->final, HP_console_final) }, + { HP_POP(console->display_title, HP_console_display_title) }, +/* core */ + { HP_POP(core->shutdown_callback, HP_core_shutdown_callback) }, +/* DB */ + { HP_POP(DB->fix_options, HP_DB_fix_options) }, + { HP_POP(DB->default_cmp, HP_DB_default_cmp) }, + { HP_POP(DB->default_hash, HP_DB_default_hash) }, + { HP_POP(DB->default_release, HP_DB_default_release) }, + { HP_POP(DB->custom_release, HP_DB_custom_release) }, + { HP_POP(DB->alloc, HP_DB_alloc) }, + { HP_POP(DB->i2key, HP_DB_i2key) }, + { HP_POP(DB->ui2key, HP_DB_ui2key) }, + { HP_POP(DB->str2key, HP_DB_str2key) }, + { HP_POP(DB->i642key, HP_DB_i642key) }, + { HP_POP(DB->ui642key, HP_DB_ui642key) }, + { HP_POP(DB->i2data, HP_DB_i2data) }, + { HP_POP(DB->ui2data, HP_DB_ui2data) }, + { HP_POP(DB->ptr2data, HP_DB_ptr2data) }, + { HP_POP(DB->data2i, HP_DB_data2i) }, + { HP_POP(DB->data2ui, HP_DB_data2ui) }, + { HP_POP(DB->data2ptr, HP_DB_data2ptr) }, + { HP_POP(DB->init, HP_DB_init) }, + { HP_POP(DB->final, HP_DB_final) }, /* duel */ { HP_POP(duel->create, HP_duel_create) }, { HP_POP(duel->invite, HP_duel_invite) }, @@ -1337,6 +1374,65 @@ struct HookingPointData HookingPoints[] = { { HP_POP(itemdb->id2combo, HP_itemdb_id2combo) }, { HP_POP(itemdb->is_item_usable, HP_itemdb_is_item_usable) }, { HP_POP(itemdb->lookup_const, HP_itemdb_lookup_const) }, +/* libconfig */ + { HP_POP(libconfig->read, HP_libconfig_read) }, + { HP_POP(libconfig->write, HP_libconfig_write) }, + { HP_POP(libconfig->set_auto_convert, HP_libconfig_set_auto_convert) }, + { HP_POP(libconfig->get_auto_convert, HP_libconfig_get_auto_convert) }, + { HP_POP(libconfig->read_string, HP_libconfig_read_string) }, + { HP_POP(libconfig->read_file_src, HP_libconfig_read_file_src) }, + { HP_POP(libconfig->write_file, HP_libconfig_write_file) }, + { HP_POP(libconfig->set_destructor, HP_libconfig_set_destructor) }, + { HP_POP(libconfig->set_include_dir, HP_libconfig_set_include_dir) }, + { HP_POP(libconfig->init, HP_libconfig_init) }, + { HP_POP(libconfig->destroy, HP_libconfig_destroy) }, + { HP_POP(libconfig->setting_get_int, HP_libconfig_setting_get_int) }, + { HP_POP(libconfig->setting_get_int64, HP_libconfig_setting_get_int64) }, + { HP_POP(libconfig->setting_get_float, HP_libconfig_setting_get_float) }, + { HP_POP(libconfig->setting_get_bool, HP_libconfig_setting_get_bool) }, + { HP_POP(libconfig->setting_get_string, HP_libconfig_setting_get_string) }, + { HP_POP(libconfig->setting_lookup_int, HP_libconfig_setting_lookup_int) }, + { HP_POP(libconfig->setting_lookup_int64, HP_libconfig_setting_lookup_int64) }, + { HP_POP(libconfig->setting_lookup_float, HP_libconfig_setting_lookup_float) }, + { HP_POP(libconfig->setting_lookup_bool, HP_libconfig_setting_lookup_bool) }, + { HP_POP(libconfig->setting_lookup_string, HP_libconfig_setting_lookup_string) }, + { HP_POP(libconfig->setting_set_int, HP_libconfig_setting_set_int) }, + { HP_POP(libconfig->setting_set_int64, HP_libconfig_setting_set_int64) }, + { HP_POP(libconfig->setting_set_float, HP_libconfig_setting_set_float) }, + { HP_POP(libconfig->setting_set_bool, HP_libconfig_setting_set_bool) }, + { HP_POP(libconfig->setting_set_string, HP_libconfig_setting_set_string) }, + { HP_POP(libconfig->setting_set_format, HP_libconfig_setting_set_format) }, + { HP_POP(libconfig->setting_get_format, HP_libconfig_setting_get_format) }, + { HP_POP(libconfig->setting_get_int_elem, HP_libconfig_setting_get_int_elem) }, + { HP_POP(libconfig->setting_get_int64_elem, HP_libconfig_setting_get_int64_elem) }, + { HP_POP(libconfig->setting_get_float_elem, HP_libconfig_setting_get_float_elem) }, + { HP_POP(libconfig->setting_get_bool_elem, HP_libconfig_setting_get_bool_elem) }, + { HP_POP(libconfig->setting_get_string_elem, HP_libconfig_setting_get_string_elem) }, + { HP_POP(libconfig->setting_set_int_elem, HP_libconfig_setting_set_int_elem) }, + { HP_POP(libconfig->setting_set_int64_elem, HP_libconfig_setting_set_int64_elem) }, + { HP_POP(libconfig->setting_set_float_elem, HP_libconfig_setting_set_float_elem) }, + { HP_POP(libconfig->setting_set_bool_elem, HP_libconfig_setting_set_bool_elem) }, + { HP_POP(libconfig->setting_set_string_elem, HP_libconfig_setting_set_string_elem) }, + { HP_POP(libconfig->setting_index, HP_libconfig_setting_index) }, + { HP_POP(libconfig->setting_length, HP_libconfig_setting_length) }, + { HP_POP(libconfig->setting_get_elem, HP_libconfig_setting_get_elem) }, + { HP_POP(libconfig->setting_get_member, HP_libconfig_setting_get_member) }, + { HP_POP(libconfig->setting_add, HP_libconfig_setting_add) }, + { HP_POP(libconfig->setting_remove, HP_libconfig_setting_remove) }, + { HP_POP(libconfig->setting_remove_elem, HP_libconfig_setting_remove_elem) }, + { HP_POP(libconfig->setting_set_hook, HP_libconfig_setting_set_hook) }, + { HP_POP(libconfig->lookup, HP_libconfig_lookup) }, + { HP_POP(libconfig->lookup_from, HP_libconfig_lookup_from) }, + { HP_POP(libconfig->lookup_int, HP_libconfig_lookup_int) }, + { HP_POP(libconfig->lookup_int64, HP_libconfig_lookup_int64) }, + { HP_POP(libconfig->lookup_float, HP_libconfig_lookup_float) }, + { HP_POP(libconfig->lookup_bool, HP_libconfig_lookup_bool) }, + { HP_POP(libconfig->lookup_string, HP_libconfig_lookup_string) }, + { HP_POP(libconfig->read_file, HP_libconfig_read_file) }, + { HP_POP(libconfig->setting_copy_simple, HP_libconfig_setting_copy_simple) }, + { HP_POP(libconfig->setting_copy_elem, HP_libconfig_setting_copy_elem) }, + { HP_POP(libconfig->setting_copy_aggregate, HP_libconfig_setting_copy_aggregate) }, + { HP_POP(libconfig->setting_copy, HP_libconfig_setting_copy) }, /* logs */ { HP_POP(logs->pick_pc, HP_logs_pick_pc) }, { HP_POP(logs->pick_mob, HP_logs_pick_mob) }, @@ -1370,6 +1466,20 @@ struct HookingPointData HookingPoints[] = { { HP_POP(mail->openmail, HP_mail_openmail) }, { HP_POP(mail->deliveryfail, HP_mail_deliveryfail) }, { HP_POP(mail->invalid_operation, HP_mail_invalid_operation) }, +/* iMalloc */ + { HP_POP(iMalloc->init, HP_iMalloc_init) }, + { HP_POP(iMalloc->final, HP_iMalloc_final) }, + { HP_POP(iMalloc->malloc, HP_iMalloc_malloc) }, + { HP_POP(iMalloc->calloc, HP_iMalloc_calloc) }, + { HP_POP(iMalloc->realloc, HP_iMalloc_realloc) }, + { HP_POP(iMalloc->reallocz, HP_iMalloc_reallocz) }, + { HP_POP(iMalloc->astrdup, HP_iMalloc_astrdup) }, + { HP_POP(iMalloc->free, HP_iMalloc_free) }, + { HP_POP(iMalloc->memory_check, HP_iMalloc_memory_check) }, + { HP_POP(iMalloc->verify_ptr, HP_iMalloc_verify_ptr) }, + { HP_POP(iMalloc->usage, HP_iMalloc_usage) }, + { HP_POP(iMalloc->post_shutdown, HP_iMalloc_post_shutdown) }, + { HP_POP(iMalloc->init_messages, HP_iMalloc_init_messages) }, /* map */ { HP_POP(map->zone_init, HP_map_zone_init) }, { HP_POP(map->zone_remove, HP_map_zone_remove) }, @@ -1499,6 +1609,16 @@ struct HookingPointData HookingPoints[] = { { HP_POP(map->remove_questinfo, HP_map_remove_questinfo) }, { HP_POP(map->merge_zone, HP_map_merge_zone) }, { HP_POP(map->zone_clear_single, HP_map_zone_clear_single) }, +/* mapindex */ + { HP_POP(mapindex->init, HP_mapindex_init) }, + { HP_POP(mapindex->final, HP_mapindex_final) }, + { HP_POP(mapindex->addmap, HP_mapindex_addmap) }, + { HP_POP(mapindex->removemap, HP_mapindex_removemap) }, + { HP_POP(mapindex->getmapname, HP_mapindex_getmapname) }, + { HP_POP(mapindex->getmapname_ext, HP_mapindex_getmapname_ext) }, + { HP_POP(mapindex->name2id, HP_mapindex_name2id) }, + { HP_POP(mapindex->id2name, HP_mapindex_id2name) }, + { HP_POP(mapindex->check_default, HP_mapindex_check_default) }, /* mapit */ { HP_POP(mapit->alloc, HP_mapit_alloc) }, { HP_POP(mapit->free, HP_mapit_free) }, @@ -1748,6 +1868,8 @@ struct HookingPointData HookingPoints[] = { { HP_POP(npc->market_delfromsql_sub, HP_npc_market_delfromsql_sub) }, { HP_POP(npc->db_checkid, HP_npc_db_checkid) }, { HP_POP(npc->secure_timeout_timer, HP_npc_secure_timeout_timer) }, +/* nullpo */ + { HP_POP(nullpo->assert_report, HP_nullpo_assert_report) }, /* party */ { HP_POP(party->init, HP_party_init) }, { HP_POP(party->final, HP_party_final) }, @@ -2114,6 +2236,8 @@ struct HookingPointData HookingPoints[] = { { HP_POP(script->get_constant, HP_script_get_constant) }, { HP_POP(script->label_add, HP_script_label_add) }, { HP_POP(script->run, HP_script_run) }, + { HP_POP(script->run_npc, HP_script_run_npc) }, + { HP_POP(script->run_pet, HP_script_run_pet) }, { HP_POP(script->run_main, HP_script_run_main) }, { HP_POP(script->run_timer, HP_script_run_timer) }, { HP_POP(script->set_var, HP_script_set_var) }, @@ -2230,6 +2354,9 @@ struct HookingPointData HookingPoints[] = { { HP_POP(script->add_language, HP_script_add_language) }, { HP_POP(script->get_translation_file_name, HP_script_get_translation_file_name) }, { HP_POP(script->parser_clean_leftovers, HP_script_parser_clean_leftovers) }, + { HP_POP(script->run_use_script, HP_script_run_use_script) }, + { HP_POP(script->run_item_equip_script, HP_script_run_item_equip_script) }, + { HP_POP(script->run_item_unequip_script, HP_script_run_item_unequip_script) }, /* searchstore */ { HP_POP(searchstore->open, HP_searchstore_open) }, { HP_POP(searchstore->query, HP_searchstore_query) }, @@ -2241,6 +2368,11 @@ struct HookingPointData HookingPoints[] = { { HP_POP(searchstore->queryremote, HP_searchstore_queryremote) }, { HP_POP(searchstore->clearremote, HP_searchstore_clearremote) }, { HP_POP(searchstore->result, HP_searchstore_result) }, +/* showmsg */ + { HP_POP(showmsg->init, HP_showmsg_init) }, + { HP_POP(showmsg->final, HP_showmsg_final) }, + { HP_POP(showmsg->clearScreen, HP_showmsg_clearScreen) }, + { HP_POP(showmsg->showMessageV, HP_showmsg_showMessageV) }, /* skill */ { HP_POP(skill->init, HP_skill_init) }, { HP_POP(skill->final, HP_skill_final) }, @@ -2459,6 +2591,68 @@ struct HookingPointData HookingPoints[] = { { HP_POP(skill->get_requirement_off_unknown, HP_skill_get_requirement_off_unknown) }, { HP_POP(skill->get_requirement_item_unknown, HP_skill_get_requirement_item_unknown) }, { HP_POP(skill->get_requirement_unknown, HP_skill_get_requirement_unknown) }, +/* sockt */ + { HP_POP(sockt->init, HP_sockt_init) }, + { HP_POP(sockt->final, HP_sockt_final) }, + { HP_POP(sockt->perform, HP_sockt_perform) }, + { HP_POP(sockt->datasync, HP_sockt_datasync) }, + { HP_POP(sockt->make_listen_bind, HP_sockt_make_listen_bind) }, + { HP_POP(sockt->make_connection, HP_sockt_make_connection) }, + { HP_POP(sockt->realloc_fifo, HP_sockt_realloc_fifo) }, + { HP_POP(sockt->realloc_writefifo, HP_sockt_realloc_writefifo) }, + { HP_POP(sockt->wfifoset, HP_sockt_wfifoset) }, + { HP_POP(sockt->rfifoskip, HP_sockt_rfifoskip) }, + { HP_POP(sockt->close, HP_sockt_close) }, + { HP_POP(sockt->session_is_valid, HP_sockt_session_is_valid) }, + { HP_POP(sockt->session_is_active, HP_sockt_session_is_active) }, + { HP_POP(sockt->flush, HP_sockt_flush) }, + { HP_POP(sockt->flush_fifos, HP_sockt_flush_fifos) }, + { HP_POP(sockt->set_nonblocking, HP_sockt_set_nonblocking) }, + { HP_POP(sockt->set_defaultparse, HP_sockt_set_defaultparse) }, + { HP_POP(sockt->host2ip, HP_sockt_host2ip) }, + { HP_POP(sockt->ip2str, HP_sockt_ip2str) }, + { HP_POP(sockt->str2ip, HP_sockt_str2ip) }, + { HP_POP(sockt->ntows, HP_sockt_ntows) }, + { HP_POP(sockt->getips, HP_sockt_getips) }, + { HP_POP(sockt->eof, HP_sockt_eof) }, + { HP_POP(sockt->lan_subnet_check, HP_sockt_lan_subnet_check) }, + { HP_POP(sockt->allowed_ip_check, HP_sockt_allowed_ip_check) }, + { HP_POP(sockt->trusted_ip_check, HP_sockt_trusted_ip_check) }, + { HP_POP(sockt->net_config_read_sub, HP_sockt_net_config_read_sub) }, + { HP_POP(sockt->net_config_read, HP_sockt_net_config_read) }, +/* SQL */ + { HP_POP(SQL->Connect, HP_SQL_Connect) }, + { HP_POP(SQL->GetTimeout, HP_SQL_GetTimeout) }, + { HP_POP(SQL->GetColumnNames, HP_SQL_GetColumnNames) }, + { HP_POP(SQL->SetEncoding, HP_SQL_SetEncoding) }, + { HP_POP(SQL->Ping, HP_SQL_Ping) }, + { HP_POP(SQL->EscapeString, HP_SQL_EscapeString) }, + { HP_POP(SQL->EscapeStringLen, HP_SQL_EscapeStringLen) }, + { HP_POP(SQL->QueryV, HP_SQL_QueryV) }, + { HP_POP(SQL->QueryStr, HP_SQL_QueryStr) }, + { HP_POP(SQL->LastInsertId, HP_SQL_LastInsertId) }, + { HP_POP(SQL->NumColumns, HP_SQL_NumColumns) }, + { HP_POP(SQL->NumRows, HP_SQL_NumRows) }, + { HP_POP(SQL->NextRow, HP_SQL_NextRow) }, + { HP_POP(SQL->GetData, HP_SQL_GetData) }, + { HP_POP(SQL->FreeResult, HP_SQL_FreeResult) }, + { HP_POP(SQL->ShowDebug_, HP_SQL_ShowDebug_) }, + { HP_POP(SQL->Free, HP_SQL_Free) }, + { HP_POP(SQL->Malloc, HP_SQL_Malloc) }, + { HP_POP(SQL->StmtMalloc, HP_SQL_StmtMalloc) }, + { HP_POP(SQL->StmtPrepareV, HP_SQL_StmtPrepareV) }, + { HP_POP(SQL->StmtPrepareStr, HP_SQL_StmtPrepareStr) }, + { HP_POP(SQL->StmtNumParams, HP_SQL_StmtNumParams) }, + { HP_POP(SQL->StmtBindParam, HP_SQL_StmtBindParam) }, + { HP_POP(SQL->StmtExecute, HP_SQL_StmtExecute) }, + { HP_POP(SQL->StmtLastInsertId, HP_SQL_StmtLastInsertId) }, + { HP_POP(SQL->StmtNumColumns, HP_SQL_StmtNumColumns) }, + { HP_POP(SQL->StmtBindColumn, HP_SQL_StmtBindColumn) }, + { HP_POP(SQL->StmtNumRows, HP_SQL_StmtNumRows) }, + { HP_POP(SQL->StmtNextRow, HP_SQL_StmtNextRow) }, + { HP_POP(SQL->StmtFreeResult, HP_SQL_StmtFreeResult) }, + { HP_POP(SQL->StmtFree, HP_SQL_StmtFree) }, + { HP_POP(SQL->StmtShowDebug_, HP_SQL_StmtShowDebug_) }, /* status */ { HP_POP(status->init, HP_status_init) }, { HP_POP(status->final, HP_status_final) }, @@ -2508,6 +2702,7 @@ struct HookingPointData HookingPoints[] = { { HP_POP(status->calc_mob_, HP_status_calc_mob_) }, { HP_POP(status->calc_pet_, HP_status_calc_pet_) }, { HP_POP(status->calc_pc_, HP_status_calc_pc_) }, + { HP_POP(status->calc_pc_additional, HP_status_calc_pc_additional) }, { HP_POP(status->calc_homunculus_, HP_status_calc_homunculus_) }, { HP_POP(status->calc_mercenary_, HP_status_calc_mercenary_) }, { HP_POP(status->calc_elemental_, HP_status_calc_elemental_) }, @@ -2584,6 +2779,73 @@ struct HookingPointData HookingPoints[] = { { HP_POP(storage->comp_item, HP_storage_comp_item) }, { HP_POP(storage->sortitem, HP_storage_sortitem) }, { HP_POP(storage->reconnect_sub, HP_storage_reconnect_sub) }, +/* StrBuf */ + { HP_POP(StrBuf->Malloc, HP_StrBuf_Malloc) }, + { HP_POP(StrBuf->Init, HP_StrBuf_Init) }, + { HP_POP(StrBuf->Vprintf, HP_StrBuf_Vprintf) }, + { HP_POP(StrBuf->Append, HP_StrBuf_Append) }, + { HP_POP(StrBuf->AppendStr, HP_StrBuf_AppendStr) }, + { HP_POP(StrBuf->Length, HP_StrBuf_Length) }, + { HP_POP(StrBuf->Value, HP_StrBuf_Value) }, + { HP_POP(StrBuf->Clear, HP_StrBuf_Clear) }, + { HP_POP(StrBuf->Destroy, HP_StrBuf_Destroy) }, + { HP_POP(StrBuf->Free, HP_StrBuf_Free) }, +/* strlib */ + { HP_POP(strlib->jstrescape, HP_strlib_jstrescape) }, + { HP_POP(strlib->jstrescapecpy, HP_strlib_jstrescapecpy) }, + { HP_POP(strlib->jmemescapecpy, HP_strlib_jmemescapecpy) }, + { HP_POP(strlib->remove_control_chars_, HP_strlib_remove_control_chars_) }, + { HP_POP(strlib->trim_, HP_strlib_trim_) }, + { HP_POP(strlib->normalize_name_, HP_strlib_normalize_name_) }, + { HP_POP(strlib->stristr_, HP_strlib_stristr_) }, + { HP_POP(strlib->strnlen_, HP_strlib_strnlen_) }, + { HP_POP(strlib->strtok_r_, HP_strlib_strtok_r_) }, + { HP_POP(strlib->e_mail_check_, HP_strlib_e_mail_check_) }, + { HP_POP(strlib->config_switch_, HP_strlib_config_switch_) }, + { HP_POP(strlib->safestrncpy_, HP_strlib_safestrncpy_) }, + { HP_POP(strlib->safestrnlen_, HP_strlib_safestrnlen_) }, + { HP_POP(strlib->strline_, HP_strlib_strline_) }, + { HP_POP(strlib->bin2hex_, HP_strlib_bin2hex_) }, +/* sv */ + { HP_POP(sv->parse_next, HP_sv_parse_next) }, + { HP_POP(sv->parse, HP_sv_parse) }, + { HP_POP(sv->split, HP_sv_split) }, + { HP_POP(sv->escape_c, HP_sv_escape_c) }, + { HP_POP(sv->unescape_c, HP_sv_unescape_c) }, + { HP_POP(sv->skip_escaped_c, HP_sv_skip_escaped_c) }, + { HP_POP(sv->readdb, HP_sv_readdb) }, +/* sysinfo */ + { HP_POP(sysinfo->getpagesize, HP_sysinfo_getpagesize) }, + { HP_POP(sysinfo->platform, HP_sysinfo_platform) }, + { HP_POP(sysinfo->osversion, HP_sysinfo_osversion) }, + { HP_POP(sysinfo->cpu, HP_sysinfo_cpu) }, + { HP_POP(sysinfo->cpucores, HP_sysinfo_cpucores) }, + { HP_POP(sysinfo->arch, HP_sysinfo_arch) }, + { HP_POP(sysinfo->is64bit, HP_sysinfo_is64bit) }, + { HP_POP(sysinfo->compiler, HP_sysinfo_compiler) }, + { HP_POP(sysinfo->cflags, HP_sysinfo_cflags) }, + { HP_POP(sysinfo->vcstype, HP_sysinfo_vcstype) }, + { HP_POP(sysinfo->vcstypeid, HP_sysinfo_vcstypeid) }, + { HP_POP(sysinfo->vcsrevision_src, HP_sysinfo_vcsrevision_src) }, + { HP_POP(sysinfo->vcsrevision_scripts, HP_sysinfo_vcsrevision_scripts) }, + { HP_POP(sysinfo->vcsrevision_reload, HP_sysinfo_vcsrevision_reload) }, + { HP_POP(sysinfo->is_superuser, HP_sysinfo_is_superuser) }, + { HP_POP(sysinfo->init, HP_sysinfo_init) }, + { HP_POP(sysinfo->final, HP_sysinfo_final) }, +/* timer */ + { HP_POP(timer->gettick, HP_timer_gettick) }, + { HP_POP(timer->gettick_nocache, HP_timer_gettick_nocache) }, + { HP_POP(timer->add, HP_timer_add) }, + { HP_POP(timer->add_interval, HP_timer_add_interval) }, + { HP_POP(timer->get, HP_timer_get) }, + { HP_POP(timer->delete, HP_timer_delete) }, + { HP_POP(timer->addtick, HP_timer_addtick) }, + { HP_POP(timer->settick, HP_timer_settick) }, + { HP_POP(timer->add_func_list, HP_timer_add_func_list) }, + { HP_POP(timer->get_uptime, HP_timer_get_uptime) }, + { HP_POP(timer->perform, HP_timer_perform) }, + { HP_POP(timer->init, HP_timer_init) }, + { HP_POP(timer->final, HP_timer_final) }, /* trade */ { HP_POP(trade->request, HP_trade_request) }, { HP_POP(trade->ack, HP_trade_ack) }, diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc index 85f477bec..bc2235b02 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc @@ -4,6 +4,87 @@ // NOTE: This file was auto-generated and should never be manually edited, // as it will get overwritten. +/* HCache */ +void HP_HCache_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_HCache_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.HCache.init(); + } + if( HPMHooks.count.HP_HCache_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_HCache_check(const char *file) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_HCache_check_pre ) { + bool (*preHookFunc) (const char *file); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_check_pre[hIndex].func; + retVal___ = preHookFunc(file); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.HCache.check(file); + } + if( HPMHooks.count.HP_HCache_check_post ) { + bool (*postHookFunc) (bool retVal___, const char *file); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file); + } + } + return retVal___; +} +FILE* HP_HCache_open(const char *file, const char *opt) { + int hIndex = 0; + FILE* retVal___ = NULL; + if( HPMHooks.count.HP_HCache_open_pre ) { + FILE* (*preHookFunc) (const char *file, const char *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_HCache_open_pre[hIndex].func; + retVal___ = preHookFunc(file, opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.HCache.open(file, opt); + } + if( HPMHooks.count.HP_HCache_open_post ) { + FILE* (*postHookFunc) (FILE* retVal___, const char *file, const char *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_HCache_open_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file, opt); + } + } + return retVal___; +} /* atcommand */ void HP_atcommand_init(bool minimal) { int hIndex = 0; @@ -23758,6 +23839,793 @@ void HP_clif_pNPCMarketPurchase(int fd, struct map_session_data *sd) { } return; } +/* cmdline */ +void HP_cmdline_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_cmdline_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.cmdline.init(); + } + if( HPMHooks.count.HP_cmdline_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_cmdline_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_cmdline_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.cmdline.final(); + } + if( HPMHooks.count.HP_cmdline_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_cmdline_arg_add_pre ) { + bool (*preHookFunc) (unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_add_pre[hIndex].func; + retVal___ = preHookFunc(&pluginID, name, &shortname, &func, help, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_add(pluginID, name, shortname, func, help, options); + } + if( HPMHooks.count.HP_cmdline_arg_add_post ) { + bool (*postHookFunc) (bool retVal___, unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &pluginID, name, &shortname, &func, help, &options); + } + } + return retVal___; +} +int HP_cmdline_exec(int argc, char **argv, unsigned int options) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_cmdline_exec_pre ) { + int (*preHookFunc) (int *argc, char **argv, unsigned int *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_exec_pre[hIndex].func; + retVal___ = preHookFunc(&argc, argv, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.exec(argc, argv, options); + } + if( HPMHooks.count.HP_cmdline_exec_post ) { + int (*postHookFunc) (int retVal___, int *argc, char **argv, unsigned int *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_exec_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &argc, argv, &options); + } + } + return retVal___; +} +bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_cmdline_arg_next_value_pre ) { + bool (*preHookFunc) (const char *name, int *current_arg, int *argc); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_pre[hIndex].func; + retVal___ = preHookFunc(name, ¤t_arg, &argc); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_next_value(name, current_arg, argc); + } + if( HPMHooks.count.HP_cmdline_arg_next_value_post ) { + bool (*postHookFunc) (bool retVal___, const char *name, int *current_arg, int *argc); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_post[hIndex].func; + retVal___ = postHookFunc(retVal___, name, ¤t_arg, &argc); + } + } + return retVal___; +} +const char* HP_cmdline_arg_source(struct CmdlineArgData *arg) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_cmdline_arg_source_pre ) { + const char* (*preHookFunc) (struct CmdlineArgData *arg); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_cmdline_arg_source_pre[hIndex].func; + retVal___ = preHookFunc(arg); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.cmdline.arg_source(arg); + } + if( HPMHooks.count.HP_cmdline_arg_source_post ) { + const char* (*postHookFunc) (const char* retVal___, struct CmdlineArgData *arg); + for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_cmdline_arg_source_post[hIndex].func; + retVal___ = postHookFunc(retVal___, arg); + } + } + return retVal___; +} +/* console */ +void HP_console_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.init(); + } + if( HPMHooks.count.HP_console_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_console_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.final(); + } + if( HPMHooks.count.HP_console_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_console_display_title(void) { + int hIndex = 0; + if( HPMHooks.count.HP_console_display_title_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_console_display_title_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.console.display_title(); + } + if( HPMHooks.count.HP_console_display_title_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_console_display_title_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* core */ +void HP_core_shutdown_callback(void) { + int hIndex = 0; + if( HPMHooks.count.HP_core_shutdown_callback_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_core_shutdown_callback_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.core.shutdown_callback(); + } + if( HPMHooks.count.HP_core_shutdown_callback_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_core_shutdown_callback_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* DB */ +DBOptions HP_DB_fix_options(DBType type, DBOptions options) { + int hIndex = 0; + DBOptions retVal___ = DB_OPT_BASE; + if( HPMHooks.count.HP_DB_fix_options_pre ) { + DBOptions (*preHookFunc) (DBType *type, DBOptions *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_fix_options_pre[hIndex].func; + retVal___ = preHookFunc(&type, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.fix_options(type, options); + } + if( HPMHooks.count.HP_DB_fix_options_post ) { + DBOptions (*postHookFunc) (DBOptions retVal___, DBType *type, DBOptions *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_fix_options_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type, &options); + } + } + return retVal___; +} +DBComparator HP_DB_default_cmp(DBType type) { + int hIndex = 0; + DBComparator retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_cmp_pre ) { + DBComparator (*preHookFunc) (DBType *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_cmp_pre[hIndex].func; + retVal___ = preHookFunc(&type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_cmp(type); + } + if( HPMHooks.count.HP_DB_default_cmp_post ) { + DBComparator (*postHookFunc) (DBComparator retVal___, DBType *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_cmp_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type); + } + } + return retVal___; +} +DBHasher HP_DB_default_hash(DBType type) { + int hIndex = 0; + DBHasher retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_hash_pre ) { + DBHasher (*preHookFunc) (DBType *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_hash_pre[hIndex].func; + retVal___ = preHookFunc(&type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_hash(type); + } + if( HPMHooks.count.HP_DB_default_hash_post ) { + DBHasher (*postHookFunc) (DBHasher retVal___, DBType *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_hash_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type); + } + } + return retVal___; +} +DBReleaser HP_DB_default_release(DBType type, DBOptions options) { + int hIndex = 0; + DBReleaser retVal___ = NULL; + if( HPMHooks.count.HP_DB_default_release_pre ) { + DBReleaser (*preHookFunc) (DBType *type, DBOptions *options); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_default_release_pre[hIndex].func; + retVal___ = preHookFunc(&type, &options); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.default_release(type, options); + } + if( HPMHooks.count.HP_DB_default_release_post ) { + DBReleaser (*postHookFunc) (DBReleaser retVal___, DBType *type, DBOptions *options); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_default_release_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &type, &options); + } + } + return retVal___; +} +DBReleaser HP_DB_custom_release(DBRelease which) { + int hIndex = 0; + DBReleaser retVal___ = NULL; + if( HPMHooks.count.HP_DB_custom_release_pre ) { + DBReleaser (*preHookFunc) (DBRelease *which); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_custom_release_pre[hIndex].func; + retVal___ = preHookFunc(&which); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.custom_release(which); + } + if( HPMHooks.count.HP_DB_custom_release_post ) { + DBReleaser (*postHookFunc) (DBReleaser retVal___, DBRelease *which); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_custom_release_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &which); + } + } + return retVal___; +} +DBMap* HP_DB_alloc(const char *file, const char *func, int line, DBType type, DBOptions options, unsigned short maxlen) { + int hIndex = 0; + DBMap* retVal___ = NULL; + if( HPMHooks.count.HP_DB_alloc_pre ) { + DBMap* (*preHookFunc) (const char *file, const char *func, int *line, DBType *type, DBOptions *options, unsigned short *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_alloc_pre[hIndex].func; + retVal___ = preHookFunc(file, func, &line, &type, &options, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen); + } + if( HPMHooks.count.HP_DB_alloc_post ) { + DBMap* (*postHookFunc) (DBMap* retVal___, const char *file, const char *func, int *line, DBType *type, DBOptions *options, unsigned short *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_alloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, file, func, &line, &type, &options, &maxlen); + } + } + return retVal___; +} +DBKey HP_DB_i2key(int key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_i2key_pre ) { + DBKey (*preHookFunc) (int *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i2key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i2key(key); + } + if( HPMHooks.count.HP_DB_i2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, int *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_ui2key(unsigned int key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_ui2key_pre ) { + DBKey (*preHookFunc) (unsigned int *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui2key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui2key(key); + } + if( HPMHooks.count.HP_DB_ui2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, unsigned int *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_str2key(const char *key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_str2key_pre ) { + DBKey (*preHookFunc) (const char *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_str2key_pre[hIndex].func; + retVal___ = preHookFunc(key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.str2key(key); + } + if( HPMHooks.count.HP_DB_str2key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, const char *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_str2key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, key); + } + } + return retVal___; +} +DBKey HP_DB_i642key(int64 key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_i642key_pre ) { + DBKey (*preHookFunc) (int64 *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i642key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i642key(key); + } + if( HPMHooks.count.HP_DB_i642key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, int64 *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i642key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBKey HP_DB_ui642key(uint64 key) { + int hIndex = 0; + DBKey retVal___; + memset(&retVal___, '\0', sizeof(DBKey)); + if( HPMHooks.count.HP_DB_ui642key_pre ) { + DBKey (*preHookFunc) (uint64 *key); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui642key_pre[hIndex].func; + retVal___ = preHookFunc(&key); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui642key(key); + } + if( HPMHooks.count.HP_DB_ui642key_post ) { + DBKey (*postHookFunc) (DBKey retVal___, uint64 *key); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui642key_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &key); + } + } + return retVal___; +} +DBData HP_DB_i2data(int data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_i2data_pre ) { + DBData (*preHookFunc) (int *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_i2data_pre[hIndex].func; + retVal___ = preHookFunc(&data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.i2data(data); + } + if( HPMHooks.count.HP_DB_i2data_post ) { + DBData (*postHookFunc) (DBData retVal___, int *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_i2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &data); + } + } + return retVal___; +} +DBData HP_DB_ui2data(unsigned int data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_ui2data_pre ) { + DBData (*preHookFunc) (unsigned int *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ui2data_pre[hIndex].func; + retVal___ = preHookFunc(&data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ui2data(data); + } + if( HPMHooks.count.HP_DB_ui2data_post ) { + DBData (*postHookFunc) (DBData retVal___, unsigned int *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ui2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &data); + } + } + return retVal___; +} +DBData HP_DB_ptr2data(void *data) { + int hIndex = 0; + DBData retVal___; + memset(&retVal___, '\0', sizeof(DBData)); + if( HPMHooks.count.HP_DB_ptr2data_pre ) { + DBData (*preHookFunc) (void *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_ptr2data_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.ptr2data(data); + } + if( HPMHooks.count.HP_DB_ptr2data_post ) { + DBData (*postHookFunc) (DBData retVal___, void *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_ptr2data_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +int HP_DB_data2i(DBData *data) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_DB_data2i_pre ) { + int (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2i_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2i(data); + } + if( HPMHooks.count.HP_DB_data2i_post ) { + int (*postHookFunc) (int retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2i_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +unsigned int HP_DB_data2ui(DBData *data) { + int hIndex = 0; + unsigned int retVal___ = 0; + if( HPMHooks.count.HP_DB_data2ui_pre ) { + unsigned int (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2ui_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2ui(data); + } + if( HPMHooks.count.HP_DB_data2ui_post ) { + unsigned int (*postHookFunc) (unsigned int retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2ui_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +void* HP_DB_data2ptr(DBData *data) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_DB_data2ptr_pre ) { + void* (*preHookFunc) (DBData *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_data2ptr_pre[hIndex].func; + retVal___ = preHookFunc(data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.DB.data2ptr(data); + } + if( HPMHooks.count.HP_DB_data2ptr_post ) { + void* (*postHookFunc) (void* retVal___, DBData *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_data2ptr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, data); + } + } + return retVal___; +} +void HP_DB_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_DB_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.DB.init(); + } + if( HPMHooks.count.HP_DB_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_DB_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_DB_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_DB_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.DB.final(); + } + if( HPMHooks.count.HP_DB_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_DB_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} /* duel */ int HP_duel_create(struct map_session_data *sd, const unsigned int maxpl) { int hIndex = 0; @@ -34907,6 +35775,1563 @@ bool HP_itemdb_lookup_const(const config_setting_t *it, const char *name, int *v } return retVal___; } +/* libconfig */ +int HP_libconfig_read(config_t *config, FILE *stream) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_pre ) { + int (*preHookFunc) (config_t *config, FILE *stream); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_pre[hIndex].func; + retVal___ = preHookFunc(config, stream); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read(config, stream); + } + if( HPMHooks.count.HP_libconfig_read_post ) { + int (*postHookFunc) (int retVal___, config_t *config, FILE *stream); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, stream); + } + } + return retVal___; +} +void HP_libconfig_write(const config_t *config, FILE *stream) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_write_pre ) { + void (*preHookFunc) (const config_t *config, FILE *stream); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_write_pre[hIndex].func; + preHookFunc(config, stream); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.write(config, stream); + } + if( HPMHooks.count.HP_libconfig_write_post ) { + void (*postHookFunc) (const config_t *config, FILE *stream); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_write_post[hIndex].func; + postHookFunc(config, stream); + } + } + return; +} +void HP_libconfig_set_auto_convert(config_t *config, int flag) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_auto_convert_pre ) { + void (*preHookFunc) (config_t *config, int *flag); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_auto_convert_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_auto_convert_pre[hIndex].func; + preHookFunc(config, &flag); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_auto_convert(config, flag); + } + if( HPMHooks.count.HP_libconfig_set_auto_convert_post ) { + void (*postHookFunc) (config_t *config, int *flag); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_auto_convert_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_auto_convert_post[hIndex].func; + postHookFunc(config, &flag); + } + } + return; +} +int HP_libconfig_get_auto_convert(const config_t *config) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_get_auto_convert_pre ) { + int (*preHookFunc) (const config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_auto_convert_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_get_auto_convert_pre[hIndex].func; + retVal___ = preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.get_auto_convert(config); + } + if( HPMHooks.count.HP_libconfig_get_auto_convert_post ) { + int (*postHookFunc) (int retVal___, const config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_auto_convert_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_get_auto_convert_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config); + } + } + return retVal___; +} +int HP_libconfig_read_string(config_t *config, const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_string_pre ) { + int (*preHookFunc) (config_t *config, const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_string_pre[hIndex].func; + retVal___ = preHookFunc(config, str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_string(config, str); + } + if( HPMHooks.count.HP_libconfig_read_string_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, str); + } + } + return retVal___; +} +int HP_libconfig_read_file_src(config_t *config, const char *filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_file_src_pre ) { + int (*preHookFunc) (config_t *config, const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_file_src_pre[hIndex].func; + retVal___ = preHookFunc(config, filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_file_src(config, filename); + } + if( HPMHooks.count.HP_libconfig_read_file_src_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_file_src_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filename); + } + } + return retVal___; +} +int HP_libconfig_write_file(config_t *config, const char *filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_write_file_pre ) { + int (*preHookFunc) (config_t *config, const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_write_file_pre[hIndex].func; + retVal___ = preHookFunc(config, filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.write_file(config, filename); + } + if( HPMHooks.count.HP_libconfig_write_file_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_write_file_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filename); + } + } + return retVal___; +} +void HP_libconfig_set_destructor(config_t *config, void ( *destructor ) (void *)) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_destructor_pre ) { + void (*preHookFunc) (config_t *config, void ( *destructor ) (void *)); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_destructor_pre[hIndex].func; + preHookFunc(config, destructor); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_destructor(config, destructor); + } + if( HPMHooks.count.HP_libconfig_set_destructor_post ) { + void (*postHookFunc) (config_t *config, void ( *destructor ) (void *)); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_destructor_post[hIndex].func; + postHookFunc(config, destructor); + } + } + return; +} +void HP_libconfig_set_include_dir(config_t *config, const char *include_dir) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) { + void (*preHookFunc) (config_t *config, const char *include_dir); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_pre[hIndex].func; + preHookFunc(config, include_dir); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.set_include_dir(config, include_dir); + } + if( HPMHooks.count.HP_libconfig_set_include_dir_post ) { + void (*postHookFunc) (config_t *config, const char *include_dir); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_post[hIndex].func; + postHookFunc(config, include_dir); + } + } + return; +} +void HP_libconfig_init(config_t *config) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_init_pre ) { + void (*preHookFunc) (config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_init_pre[hIndex].func; + preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.init(config); + } + if( HPMHooks.count.HP_libconfig_init_post ) { + void (*postHookFunc) (config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_init_post[hIndex].func; + postHookFunc(config); + } + } + return; +} +void HP_libconfig_destroy(config_t *config) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_destroy_pre ) { + void (*preHookFunc) (config_t *config); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_destroy_pre[hIndex].func; + preHookFunc(config); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.destroy(config); + } + if( HPMHooks.count.HP_libconfig_destroy_post ) { + void (*postHookFunc) (config_t *config); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_destroy_post[hIndex].func; + postHookFunc(config); + } + } + return; +} +int HP_libconfig_setting_get_int(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_int_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +long long HP_libconfig_setting_get_int64(const config_setting_t *setting) { + int hIndex = 0; + long long retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) { + long long (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int64(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_int64_post ) { + long long (*postHookFunc) (long long retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +double HP_libconfig_setting_get_float(const config_setting_t *setting) { + int hIndex = 0; + double retVal___ = 0.; + if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) { + double (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_float(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_float_post ) { + double (*postHookFunc) (double retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_get_bool(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_bool(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_bool_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +const char* HP_libconfig_setting_get_string(const config_setting_t *setting) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) { + const char* (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_string(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_string_post ) { + const char* (*postHookFunc) (const char* retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_int(const config_setting_t *setting, const char *name, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_int(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_int_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_int64(const config_setting_t *setting, const char *name, long long *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_int64(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_int64_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_float(const config_setting_t *setting, const char *name, double *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_float(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_float_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_bool(const config_setting_t *setting, const char *name, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_bool(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_bool_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_lookup_string(const config_setting_t *setting, const char *name, const char **value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) { + int (*preHookFunc) (const config_setting_t *setting, const char *name, const char **value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_pre[hIndex].func; + retVal___ = preHookFunc(setting, name, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_lookup_string(setting, name, value); + } + if( HPMHooks.count.HP_libconfig_setting_lookup_string_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, const char *name, const char **value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name, value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_int(config_setting_t *setting, int value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) { + int (*preHookFunc) (config_setting_t *setting, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_int64(config_setting_t *setting, long long value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) { + int (*preHookFunc) (config_setting_t *setting, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_float(config_setting_t *setting, double value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) { + int (*preHookFunc) (config_setting_t *setting, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_float_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_bool(config_setting_t *setting, int value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) { + int (*preHookFunc) (config_setting_t *setting, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_pre[hIndex].func; + retVal___ = preHookFunc(setting, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_string(config_setting_t *setting, const char *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) { + int (*preHookFunc) (config_setting_t *setting, const char *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_pre[hIndex].func; + retVal___ = preHookFunc(setting, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_string(setting, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_string_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, const char *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, value); + } + } + return retVal___; +} +int HP_libconfig_setting_set_format(config_setting_t *setting, short format) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) { + int (*preHookFunc) (config_setting_t *setting, short *format); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_pre[hIndex].func; + retVal___ = preHookFunc(setting, &format); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format); + } + if( HPMHooks.count.HP_libconfig_setting_set_format_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *setting, short *format); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &format); + } + } + return retVal___; +} +short HP_libconfig_setting_get_format(const config_setting_t *setting) { + int hIndex = 0; + short retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) { + short (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_format(setting); + } + if( HPMHooks.count.HP_libconfig_setting_get_format_post ) { + short (*postHookFunc) (short retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_get_int_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) { + int (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_int_elem_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +long long HP_libconfig_setting_get_int64_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + long long retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) { + long long (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_int64_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_post ) { + long long (*postHookFunc) (long long retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +double HP_libconfig_setting_get_float_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + double retVal___ = 0.; + if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) { + double (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_float_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_float_elem_post ) { + double (*postHookFunc) (double retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +int HP_libconfig_setting_get_bool_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) { + int (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_bool_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +const char* HP_libconfig_setting_get_string_elem(const config_setting_t *setting, int idx) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) { + const char* (*preHookFunc) (const config_setting_t *setting, int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_string_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_string_elem_post ) { + const char* (*postHookFunc) (const char* retVal___, const config_setting_t *setting, int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_int_elem(config_setting_t *setting, int idx, int value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_int64_elem(config_setting_t *setting, int idx, long long value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_float_elem(config_setting_t *setting, int idx, double value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_bool_elem(config_setting_t *setting, int idx, int value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, &value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, &value); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_set_string_elem(config_setting_t *setting, int idx, const char *value) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, int *idx, const char *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value); + } + if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, int *idx, const char *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx, value); + } + } + return retVal___; +} +int HP_libconfig_setting_index(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_index_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_index_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_index(setting); + } + if( HPMHooks.count.HP_libconfig_setting_index_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_index_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +int HP_libconfig_setting_length(const config_setting_t *setting) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_length_pre ) { + int (*preHookFunc) (const config_setting_t *setting); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_length_pre[hIndex].func; + retVal___ = preHookFunc(setting); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_length(setting); + } + if( HPMHooks.count.HP_libconfig_setting_length_post ) { + int (*postHookFunc) (int retVal___, const config_setting_t *setting); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_length_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_get_elem(const config_setting_t *setting, unsigned int idx) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) { + config_setting_t* (*preHookFunc) (const config_setting_t *setting, unsigned int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_pre[hIndex].func; + retVal___ = preHookFunc(setting, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx); + } + if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_setting_t *setting, unsigned int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, &idx); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_get_member(const config_setting_t *setting, const char *name) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) { + config_setting_t* (*preHookFunc) (const config_setting_t *setting, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_pre[hIndex].func; + retVal___ = preHookFunc(setting, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_get_member(setting, name); + } + if( HPMHooks.count.HP_libconfig_setting_get_member_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_setting_t *setting, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, name); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_setting_add(config_setting_t *parent, const char *name, int type) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_setting_add_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *parent, const char *name, int *type); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_add_pre[hIndex].func; + retVal___ = preHookFunc(parent, name, &type); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type); + } + if( HPMHooks.count.HP_libconfig_setting_add_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *parent, const char *name, int *type); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, name, &type); + } + } + return retVal___; +} +int HP_libconfig_setting_remove(config_setting_t *parent, const char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_remove_pre ) { + int (*preHookFunc) (config_setting_t *parent, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_pre[hIndex].func; + retVal___ = preHookFunc(parent, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_remove(parent, name); + } + if( HPMHooks.count.HP_libconfig_setting_remove_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, name); + } + } + return retVal___; +} +int HP_libconfig_setting_remove_elem(config_setting_t *parent, unsigned int idx) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) { + int (*preHookFunc) (config_setting_t *parent, unsigned int *idx); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_pre[hIndex].func; + retVal___ = preHookFunc(parent, &idx); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx); + } + if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, unsigned int *idx); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, &idx); + } + } + return retVal___; +} +void HP_libconfig_setting_set_hook(config_setting_t *setting, void *hook) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) { + void (*preHookFunc) (config_setting_t *setting, void *hook); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_pre[hIndex].func; + preHookFunc(setting, hook); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_set_hook(setting, hook); + } + if( HPMHooks.count.HP_libconfig_setting_set_hook_post ) { + void (*postHookFunc) (config_setting_t *setting, void *hook); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_post[hIndex].func; + postHookFunc(setting, hook); + } + } + return; +} +config_setting_t* HP_libconfig_lookup(const config_t *config, const char *filepath) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_lookup_pre ) { + config_setting_t* (*preHookFunc) (const config_t *config, const char *filepath); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup(config, filepath); + } + if( HPMHooks.count.HP_libconfig_lookup_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, const config_t *config, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath); + } + } + return retVal___; +} +config_setting_t* HP_libconfig_lookup_from(config_setting_t *setting, const char *filepath) { + int hIndex = 0; + config_setting_t* retVal___ = NULL; + if( HPMHooks.count.HP_libconfig_lookup_from_pre ) { + config_setting_t* (*preHookFunc) (config_setting_t *setting, const char *filepath); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_from_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_from_pre[hIndex].func; + retVal___ = preHookFunc(setting, filepath); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_from(setting, filepath); + } + if( HPMHooks.count.HP_libconfig_lookup_from_post ) { + config_setting_t* (*postHookFunc) (config_setting_t* retVal___, config_setting_t *setting, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_from_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_from_post[hIndex].func; + retVal___ = postHookFunc(retVal___, setting, filepath); + } + } + return retVal___; +} +int HP_libconfig_lookup_int(const config_t *config, const char *filepath, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_int_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_int_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_int(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_int_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_int_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_int64(const config_t *config, const char *filepath, long long *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, long long *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_int64(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_int64_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, long long *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_float(const config_t *config, const char *filepath, double *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_float_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, double *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_float_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_float(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_float_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, double *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_float_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_bool(const config_t *config, const char *filepath, int *value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, int *value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_bool(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_bool_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, int *value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_lookup_string(const config_t *config, const char *filepath, const char **value) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_lookup_string_pre ) { + int (*preHookFunc) (const config_t *config, const char *filepath, const char **value); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_lookup_string_pre[hIndex].func; + retVal___ = preHookFunc(config, filepath, value); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.lookup_string(config, filepath, value); + } + if( HPMHooks.count.HP_libconfig_lookup_string_post ) { + int (*postHookFunc) (int retVal___, const config_t *config, const char *filepath, const char **value); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_lookup_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, filepath, value); + } + } + return retVal___; +} +int HP_libconfig_read_file(config_t *config, const char *config_filename) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_read_file_pre ) { + int (*preHookFunc) (config_t *config, const char *config_filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_read_file_pre[hIndex].func; + retVal___ = preHookFunc(config, config_filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.read_file(config, config_filename); + } + if( HPMHooks.count.HP_libconfig_read_file_post ) { + int (*postHookFunc) (int retVal___, config_t *config, const char *config_filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_read_file_post[hIndex].func; + retVal___ = postHookFunc(retVal___, config, config_filename); + } + } + return retVal___; +} +void HP_libconfig_setting_copy_simple(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_simple(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_simple_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +void HP_libconfig_setting_copy_elem(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_elem(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_elem_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +void HP_libconfig_setting_copy_aggregate(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) { + void (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_pre[hIndex].func; + preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.libconfig.setting_copy_aggregate(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_post ) { + void (*postHookFunc) (config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_post[hIndex].func; + postHookFunc(parent, src); + } + } + return; +} +int HP_libconfig_setting_copy(config_setting_t *parent, const config_setting_t *src) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_libconfig_setting_copy_pre ) { + int (*preHookFunc) (config_setting_t *parent, const config_setting_t *src); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_pre[hIndex].func; + retVal___ = preHookFunc(parent, src); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.libconfig.setting_copy(parent, src); + } + if( HPMHooks.count.HP_libconfig_setting_copy_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *parent, const config_setting_t *src); + for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, parent, src); + } + } + return retVal___; +} /* logs */ void HP_logs_pick_pc(struct map_session_data *sd, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) { int hIndex = 0; @@ -35725,6 +38150,352 @@ bool HP_mail_invalid_operation(struct map_session_data *sd) { } return retVal___; } +/* iMalloc */ +void HP_iMalloc_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.init(); + } + if( HPMHooks.count.HP_iMalloc_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_iMalloc_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.final(); + } + if( HPMHooks.count.HP_iMalloc_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_malloc_pre ) { + void* (*preHookFunc) (size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func; + retVal___ = preHookFunc(&size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_malloc_post ) { + void* (*postHookFunc) (void* retVal___, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_calloc_pre ) { + void* (*preHookFunc) (size_t *num, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func; + retVal___ = preHookFunc(&num, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_calloc_post ) { + void* (*postHookFunc) (void* retVal___, size_t *num, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &num, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_realloc_pre ) { + void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func; + retVal___ = preHookFunc(p, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_realloc_post ) { + void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + } + } + return retVal___; +} +void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, const char *func) { + int hIndex = 0; + void* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_reallocz_pre ) { + void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func; + retVal___ = preHookFunc(p, &size, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_reallocz_post ) { + void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + } + } + return retVal___; +} +char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char *func) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_iMalloc_astrdup_pre ) { + char* (*preHookFunc) (const char *p, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func; + retVal___ = preHookFunc(p, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_astrdup_post ) { + char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, file, &line, func); + } + } + return retVal___; +} +void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_free_pre ) { + void (*preHookFunc) (void *p, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func; + preHookFunc(p, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.free(p, file, line, func); + } + if( HPMHooks.count.HP_iMalloc_free_post ) { + void (*postHookFunc) (void *p, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func; + postHookFunc(p, file, &line, func); + } + } + return; +} +void HP_iMalloc_memory_check(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_memory_check_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_memory_check_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.memory_check(); + } + if( HPMHooks.count.HP_iMalloc_memory_check_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_memory_check_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_iMalloc_verify_ptr(void *ptr) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) { + bool (*preHookFunc) (void *ptr); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func; + retVal___ = preHookFunc(ptr); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.verify_ptr(ptr); + } + if( HPMHooks.count.HP_iMalloc_verify_ptr_post ) { + bool (*postHookFunc) (bool retVal___, void *ptr); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ptr); + } + } + return retVal___; +} +size_t HP_iMalloc_usage(void) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_iMalloc_usage_pre ) { + size_t (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_usage_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.iMalloc.usage(); + } + if( HPMHooks.count.HP_iMalloc_usage_post ) { + size_t (*postHookFunc) (size_t retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_usage_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_iMalloc_post_shutdown(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_post_shutdown_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.post_shutdown(); + } + if( HPMHooks.count.HP_iMalloc_post_shutdown_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_iMalloc_init_messages(void) { + int hIndex = 0; + if( HPMHooks.count.HP_iMalloc_init_messages_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_iMalloc_init_messages_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.iMalloc.init_messages(); + } + if( HPMHooks.count.HP_iMalloc_init_messages_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_iMalloc_init_messages_post[hIndex].func; + postHookFunc(); + } + } + return; +} /* map */ void HP_map_zone_init(void) { int hIndex = 0; @@ -39295,6 +42066,248 @@ void HP_map_zone_clear_single(struct map_zone_data *zone) { } return; } +/* mapindex */ +int HP_mapindex_init(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_mapindex_init_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_init_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.init(); + } + if( HPMHooks.count.HP_mapindex_init_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_init_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_mapindex_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_mapindex_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapindex.final(); + } + if( HPMHooks.count.HP_mapindex_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_mapindex_addmap(int index, const char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_mapindex_addmap_pre ) { + int (*preHookFunc) (int *index, const char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_addmap_pre[hIndex].func; + retVal___ = preHookFunc(&index, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.addmap(index, name); + } + if( HPMHooks.count.HP_mapindex_addmap_post ) { + int (*postHookFunc) (int retVal___, int *index, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_addmap_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &index, name); + } + } + return retVal___; +} +void HP_mapindex_removemap(int index) { + int hIndex = 0; + if( HPMHooks.count.HP_mapindex_removemap_pre ) { + void (*preHookFunc) (int *index); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_removemap_pre[hIndex].func; + preHookFunc(&index); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapindex.removemap(index); + } + if( HPMHooks.count.HP_mapindex_removemap_post ) { + void (*postHookFunc) (int *index); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_removemap_post[hIndex].func; + postHookFunc(&index); + } + } + return; +} +const char* HP_mapindex_getmapname(const char *string, char *output) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_mapindex_getmapname_pre ) { + const char* (*preHookFunc) (const char *string, char *output); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_getmapname_pre[hIndex].func; + retVal___ = preHookFunc(string, output); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.getmapname(string, output); + } + if( HPMHooks.count.HP_mapindex_getmapname_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *string, char *output); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_getmapname_post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, output); + } + } + return retVal___; +} +const char* HP_mapindex_getmapname_ext(const char *string, char *output) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_mapindex_getmapname_ext_pre ) { + const char* (*preHookFunc) (const char *string, char *output); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_pre[hIndex].func; + retVal___ = preHookFunc(string, output); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.getmapname_ext(string, output); + } + if( HPMHooks.count.HP_mapindex_getmapname_ext_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *string, char *output); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, output); + } + } + return retVal___; +} +unsigned short HP_mapindex_name2id(const char *p1) { + int hIndex = 0; + unsigned short retVal___ = 0; + if( HPMHooks.count.HP_mapindex_name2id_pre ) { + unsigned short (*preHookFunc) (const char *p1); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_name2id_pre[hIndex].func; + retVal___ = preHookFunc(p1); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.name2id(p1); + } + if( HPMHooks.count.HP_mapindex_name2id_post ) { + unsigned short (*postHookFunc) (unsigned short retVal___, const char *p1); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_name2id_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p1); + } + } + return retVal___; +} +const char* HP_mapindex_id2name(uint16 id, const char *file, int line, const char *func) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_mapindex_id2name_pre ) { + const char* (*preHookFunc) (uint16 *id, const char *file, int *line, const char *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_id2name_pre[hIndex].func; + retVal___ = preHookFunc(&id, file, &line, func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.id2name(id, file, line, func); + } + if( HPMHooks.count.HP_mapindex_id2name_post ) { + const char* (*postHookFunc) (const char* retVal___, uint16 *id, const char *file, int *line, const char *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_id2name_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &id, file, &line, func); + } + } + return retVal___; +} +bool HP_mapindex_check_default(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_mapindex_check_default_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_check_default_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_mapindex_check_default_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapindex.check_default(); + } + if( HPMHooks.count.HP_mapindex_check_default_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_check_default_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_mapindex_check_default_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} /* mapit */ struct s_mapiterator* HP_mapit_alloc(enum e_mapitflags flags, enum bl_type types) { int hIndex = 0; @@ -45999,6 +49012,33 @@ int HP_npc_secure_timeout_timer(int tid, int64 tick, int id, intptr_t data) { } return retVal___; } +/* nullpo */ +void HP_nullpo_assert_report(const char *file, int line, const char *func, const char *targetname, const char *title) { + int hIndex = 0; + if( HPMHooks.count.HP_nullpo_assert_report_pre ) { + void (*preHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_nullpo_assert_report_pre[hIndex].func; + preHookFunc(file, &line, func, targetname, title); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.nullpo.assert_report(file, line, func, targetname, title); + } + if( HPMHooks.count.HP_nullpo_assert_report_post ) { + void (*postHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_nullpo_assert_report_post[hIndex].func; + postHookFunc(file, &line, func, targetname, title); + } + } + return; +} /* party */ void HP_party_init(bool minimal) { int hIndex = 0; @@ -50271,14 +53311,14 @@ int HP_pc_equipitem(struct map_session_data *sd, int n, int req_pos) { } return retVal___; } -void HP_pc_equipitem_pos(struct map_session_data *sd, struct item_data *id, int pos) { +void HP_pc_equipitem_pos(struct map_session_data *sd, struct item_data *id, int n, int pos) { int hIndex = 0; if( HPMHooks.count.HP_pc_equipitem_pos_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item_data *id, int *pos); + void (*preHookFunc) (struct map_session_data *sd, struct item_data *id, int *n, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_equipitem_pos_pre[hIndex].func; - preHookFunc(sd, id, &pos); + preHookFunc(sd, id, &n, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50286,13 +53326,13 @@ void HP_pc_equipitem_pos(struct map_session_data *sd, struct item_data *id, int } } { - HPMHooks.source.pc.equipitem_pos(sd, id, pos); + HPMHooks.source.pc.equipitem_pos(sd, id, n, pos); } if( HPMHooks.count.HP_pc_equipitem_pos_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct item_data *id, int *pos); + void (*postHookFunc) (struct map_session_data *sd, struct item_data *id, int *n, int *pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_equipitem_pos_post[hIndex].func; - postHookFunc(sd, id, &pos); + postHookFunc(sd, id, &n, &pos); } } return; @@ -55686,6 +58726,58 @@ void HP_script_run(struct script_code *rootscript, int pos, int rid, int oid) { } return; } +void HP_script_run_npc(struct script_code *rootscript, int pos, int rid, int oid) { + int hIndex = 0; + if( HPMHooks.count.HP_script_run_npc_pre ) { + void (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_npc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_run_npc_pre[hIndex].func; + preHookFunc(rootscript, &pos, &rid, &oid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.script.run_npc(rootscript, pos, rid, oid); + } + if( HPMHooks.count.HP_script_run_npc_post ) { + void (*postHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_npc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_run_npc_post[hIndex].func; + postHookFunc(rootscript, &pos, &rid, &oid); + } + } + return; +} +void HP_script_run_pet(struct script_code *rootscript, int pos, int rid, int oid) { + int hIndex = 0; + if( HPMHooks.count.HP_script_run_pet_pre ) { + void (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_pet_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_run_pet_pre[hIndex].func; + preHookFunc(rootscript, &pos, &rid, &oid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.script.run_pet(rootscript, pos, rid, oid); + } + if( HPMHooks.count.HP_script_run_pet_post ) { + void (*postHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_pet_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_run_pet_post[hIndex].func; + postHookFunc(rootscript, &pos, &rid, &oid); + } + } + return; +} void HP_script_run_main(struct script_state *st) { int hIndex = 0; if( HPMHooks.count.HP_script_run_main_pre ) { @@ -58915,6 +62007,84 @@ void HP_script_parser_clean_leftovers(void) { } return; } +void HP_script_run_use_script(struct map_session_data *sd, struct item_data *data, int oid) { + int hIndex = 0; + if( HPMHooks.count.HP_script_run_use_script_pre ) { + void (*preHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_use_script_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_run_use_script_pre[hIndex].func; + preHookFunc(sd, data, &oid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.script.run_use_script(sd, data, oid); + } + if( HPMHooks.count.HP_script_run_use_script_post ) { + void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_use_script_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_run_use_script_post[hIndex].func; + postHookFunc(sd, data, &oid); + } + } + return; +} +void HP_script_run_item_equip_script(struct map_session_data *sd, struct item_data *data, int oid) { + int hIndex = 0; + if( HPMHooks.count.HP_script_run_item_equip_script_pre ) { + void (*preHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_equip_script_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_run_item_equip_script_pre[hIndex].func; + preHookFunc(sd, data, &oid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.script.run_item_equip_script(sd, data, oid); + } + if( HPMHooks.count.HP_script_run_item_equip_script_post ) { + void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_equip_script_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_run_item_equip_script_post[hIndex].func; + postHookFunc(sd, data, &oid); + } + } + return; +} +void HP_script_run_item_unequip_script(struct map_session_data *sd, struct item_data *data, int oid) { + int hIndex = 0; + if( HPMHooks.count.HP_script_run_item_unequip_script_pre ) { + void (*preHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_unequip_script_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_run_item_unequip_script_pre[hIndex].func; + preHookFunc(sd, data, &oid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.script.run_item_unequip_script(sd, data, oid); + } + if( HPMHooks.count.HP_script_run_item_unequip_script_post ) { + void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_unequip_script_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_run_item_unequip_script_post[hIndex].func; + postHookFunc(sd, data, &oid); + } + } + return; +} /* searchstore */ bool HP_searchstore_open(struct map_session_data *sd, unsigned int uses, unsigned short effect) { int hIndex = 0; @@ -59180,6 +62350,118 @@ bool HP_searchstore_result(struct map_session_data *sd, unsigned int store_id, i } return retVal___; } +/* showmsg */ +void HP_showmsg_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.init(); + } + if( HPMHooks.count.HP_showmsg_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_showmsg_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.final(); + } + if( HPMHooks.count.HP_showmsg_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_showmsg_clearScreen(void) { + int hIndex = 0; + if( HPMHooks.count.HP_showmsg_clearScreen_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_showmsg_clearScreen_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.showmsg.clearScreen(); + } + if( HPMHooks.count.HP_showmsg_clearScreen_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_showmsg_clearScreen_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_showmsg_showMessageV(const char *string, va_list ap) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_showmsg_showMessageV_pre ) { + int (*preHookFunc) (const char *string, va_list ap); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_pre; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + preHookFunc = HPMHooks.list.HP_showmsg_showMessageV_pre[hIndex].func; + retVal___ = preHookFunc(string, ap___copy); + va_end(ap___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list ap___copy; va_copy(ap___copy, ap); + retVal___ = HPMHooks.source.showmsg.showMessageV(string, ap___copy); + va_end(ap___copy); + } + if( HPMHooks.count.HP_showmsg_showMessageV_post ) { + int (*postHookFunc) (int retVal___, const char *string, va_list ap); + for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_post; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + postHookFunc = HPMHooks.list.HP_showmsg_showMessageV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, ap___copy); + va_end(ap___copy); + } + } + return retVal___; +} /* skill */ int HP_skill_init(bool minimal) { int hIndex = 0; @@ -65154,6 +68436,1624 @@ void HP_skill_get_requirement_unknown(struct status_change *sc, struct map_sessi } return; } +/* sockt */ +void HP_sockt_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.init(); + } + if( HPMHooks.count.HP_sockt_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sockt_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.final(); + } + if( HPMHooks.count.HP_sockt_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +int HP_sockt_perform(int next) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_perform_pre ) { + int (*preHookFunc) (int *next); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_perform_pre[hIndex].func; + retVal___ = preHookFunc(&next); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.perform(next); + } + if( HPMHooks.count.HP_sockt_perform_post ) { + int (*postHookFunc) (int retVal___, int *next); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_perform_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &next); + } + } + return retVal___; +} +void HP_sockt_datasync(int fd, bool send) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_datasync_pre ) { + void (*preHookFunc) (int *fd, bool *send); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_datasync_pre[hIndex].func; + preHookFunc(&fd, &send); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.datasync(fd, send); + } + if( HPMHooks.count.HP_sockt_datasync_post ) { + void (*postHookFunc) (int *fd, bool *send); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_datasync_post[hIndex].func; + postHookFunc(&fd, &send); + } + } + return; +} +int HP_sockt_make_listen_bind(uint32 ip, uint16 port) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_make_listen_bind_pre ) { + int (*preHookFunc) (uint32 *ip, uint16 *port); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_pre[hIndex].func; + retVal___ = preHookFunc(&ip, &port); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.make_listen_bind(ip, port); + } + if( HPMHooks.count.HP_sockt_make_listen_bind_post ) { + int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, &port); + } + } + return retVal___; +} +int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_make_connection_pre ) { + int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_make_connection_pre[hIndex].func; + retVal___ = preHookFunc(&ip, &port, opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.make_connection(ip, port, opt); + } + if( HPMHooks.count.HP_sockt_make_connection_post ) { + int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port, struct hSockOpt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_make_connection_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, &port, opt); + } + } + return retVal___; +} +int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_size) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_realloc_fifo_pre ) { + int (*preHookFunc) (int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &rfifo_size, &wfifo_size); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.realloc_fifo(fd, rfifo_size, wfifo_size); + } + if( HPMHooks.count.HP_sockt_realloc_fifo_post ) { + int (*postHookFunc) (int retVal___, int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &rfifo_size, &wfifo_size); + } + } + return retVal___; +} +int HP_sockt_realloc_writefifo(int fd, size_t addition) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_realloc_writefifo_pre ) { + int (*preHookFunc) (int *fd, size_t *addition); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &addition); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.realloc_writefifo(fd, addition); + } + if( HPMHooks.count.HP_sockt_realloc_writefifo_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *addition); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &addition); + } + } + return retVal___; +} +int HP_sockt_wfifoset(int fd, size_t len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_wfifoset_pre ) { + int (*preHookFunc) (int *fd, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_wfifoset_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.wfifoset(fd, len); + } + if( HPMHooks.count.HP_sockt_wfifoset_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &len); + } + } + return retVal___; +} +int HP_sockt_rfifoskip(int fd, size_t len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_rfifoskip_pre ) { + int (*preHookFunc) (int *fd, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_rfifoskip_pre[hIndex].func; + retVal___ = preHookFunc(&fd, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len); + } + if( HPMHooks.count.HP_sockt_rfifoskip_post ) { + int (*postHookFunc) (int retVal___, int *fd, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_rfifoskip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd, &len); + } + } + return retVal___; +} +void HP_sockt_close(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_close_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_close_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.close(fd); + } + if( HPMHooks.count.HP_sockt_close_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_close_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +bool HP_sockt_session_is_valid(int fd) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_session_is_valid_pre ) { + bool (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_session_is_valid_pre[hIndex].func; + retVal___ = preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.session_is_valid(fd); + } + if( HPMHooks.count.HP_sockt_session_is_valid_post ) { + bool (*postHookFunc) (bool retVal___, int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_session_is_valid_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd); + } + } + return retVal___; +} +bool HP_sockt_session_is_active(int fd) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_session_is_active_pre ) { + bool (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_session_is_active_pre[hIndex].func; + retVal___ = preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.session_is_active(fd); + } + if( HPMHooks.count.HP_sockt_session_is_active_post ) { + bool (*postHookFunc) (bool retVal___, int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_session_is_active_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &fd); + } + } + return retVal___; +} +void HP_sockt_flush(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_flush_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_flush_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.flush(fd); + } + if( HPMHooks.count.HP_sockt_flush_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_flush_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +void HP_sockt_flush_fifos(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_flush_fifos_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_flush_fifos_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.flush_fifos(); + } + if( HPMHooks.count.HP_sockt_flush_fifos_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_flush_fifos_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sockt_set_nonblocking(int fd, unsigned long yes) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_set_nonblocking_pre ) { + void (*preHookFunc) (int *fd, unsigned long *yes); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_pre[hIndex].func; + preHookFunc(&fd, &yes); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.set_nonblocking(fd, yes); + } + if( HPMHooks.count.HP_sockt_set_nonblocking_post ) { + void (*postHookFunc) (int *fd, unsigned long *yes); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_post[hIndex].func; + postHookFunc(&fd, &yes); + } + } + return; +} +void HP_sockt_set_defaultparse(ParseFunc defaultparse) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_set_defaultparse_pre ) { + void (*preHookFunc) (ParseFunc *defaultparse); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_pre[hIndex].func; + preHookFunc(&defaultparse); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.set_defaultparse(defaultparse); + } + if( HPMHooks.count.HP_sockt_set_defaultparse_post ) { + void (*postHookFunc) (ParseFunc *defaultparse); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_post[hIndex].func; + postHookFunc(&defaultparse); + } + } + return; +} +uint32 HP_sockt_host2ip(const char *hostname) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_host2ip_pre ) { + uint32 (*preHookFunc) (const char *hostname); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_host2ip_pre[hIndex].func; + retVal___ = preHookFunc(hostname); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.host2ip(hostname); + } + if( HPMHooks.count.HP_sockt_host2ip_post ) { + uint32 (*postHookFunc) (uint32 retVal___, const char *hostname); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_host2ip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, hostname); + } + } + return retVal___; +} +const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sockt_ip2str_pre ) { + const char* (*preHookFunc) (uint32 *ip, char *ip_str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_ip2str_pre[hIndex].func; + retVal___ = preHookFunc(&ip, ip_str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.ip2str(ip, ip_str); + } + if( HPMHooks.count.HP_sockt_ip2str_post ) { + const char* (*postHookFunc) (const char* retVal___, uint32 *ip, char *ip_str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_ip2str_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, ip_str); + } + } + return retVal___; +} +uint32 HP_sockt_str2ip(const char *ip_str) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_str2ip_pre ) { + uint32 (*preHookFunc) (const char *ip_str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_str2ip_pre[hIndex].func; + retVal___ = preHookFunc(ip_str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.str2ip(ip_str); + } + if( HPMHooks.count.HP_sockt_str2ip_post ) { + uint32 (*postHookFunc) (uint32 retVal___, const char *ip_str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_str2ip_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ip_str); + } + } + return retVal___; +} +uint16 HP_sockt_ntows(uint16 netshort) { + int hIndex = 0; + uint16 retVal___ = 0; + if( HPMHooks.count.HP_sockt_ntows_pre ) { + uint16 (*preHookFunc) (uint16 *netshort); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_ntows_pre[hIndex].func; + retVal___ = preHookFunc(&netshort); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.ntows(netshort); + } + if( HPMHooks.count.HP_sockt_ntows_post ) { + uint16 (*postHookFunc) (uint16 retVal___, uint16 *netshort); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_ntows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &netshort); + } + } + return retVal___; +} +int HP_sockt_getips(uint32 *ips, int max) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_getips_pre ) { + int (*preHookFunc) (uint32 *ips, int *max); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_getips_pre[hIndex].func; + retVal___ = preHookFunc(ips, &max); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.getips(ips, max); + } + if( HPMHooks.count.HP_sockt_getips_post ) { + int (*postHookFunc) (int retVal___, uint32 *ips, int *max); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_getips_post[hIndex].func; + retVal___ = postHookFunc(retVal___, ips, &max); + } + } + return retVal___; +} +void HP_sockt_eof(int fd) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_eof_pre ) { + void (*preHookFunc) (int *fd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_eof_pre[hIndex].func; + preHookFunc(&fd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.eof(fd); + } + if( HPMHooks.count.HP_sockt_eof_post ) { + void (*postHookFunc) (int *fd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_eof_post[hIndex].func; + postHookFunc(&fd); + } + } + return; +} +uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_sockt_lan_subnet_check_pre ) { + uint32 (*preHookFunc) (uint32 *ip, struct s_subnet *info); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip, info); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.lan_subnet_check(ip, info); + } + if( HPMHooks.count.HP_sockt_lan_subnet_check_post ) { + uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip, struct s_subnet *info); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip, info); + } + } + return retVal___; +} +bool HP_sockt_allowed_ip_check(uint32 ip) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_allowed_ip_check_pre ) { + bool (*preHookFunc) (uint32 *ip); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip); + } + if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) { + bool (*postHookFunc) (bool retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip); + } + } + return retVal___; +} +bool HP_sockt_trusted_ip_check(uint32 ip) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sockt_trusted_ip_check_pre ) { + bool (*preHookFunc) (uint32 *ip); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_pre[hIndex].func; + retVal___ = preHookFunc(&ip); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip); + } + if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) { + bool (*postHookFunc) (bool retVal___, uint32 *ip); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &ip); + } + } + return retVal___; +} +int HP_sockt_net_config_read_sub(config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) { + int (*preHookFunc) (config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_pre[hIndex].func; + retVal___ = preHookFunc(t, list, count, filename, groupname); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sockt.net_config_read_sub(t, list, count, filename, groupname); + } + if( HPMHooks.count.HP_sockt_net_config_read_sub_post ) { + int (*postHookFunc) (int retVal___, config_setting_t *t, struct s_subnet **list, int *count, const char *filename, const char *groupname); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_post[hIndex].func; + retVal___ = postHookFunc(retVal___, t, list, count, filename, groupname); + } + } + return retVal___; +} +void HP_sockt_net_config_read(const char *filename) { + int hIndex = 0; + if( HPMHooks.count.HP_sockt_net_config_read_pre ) { + void (*preHookFunc) (const char *filename); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sockt_net_config_read_pre[hIndex].func; + preHookFunc(filename); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sockt.net_config_read(filename); + } + if( HPMHooks.count.HP_sockt_net_config_read_post ) { + void (*postHookFunc) (const char *filename); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sockt_net_config_read_post[hIndex].func; + postHookFunc(filename); + } + } + return; +} +/* SQL */ +int HP_SQL_Connect(Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_Connect_pre ) { + int (*preHookFunc) (Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Connect_pre[hIndex].func; + retVal___ = preHookFunc(self, user, passwd, host, &port, db); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db); + } + if( HPMHooks.count.HP_SQL_Connect_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Connect_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, user, passwd, host, &port, db); + } + } + return retVal___; +} +int HP_SQL_GetTimeout(Sql *self, uint32 *out_timeout) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetTimeout_pre ) { + int (*preHookFunc) (Sql *self, uint32 *out_timeout); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetTimeout_pre[hIndex].func; + retVal___ = preHookFunc(self, out_timeout); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetTimeout(self, out_timeout); + } + if( HPMHooks.count.HP_SQL_GetTimeout_post ) { + int (*postHookFunc) (int retVal___, Sql *self, uint32 *out_timeout); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetTimeout_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_timeout); + } + } + return retVal___; +} +int HP_SQL_GetColumnNames(Sql *self, const char *table, char *out_buf, size_t buf_len, char sep) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) { + int (*preHookFunc) (Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_pre[hIndex].func; + retVal___ = preHookFunc(self, table, out_buf, &buf_len, &sep); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep); + } + if( HPMHooks.count.HP_SQL_GetColumnNames_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, table, out_buf, &buf_len, &sep); + } + } + return retVal___; +} +int HP_SQL_SetEncoding(Sql *self, const char *encoding) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_SetEncoding_pre ) { + int (*preHookFunc) (Sql *self, const char *encoding); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_SetEncoding_pre[hIndex].func; + retVal___ = preHookFunc(self, encoding); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.SetEncoding(self, encoding); + } + if( HPMHooks.count.HP_SQL_SetEncoding_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *encoding); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_SetEncoding_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, encoding); + } + } + return retVal___; +} +int HP_SQL_Ping(Sql *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_Ping_pre ) { + int (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Ping_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Ping(self); + } + if( HPMHooks.count.HP_SQL_Ping_post ) { + int (*postHookFunc) (int retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Ping_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +size_t HP_SQL_EscapeString(Sql *self, char *out_to, const char *from) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_EscapeString_pre ) { + size_t (*preHookFunc) (Sql *self, char *out_to, const char *from); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_EscapeString_pre[hIndex].func; + retVal___ = preHookFunc(self, out_to, from); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.EscapeString(self, out_to, from); + } + if( HPMHooks.count.HP_SQL_EscapeString_post ) { + size_t (*postHookFunc) (size_t retVal___, Sql *self, char *out_to, const char *from); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_EscapeString_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_to, from); + } + } + return retVal___; +} +size_t HP_SQL_EscapeStringLen(Sql *self, char *out_to, const char *from, size_t from_len) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) { + size_t (*preHookFunc) (Sql *self, char *out_to, const char *from, size_t *from_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_pre[hIndex].func; + retVal___ = preHookFunc(self, out_to, from, &from_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len); + } + if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) { + size_t (*postHookFunc) (size_t retVal___, Sql *self, char *out_to, const char *from, size_t *from_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, out_to, from, &from_len); + } + } + return retVal___; +} +int HP_SQL_QueryV(Sql *self, const char *query, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_QueryV_pre ) { + int (*preHookFunc) (Sql *self, const char *query, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_SQL_QueryV_pre[hIndex].func; + retVal___ = preHookFunc(self, query, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.SQL.QueryV(self, query, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_SQL_QueryV_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *query, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_SQL_QueryV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_SQL_QueryStr(Sql *self, const char *query) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_QueryStr_pre ) { + int (*preHookFunc) (Sql *self, const char *query); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_QueryStr_pre[hIndex].func; + retVal___ = preHookFunc(self, query); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.QueryStr(self, query); + } + if( HPMHooks.count.HP_SQL_QueryStr_post ) { + int (*postHookFunc) (int retVal___, Sql *self, const char *query); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_QueryStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query); + } + } + return retVal___; +} +uint64 HP_SQL_LastInsertId(Sql *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_LastInsertId_pre ) { + uint64 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_LastInsertId_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.LastInsertId(self); + } + if( HPMHooks.count.HP_SQL_LastInsertId_post ) { + uint64 (*postHookFunc) (uint64 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_LastInsertId_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint32 HP_SQL_NumColumns(Sql *self) { + int hIndex = 0; + uint32 retVal___ = 0; + if( HPMHooks.count.HP_SQL_NumColumns_pre ) { + uint32 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NumColumns_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NumColumns(self); + } + if( HPMHooks.count.HP_SQL_NumColumns_post ) { + uint32 (*postHookFunc) (uint32 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NumColumns_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint64 HP_SQL_NumRows(Sql *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_NumRows_pre ) { + uint64 (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NumRows_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NumRows(self); + } + if( HPMHooks.count.HP_SQL_NumRows_post ) { + uint64 (*postHookFunc) (uint64 retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NumRows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_NextRow(Sql *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_NextRow_pre ) { + int (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_NextRow_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.NextRow(self); + } + if( HPMHooks.count.HP_SQL_NextRow_post ) { + int (*postHookFunc) (int retVal___, Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_NextRow_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_GetData(Sql *self, size_t col, char **out_buf, size_t *out_len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_GetData_pre ) { + int (*preHookFunc) (Sql *self, size_t *col, char **out_buf, size_t *out_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_GetData_pre[hIndex].func; + retVal___ = preHookFunc(self, &col, out_buf, out_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len); + } + if( HPMHooks.count.HP_SQL_GetData_post ) { + int (*postHookFunc) (int retVal___, Sql *self, size_t *col, char **out_buf, size_t *out_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_GetData_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &col, out_buf, out_len); + } + } + return retVal___; +} +void HP_SQL_FreeResult(Sql *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_FreeResult_pre ) { + void (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_FreeResult_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.FreeResult(self); + } + if( HPMHooks.count.HP_SQL_FreeResult_post ) { + void (*postHookFunc) (Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_FreeResult_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_ShowDebug_(Sql *self, const char *debug_file, const unsigned long debug_line) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_ShowDebug__pre ) { + void (*preHookFunc) (Sql *self, const char *debug_file, const unsigned long *debug_line); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_ShowDebug__pre[hIndex].func; + preHookFunc(self, debug_file, &debug_line); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line); + } + if( HPMHooks.count.HP_SQL_ShowDebug__post ) { + void (*postHookFunc) (Sql *self, const char *debug_file, const unsigned long *debug_line); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_ShowDebug__post[hIndex].func; + postHookFunc(self, debug_file, &debug_line); + } + } + return; +} +void HP_SQL_Free(Sql *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_Free_pre ) { + void (*preHookFunc) (Sql *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Free_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.Free(self); + } + if( HPMHooks.count.HP_SQL_Free_post ) { + void (*postHookFunc) (Sql *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Free_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +struct Sql* HP_SQL_Malloc(void) { + int hIndex = 0; + struct Sql* retVal___ = NULL; + if( HPMHooks.count.HP_SQL_Malloc_pre ) { + struct Sql* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_Malloc_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.Malloc(); + } + if( HPMHooks.count.HP_SQL_Malloc_post ) { + struct Sql* (*postHookFunc) (struct Sql* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_Malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +struct SqlStmt* HP_SQL_StmtMalloc(Sql *sql) { + int hIndex = 0; + struct SqlStmt* retVal___ = NULL; + if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) { + struct SqlStmt* (*preHookFunc) (Sql *sql); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_pre[hIndex].func; + retVal___ = preHookFunc(sql); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtMalloc(sql); + } + if( HPMHooks.count.HP_SQL_StmtMalloc_post ) { + struct SqlStmt* (*postHookFunc) (struct SqlStmt* retVal___, Sql *sql); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___, sql); + } + } + return retVal___; +} +int HP_SQL_StmtPrepareV(SqlStmt *self, const char *query, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) { + int (*preHookFunc) (SqlStmt *self, const char *query, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_pre[hIndex].func; + retVal___ = preHookFunc(self, query, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.SQL.StmtPrepareV(self, query, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_SQL_StmtPrepareV_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, const char *query, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_SQL_StmtPrepareStr(SqlStmt *self, const char *query) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) { + int (*preHookFunc) (SqlStmt *self, const char *query); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_pre[hIndex].func; + retVal___ = preHookFunc(self, query); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtPrepareStr(self, query); + } + if( HPMHooks.count.HP_SQL_StmtPrepareStr_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, const char *query); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, query); + } + } + return retVal___; +} +size_t HP_SQL_StmtNumParams(SqlStmt *self) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) { + size_t (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumParams(self); + } + if( HPMHooks.count.HP_SQL_StmtNumParams_post ) { + size_t (*postHookFunc) (size_t retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtBindParam(SqlStmt *self, size_t idx, SqlDataType buffer_type, void *buffer, size_t buffer_len) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) { + int (*preHookFunc) (SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_pre[hIndex].func; + retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len); + } + if( HPMHooks.count.HP_SQL_StmtBindParam_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len); + } + } + return retVal___; +} +int HP_SQL_StmtExecute(SqlStmt *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtExecute_pre ) { + int (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtExecute_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtExecute(self); + } + if( HPMHooks.count.HP_SQL_StmtExecute_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtExecute_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +uint64 HP_SQL_StmtLastInsertId(SqlStmt *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) { + uint64 (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtLastInsertId(self); + } + if( HPMHooks.count.HP_SQL_StmtLastInsertId_post ) { + uint64 (*postHookFunc) (uint64 retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +size_t HP_SQL_StmtNumColumns(SqlStmt *self) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) { + size_t (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumColumns(self); + } + if( HPMHooks.count.HP_SQL_StmtNumColumns_post ) { + size_t (*postHookFunc) (size_t retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtBindColumn(SqlStmt *self, size_t idx, SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) { + int (*preHookFunc) (SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_pre[hIndex].func; + retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtBindColumn(self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); + } + if( HPMHooks.count.HP_SQL_StmtBindColumn_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self, size_t *idx, SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + } + } + return retVal___; +} +uint64 HP_SQL_StmtNumRows(SqlStmt *self) { + int hIndex = 0; + uint64 retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) { + uint64 (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNumRows(self); + } + if( HPMHooks.count.HP_SQL_StmtNumRows_post ) { + uint64 (*postHookFunc) (uint64 retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +int HP_SQL_StmtNextRow(SqlStmt *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) { + int (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.SQL.StmtNextRow(self); + } + if( HPMHooks.count.HP_SQL_StmtNextRow_post ) { + int (*postHookFunc) (int retVal___, SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +void HP_SQL_StmtFreeResult(SqlStmt *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) { + void (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtFreeResult(self); + } + if( HPMHooks.count.HP_SQL_StmtFreeResult_post ) { + void (*postHookFunc) (SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_StmtFree(SqlStmt *self) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtFree_pre ) { + void (*preHookFunc) (SqlStmt *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtFree_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtFree(self); + } + if( HPMHooks.count.HP_SQL_StmtFree_post ) { + void (*postHookFunc) (SqlStmt *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtFree_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_SQL_StmtShowDebug_(SqlStmt *self, const char *debug_file, const unsigned long debug_line) { + int hIndex = 0; + if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) { + void (*preHookFunc) (SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__pre[hIndex].func; + preHookFunc(self, debug_file, &debug_line); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line); + } + if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) { + void (*postHookFunc) (SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__post[hIndex].func; + postHookFunc(self, debug_file, &debug_line); + } + } + return; +} /* status */ int HP_status_init(bool minimal) { int hIndex = 0; @@ -66453,6 +71353,32 @@ int HP_status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt opt) } return retVal___; } +void HP_status_calc_pc_additional(struct map_session_data *sd, enum e_status_calc_opt opt) { + int hIndex = 0; + if( HPMHooks.count.HP_status_calc_pc_additional_pre ) { + void (*preHookFunc) (struct map_session_data *sd, enum e_status_calc_opt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc_additional_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_status_calc_pc_additional_pre[hIndex].func; + preHookFunc(sd, &opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.status.calc_pc_additional(sd, opt); + } + if( HPMHooks.count.HP_status_calc_pc_additional_post ) { + void (*postHookFunc) (struct map_session_data *sd, enum e_status_calc_opt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc_additional_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_status_calc_pc_additional_post[hIndex].func; + postHookFunc(sd, &opt); + } + } + return; +} int HP_status_calc_homunculus_(struct homun_data *hd, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; @@ -68476,6 +73402,1682 @@ int HP_storage_reconnect_sub(DBKey key, DBData *data, va_list ap) { } return retVal___; } +/* StrBuf */ +StringBuf* HP_StrBuf_Malloc(void) { + int hIndex = 0; + StringBuf* retVal___ = NULL; + if( HPMHooks.count.HP_StrBuf_Malloc_pre ) { + StringBuf* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Malloc_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Malloc(); + } + if( HPMHooks.count.HP_StrBuf_Malloc_post ) { + StringBuf* (*postHookFunc) (StringBuf* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Malloc_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_StrBuf_Init(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Init_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Init_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Init(self); + } + if( HPMHooks.count.HP_StrBuf_Init_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Init_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +int HP_StrBuf_Vprintf(StringBuf *self, const char *fmt, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Vprintf_pre ) { + int (*preHookFunc) (StringBuf *self, const char *fmt, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_pre[hIndex].func; + retVal___ = preHookFunc(self, fmt, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.StrBuf.Vprintf(self, fmt, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_StrBuf_Vprintf_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const char *fmt, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, fmt, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_StrBuf_Append(StringBuf *self, const StringBuf *sbuf) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Append_pre ) { + int (*preHookFunc) (StringBuf *self, const StringBuf *sbuf); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Append_pre[hIndex].func; + retVal___ = preHookFunc(self, sbuf); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Append(self, sbuf); + } + if( HPMHooks.count.HP_StrBuf_Append_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const StringBuf *sbuf); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Append_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, sbuf); + } + } + return retVal___; +} +int HP_StrBuf_AppendStr(StringBuf *self, const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_AppendStr_pre ) { + int (*preHookFunc) (StringBuf *self, const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_pre[hIndex].func; + retVal___ = preHookFunc(self, str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.AppendStr(self, str); + } + if( HPMHooks.count.HP_StrBuf_AppendStr_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self, str); + } + } + return retVal___; +} +int HP_StrBuf_Length(StringBuf *self) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_StrBuf_Length_pre ) { + int (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Length_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Length(self); + } + if( HPMHooks.count.HP_StrBuf_Length_post ) { + int (*postHookFunc) (int retVal___, StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Length_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +char* HP_StrBuf_Value(StringBuf *self) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_StrBuf_Value_pre ) { + char* (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Value_pre[hIndex].func; + retVal___ = preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.StrBuf.Value(self); + } + if( HPMHooks.count.HP_StrBuf_Value_post ) { + char* (*postHookFunc) (char* retVal___, StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Value_post[hIndex].func; + retVal___ = postHookFunc(retVal___, self); + } + } + return retVal___; +} +void HP_StrBuf_Clear(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Clear_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Clear_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Clear(self); + } + if( HPMHooks.count.HP_StrBuf_Clear_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Clear_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_StrBuf_Destroy(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Destroy_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Destroy_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Destroy(self); + } + if( HPMHooks.count.HP_StrBuf_Destroy_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Destroy_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +void HP_StrBuf_Free(StringBuf *self) { + int hIndex = 0; + if( HPMHooks.count.HP_StrBuf_Free_pre ) { + void (*preHookFunc) (StringBuf *self); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_StrBuf_Free_pre[hIndex].func; + preHookFunc(self); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.StrBuf.Free(self); + } + if( HPMHooks.count.HP_StrBuf_Free_post ) { + void (*postHookFunc) (StringBuf *self); + for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_StrBuf_Free_post[hIndex].func; + postHookFunc(self); + } + } + return; +} +/* strlib */ +char* HP_strlib_jstrescape(char *pt) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_jstrescape_pre ) { + char* (*preHookFunc) (char *pt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jstrescape_pre[hIndex].func; + retVal___ = preHookFunc(pt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jstrescape(pt); + } + if( HPMHooks.count.HP_strlib_jstrescape_post ) { + char* (*postHookFunc) (char* retVal___, char *pt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jstrescape_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt); + } + } + return retVal___; +} +char* HP_strlib_jstrescapecpy(char *pt, const char *spt) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_jstrescapecpy_pre ) { + char* (*preHookFunc) (char *pt, const char *spt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_pre[hIndex].func; + retVal___ = preHookFunc(pt, spt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jstrescapecpy(pt, spt); + } + if( HPMHooks.count.HP_strlib_jstrescapecpy_post ) { + char* (*postHookFunc) (char* retVal___, char *pt, const char *spt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt, spt); + } + } + return retVal___; +} +int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_jmemescapecpy_pre ) { + int (*preHookFunc) (char *pt, const char *spt, int *size); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_pre[hIndex].func; + retVal___ = preHookFunc(pt, spt, &size); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.jmemescapecpy(pt, spt, size); + } + if( HPMHooks.count.HP_strlib_jmemescapecpy_post ) { + int (*postHookFunc) (int retVal___, char *pt, const char *spt, int *size); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_post[hIndex].func; + retVal___ = postHookFunc(retVal___, pt, spt, &size); + } + } + return retVal___; +} +int HP_strlib_remove_control_chars_(char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_remove_control_chars__pre ) { + int (*preHookFunc) (char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.remove_control_chars_(str); + } + if( HPMHooks.count.HP_strlib_remove_control_chars__post ) { + int (*postHookFunc) (int retVal___, char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_trim_(char *str) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_trim__pre ) { + char* (*preHookFunc) (char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_trim__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.trim_(str); + } + if( HPMHooks.count.HP_strlib_trim__post ) { + char* (*postHookFunc) (char* retVal___, char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_trim__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_normalize_name_(char *str, const char *delims) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_normalize_name__pre ) { + char* (*preHookFunc) (char *str, const char *delims); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_normalize_name__pre[hIndex].func; + retVal___ = preHookFunc(str, delims); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.normalize_name_(str, delims); + } + if( HPMHooks.count.HP_strlib_normalize_name__post ) { + char* (*postHookFunc) (char* retVal___, char *str, const char *delims); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_normalize_name__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, delims); + } + } + return retVal___; +} +const char* HP_strlib_stristr_(const char *haystack, const char *needle) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_stristr__pre ) { + const char* (*preHookFunc) (const char *haystack, const char *needle); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_stristr__pre[hIndex].func; + retVal___ = preHookFunc(haystack, needle); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.stristr_(haystack, needle); + } + if( HPMHooks.count.HP_strlib_stristr__post ) { + const char* (*postHookFunc) (const char* retVal___, const char *haystack, const char *needle); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_stristr__post[hIndex].func; + retVal___ = postHookFunc(retVal___, haystack, needle); + } + } + return retVal___; +} +size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_strlib_strnlen__pre ) { + size_t (*preHookFunc) (const char *string, size_t *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strnlen__pre[hIndex].func; + retVal___ = preHookFunc(string, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strnlen_(string, maxlen); + } + if( HPMHooks.count.HP_strlib_strnlen__post ) { + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strnlen__post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, &maxlen); + } + } + return retVal___; +} +char* HP_strlib_strtok_r_(char *s1, const char *s2, char **lasts) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_strtok_r__pre ) { + char* (*preHookFunc) (char *s1, const char *s2, char **lasts); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strtok_r__pre[hIndex].func; + retVal___ = preHookFunc(s1, s2, lasts); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strtok_r_(s1, s2, lasts); + } + if( HPMHooks.count.HP_strlib_strtok_r__post ) { + char* (*postHookFunc) (char* retVal___, char *s1, const char *s2, char **lasts); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strtok_r__post[hIndex].func; + retVal___ = postHookFunc(retVal___, s1, s2, lasts); + } + } + return retVal___; +} +int HP_strlib_e_mail_check_(char *email) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_e_mail_check__pre ) { + int (*preHookFunc) (char *email); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_e_mail_check__pre[hIndex].func; + retVal___ = preHookFunc(email); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.e_mail_check_(email); + } + if( HPMHooks.count.HP_strlib_e_mail_check__post ) { + int (*postHookFunc) (int retVal___, char *email); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_e_mail_check__post[hIndex].func; + retVal___ = postHookFunc(retVal___, email); + } + } + return retVal___; +} +int HP_strlib_config_switch_(const char *str) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_config_switch__pre ) { + int (*preHookFunc) (const char *str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_config_switch__pre[hIndex].func; + retVal___ = preHookFunc(str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.config_switch_(str); + } + if( HPMHooks.count.HP_strlib_config_switch__post ) { + int (*postHookFunc) (int retVal___, const char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_config_switch__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str); + } + } + return retVal___; +} +char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { + int hIndex = 0; + char* retVal___ = NULL; + if( HPMHooks.count.HP_strlib_safestrncpy__pre ) { + char* (*preHookFunc) (char *dst, const char *src, size_t *n); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_safestrncpy__pre[hIndex].func; + retVal___ = preHookFunc(dst, src, &n); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.safestrncpy_(dst, src, n); + } + if( HPMHooks.count.HP_strlib_safestrncpy__post ) { + char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t *n); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_safestrncpy__post[hIndex].func; + retVal___ = postHookFunc(retVal___, dst, src, &n); + } + } + return retVal___; +} +size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_strlib_safestrnlen__pre ) { + size_t (*preHookFunc) (const char *string, size_t *maxlen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_safestrnlen__pre[hIndex].func; + retVal___ = preHookFunc(string, &maxlen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.safestrnlen_(string, maxlen); + } + if( HPMHooks.count.HP_strlib_safestrnlen__post ) { + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_safestrnlen__post[hIndex].func; + retVal___ = postHookFunc(retVal___, string, &maxlen); + } + } + return retVal___; +} +int HP_strlib_strline_(const char *str, size_t pos) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_strlib_strline__pre ) { + int (*preHookFunc) (const char *str, size_t *pos); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_strline__pre[hIndex].func; + retVal___ = preHookFunc(str, &pos); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.strline_(str, pos); + } + if( HPMHooks.count.HP_strlib_strline__post ) { + int (*postHookFunc) (int retVal___, const char *str, size_t *pos); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_strline__post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &pos); + } + } + return retVal___; +} +bool HP_strlib_bin2hex_(char *output, unsigned char *input, size_t count) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_strlib_bin2hex__pre ) { + bool (*preHookFunc) (char *output, unsigned char *input, size_t *count); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_strlib_bin2hex__pre[hIndex].func; + retVal___ = preHookFunc(output, input, &count); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count); + } + if( HPMHooks.count.HP_strlib_bin2hex__post ) { + bool (*postHookFunc) (bool retVal___, char *output, unsigned char *input, size_t *count); + for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_strlib_bin2hex__post[hIndex].func; + retVal___ = postHookFunc(retVal___, output, input, &count); + } + } + return retVal___; +} +/* sv */ +int HP_sv_parse_next(struct s_svstate *svstate) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_parse_next_pre ) { + int (*preHookFunc) (struct s_svstate *svstate); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_parse_next_pre[hIndex].func; + retVal___ = preHookFunc(svstate); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.parse_next(svstate); + } + if( HPMHooks.count.HP_sv_parse_next_post ) { + int (*postHookFunc) (int retVal___, struct s_svstate *svstate); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_parse_next_post[hIndex].func; + retVal___ = postHookFunc(retVal___, svstate); + } + } + return retVal___; +} +int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_parse_pre ) { + int (*preHookFunc) (const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_parse_pre[hIndex].func; + retVal___ = preHookFunc(str, &len, &startoff, &delim, out_pos, &npos, &opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.parse(str, len, startoff, delim, out_pos, npos, opt); + } + if( HPMHooks.count.HP_sv_parse_post ) { + int (*postHookFunc) (int retVal___, const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_parse_post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_pos, &npos, &opt); + } + } + return retVal___; +} +int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sv_split_pre ) { + int (*preHookFunc) (char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_split_pre[hIndex].func; + retVal___ = preHookFunc(str, &len, &startoff, &delim, out_fields, &nfields, &opt); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.split(str, len, startoff, delim, out_fields, nfields, opt); + } + if( HPMHooks.count.HP_sv_split_post ) { + int (*postHookFunc) (int retVal___, char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_split_post[hIndex].func; + retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_fields, &nfields, &opt); + } + } + return retVal___; +} +size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *escapes) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_sv_escape_c_pre ) { + size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len, const char *escapes); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_escape_c_pre[hIndex].func; + retVal___ = preHookFunc(out_dest, src, &len, escapes); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.escape_c(out_dest, src, len, escapes); + } + if( HPMHooks.count.HP_sv_escape_c_post ) { + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len, const char *escapes); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_escape_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, out_dest, src, &len, escapes); + } + } + return retVal___; +} +size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { + int hIndex = 0; + size_t retVal___ = 0; + if( HPMHooks.count.HP_sv_unescape_c_pre ) { + size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_unescape_c_pre[hIndex].func; + retVal___ = preHookFunc(out_dest, src, &len); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.unescape_c(out_dest, src, len); + } + if( HPMHooks.count.HP_sv_unescape_c_post ) { + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_unescape_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, out_dest, src, &len); + } + } + return retVal___; +} +const char* HP_sv_skip_escaped_c(const char *p) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sv_skip_escaped_c_pre ) { + const char* (*preHookFunc) (const char *p); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_pre[hIndex].func; + retVal___ = preHookFunc(p); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.skip_escaped_c(p); + } + if( HPMHooks.count.HP_sv_skip_escaped_c_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *p); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p); + } + } + return retVal___; +} +bool HP_sv_readdb(const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sv_readdb_pre ) { + bool (*preHookFunc) (const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sv_readdb_pre[hIndex].func; + retVal___ = preHookFunc(directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sv.readdb(directory, filename, delim, mincols, maxcols, maxrows, parseproc); + } + if( HPMHooks.count.HP_sv_readdb_post ) { + bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sv_readdb_post[hIndex].func; + retVal___ = postHookFunc(retVal___, directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + } + } + return retVal___; +} +/* sysinfo */ +int HP_sysinfo_getpagesize(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_getpagesize_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.getpagesize(); + } + if( HPMHooks.count.HP_sysinfo_getpagesize_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_platform(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_platform_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_platform_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.platform(); + } + if( HPMHooks.count.HP_sysinfo_platform_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_platform_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_osversion(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_osversion_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_osversion_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.osversion(); + } + if( HPMHooks.count.HP_sysinfo_osversion_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_osversion_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_cpu(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_cpu_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cpu_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cpu(); + } + if( HPMHooks.count.HP_sysinfo_cpu_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cpu_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_sysinfo_cpucores(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_cpucores_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cpucores_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cpucores(); + } + if( HPMHooks.count.HP_sysinfo_cpucores_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cpucores_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_arch(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_arch_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_arch_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.arch(); + } + if( HPMHooks.count.HP_sysinfo_arch_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_arch_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +bool HP_sysinfo_is64bit(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sysinfo_is64bit_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_is64bit_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.is64bit(); + } + if( HPMHooks.count.HP_sysinfo_is64bit_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_is64bit_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_compiler(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_compiler_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_compiler_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.compiler(); + } + if( HPMHooks.count.HP_sysinfo_compiler_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_compiler_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_cflags(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_cflags_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_cflags_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.cflags(); + } + if( HPMHooks.count.HP_sysinfo_cflags_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_cflags_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcstype(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcstype_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcstype_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcstype(); + } + if( HPMHooks.count.HP_sysinfo_vcstype_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcstype_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_sysinfo_vcstypeid(void) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_sysinfo_vcstypeid_pre ) { + int (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcstypeid(); + } + if( HPMHooks.count.HP_sysinfo_vcstypeid_post ) { + int (*postHookFunc) (int retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcsrevision_src(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcsrevision_src_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcsrevision_src(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_src_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +const char* HP_sysinfo_vcsrevision_scripts(void) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre ) { + const char* (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.vcsrevision_scripts(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post ) { + const char* (*postHookFunc) (const char* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_sysinfo_vcsrevision_reload(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.vcsrevision_reload(); + } + if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_post[hIndex].func; + postHookFunc(); + } + } + return; +} +bool HP_sysinfo_is_superuser(void) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_sysinfo_is_superuser_pre ) { + bool (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.sysinfo.is_superuser(); + } + if( HPMHooks.count.HP_sysinfo_is_superuser_post ) { + bool (*postHookFunc) (bool retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +void HP_sysinfo_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.init(); + } + if( HPMHooks.count.HP_sysinfo_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_sysinfo_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_sysinfo_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_sysinfo_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.sysinfo.final(); + } + if( HPMHooks.count.HP_sysinfo_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_sysinfo_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +/* timer */ +int64 HP_timer_gettick(void) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_gettick_pre ) { + int64 (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_gettick_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.gettick(); + } + if( HPMHooks.count.HP_timer_gettick_post ) { + int64 (*postHookFunc) (int64 retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_gettick_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int64 HP_timer_gettick_nocache(void) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_gettick_nocache_pre ) { + int64 (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_gettick_nocache_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.gettick_nocache(); + } + if( HPMHooks.count.HP_timer_gettick_nocache_post ) { + int64 (*postHookFunc) (int64 retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_gettick_nocache_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_pre ) { + int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_pre[hIndex].func; + retVal___ = preHookFunc(&tick, &func, &id, &data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add(tick, func, id, data); + } + if( HPMHooks.count.HP_timer_add_post ) { + int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data); + } + } + return retVal___; +} +int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int interval) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_interval_pre ) { + int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_interval_pre[hIndex].func; + retVal___ = preHookFunc(&tick, &func, &id, &data, &interval); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add_interval(tick, func, id, data, interval); + } + if( HPMHooks.count.HP_timer_add_interval_post ) { + int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_interval_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data, &interval); + } + } + return retVal___; +} +const struct TimerData* HP_timer_get(int tid) { + int hIndex = 0; + const struct TimerData* retVal___ = NULL; + if( HPMHooks.count.HP_timer_get_pre ) { + const struct TimerData* (*preHookFunc) (int *tid); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_get_pre[hIndex].func; + retVal___ = preHookFunc(&tid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.get(tid); + } + if( HPMHooks.count.HP_timer_get_post ) { + const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int *tid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_get_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid); + } + } + return retVal___; +} +int HP_timer_delete(int tid, TimerFunc func) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_delete_pre ) { + int (*preHookFunc) (int *tid, TimerFunc *func); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_delete_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &func); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.delete(tid, func); + } + if( HPMHooks.count.HP_timer_delete_post ) { + int (*postHookFunc) (int retVal___, int *tid, TimerFunc *func); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_delete_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &func); + } + } + return retVal___; +} +int64 HP_timer_addtick(int tid, int64 tick) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_addtick_pre ) { + int64 (*preHookFunc) (int *tid, int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_addtick_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.addtick(tid, tick); + } + if( HPMHooks.count.HP_timer_addtick_post ) { + int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_addtick_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &tick); + } + } + return retVal___; +} +int64 HP_timer_settick(int tid, int64 tick) { + int hIndex = 0; + int64 retVal___ = 0; + if( HPMHooks.count.HP_timer_settick_pre ) { + int64 (*preHookFunc) (int *tid, int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_settick_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.settick(tid, tick); + } + if( HPMHooks.count.HP_timer_settick_post ) { + int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_settick_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tid, &tick); + } + } + return retVal___; +} +int HP_timer_add_func_list(TimerFunc func, char *name) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_add_func_list_pre ) { + int (*preHookFunc) (TimerFunc *func, char *name); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_add_func_list_pre[hIndex].func; + retVal___ = preHookFunc(&func, name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.add_func_list(func, name); + } + if( HPMHooks.count.HP_timer_add_func_list_post ) { + int (*postHookFunc) (int retVal___, TimerFunc *func, char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_add_func_list_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &func, name); + } + } + return retVal___; +} +unsigned long HP_timer_get_uptime(void) { + int hIndex = 0; + unsigned long retVal___ = 0; + if( HPMHooks.count.HP_timer_get_uptime_pre ) { + unsigned long (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_get_uptime_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.get_uptime(); + } + if( HPMHooks.count.HP_timer_get_uptime_post ) { + unsigned long (*postHookFunc) (unsigned long retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_get_uptime_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +int HP_timer_perform(int64 tick) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_timer_perform_pre ) { + int (*preHookFunc) (int64 *tick); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_perform_pre[hIndex].func; + retVal___ = preHookFunc(&tick); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.timer.perform(tick); + } + if( HPMHooks.count.HP_timer_perform_post ) { + int (*postHookFunc) (int retVal___, int64 *tick); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_perform_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &tick); + } + } + return retVal___; +} +void HP_timer_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_timer_init_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.timer.init(); + } + if( HPMHooks.count.HP_timer_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_timer_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_timer_final_pre ) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_timer_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.timer.final(); + } + if( HPMHooks.count.HP_timer_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_timer_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} /* trade */ void HP_trade_request(struct map_session_data *sd, struct map_session_data *target_sd) { int hIndex = 0; diff --git a/src/plugins/HPMHooking/HPMHooking_map.sources.inc b/src/plugins/HPMHooking/HPMHooking_map.sources.inc index d7d7ac1ac..024febdf8 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.sources.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.sources.inc @@ -4,6 +4,7 @@ // NOTE: This file was auto-generated and should never be manually edited, // as it will get overwritten. +memcpy(&HPMHooks.source.HCache, HCache, sizeof(struct HCache_interface)); memcpy(&HPMHooks.source.atcommand, atcommand, sizeof(struct atcommand_interface)); memcpy(&HPMHooks.source.battle, battle, sizeof(struct battle_interface)); memcpy(&HPMHooks.source.bg, bg, sizeof(struct battleground_interface)); @@ -12,6 +13,10 @@ memcpy(&HPMHooks.source.channel, channel, sizeof(struct channel_interface)); memcpy(&HPMHooks.source.chat, chat, sizeof(struct chat_interface)); memcpy(&HPMHooks.source.chrif, chrif, sizeof(struct chrif_interface)); memcpy(&HPMHooks.source.clif, clif, sizeof(struct clif_interface)); +memcpy(&HPMHooks.source.cmdline, cmdline, sizeof(struct cmdline_interface)); +memcpy(&HPMHooks.source.console, console, sizeof(struct console_interface)); +memcpy(&HPMHooks.source.core, core, sizeof(struct core_interface)); +memcpy(&HPMHooks.source.DB, DB, sizeof(struct db_interface)); memcpy(&HPMHooks.source.duel, duel, sizeof(struct duel_interface)); memcpy(&HPMHooks.source.elemental, elemental, sizeof(struct elemental_interface)); memcpy(&HPMHooks.source.guild, guild, sizeof(struct guild_interface)); @@ -21,14 +26,18 @@ memcpy(&HPMHooks.source.instance, instance, sizeof(struct instance_interface)); memcpy(&HPMHooks.source.intif, intif, sizeof(struct intif_interface)); memcpy(&HPMHooks.source.ircbot, ircbot, sizeof(struct irc_bot_interface)); memcpy(&HPMHooks.source.itemdb, itemdb, sizeof(struct itemdb_interface)); +memcpy(&HPMHooks.source.libconfig, libconfig, sizeof(struct libconfig_interface)); memcpy(&HPMHooks.source.logs, logs, sizeof(struct log_interface)); memcpy(&HPMHooks.source.mail, mail, sizeof(struct mail_interface)); +memcpy(&HPMHooks.source.iMalloc, iMalloc, sizeof(struct malloc_interface)); memcpy(&HPMHooks.source.map, map, sizeof(struct map_interface)); +memcpy(&HPMHooks.source.mapindex, mapindex, sizeof(struct mapindex_interface)); memcpy(&HPMHooks.source.mapit, mapit, sizeof(struct mapit_interface)); memcpy(&HPMHooks.source.mapreg, mapreg, sizeof(struct mapreg_interface)); memcpy(&HPMHooks.source.mercenary, mercenary, sizeof(struct mercenary_interface)); memcpy(&HPMHooks.source.mob, mob, sizeof(struct mob_interface)); memcpy(&HPMHooks.source.npc, npc, sizeof(struct npc_interface)); +memcpy(&HPMHooks.source.nullpo, nullpo, sizeof(struct nullpo_interface)); memcpy(&HPMHooks.source.party, party, sizeof(struct party_interface)); memcpy(&HPMHooks.source.path, path, sizeof(struct path_interface)); memcpy(&HPMHooks.source.pcg, pcg, sizeof(struct pc_groups_interface)); @@ -37,9 +46,17 @@ memcpy(&HPMHooks.source.pet, pet, sizeof(struct pet_interface)); memcpy(&HPMHooks.source.quest, quest, sizeof(struct quest_interface)); memcpy(&HPMHooks.source.script, script, sizeof(struct script_interface)); memcpy(&HPMHooks.source.searchstore, searchstore, sizeof(struct searchstore_interface)); +memcpy(&HPMHooks.source.showmsg, showmsg, sizeof(struct showmsg_interface)); memcpy(&HPMHooks.source.skill, skill, sizeof(struct skill_interface)); +memcpy(&HPMHooks.source.sockt, sockt, sizeof(struct socket_interface)); +memcpy(&HPMHooks.source.SQL, SQL, sizeof(struct sql_interface)); memcpy(&HPMHooks.source.status, status, sizeof(struct status_interface)); memcpy(&HPMHooks.source.storage, storage, sizeof(struct storage_interface)); +memcpy(&HPMHooks.source.StrBuf, StrBuf, sizeof(struct stringbuf_interface)); +memcpy(&HPMHooks.source.strlib, strlib, sizeof(struct strlib_interface)); +memcpy(&HPMHooks.source.sv, sv, sizeof(struct sv_interface)); +memcpy(&HPMHooks.source.sysinfo, sysinfo, sizeof(struct sysinfo_interface)); +memcpy(&HPMHooks.source.timer, timer, sizeof(struct timer_interface)); memcpy(&HPMHooks.source.trade, trade, sizeof(struct trade_interface)); memcpy(&HPMHooks.source.unit, unit, sizeof(struct unit_interface)); memcpy(&HPMHooks.source.vending, vending, sizeof(struct vending_interface)); diff --git a/src/plugins/db2sql.c b/src/plugins/db2sql.c index 2741ce468..ff2feefa0 100644 --- a/src/plugins/db2sql.c +++ b/src/plugins/db2sql.c @@ -3,7 +3,7 @@ #include "config/core.h" -#include "common/HPMi.h" +#include "common/hercules.h" #include "common/cbasetypes.h" #include "common/conf.h" #include "common/malloc.h" @@ -141,7 +141,7 @@ int db2sql(config_setting_t *entry, int n, const char *source) { StrBuf->Printf(&buf, "'%u',", it->flag.bindonequip?1:0); // forceserial - StrBuf->Printf(&buf, "'%u',", it->flag.force_serial?1:0); + StrBuf->Printf(&buf, "'%u',", it->flag.force_serial?1:0); // buyingstore StrBuf->Printf(&buf, "'%u',", it->flag.buyingstore?1:0); @@ -357,21 +357,14 @@ CMDLINEARG(db2sql) map->minimal = torun = true; return true; } -HPExport void server_preinit (void) { - SQL = GET_SYMBOL("SQL"); - itemdb = GET_SYMBOL("itemdb"); - map = GET_SYMBOL("map"); - strlib = GET_SYMBOL("strlib"); - iMalloc = GET_SYMBOL("iMalloc"); - libconfig = GET_SYMBOL("libconfig"); - StrBuf = GET_SYMBOL("StrBuf"); +HPExport void server_preinit(void) { addArg("--db2sql",false,db2sql,NULL); } -HPExport void plugin_init (void) { +HPExport void plugin_init(void) { addCPCommand("server:tools:db2sql",db2sql); } -HPExport void server_online (void) { +HPExport void server_online(void) { if( torun ) do_db2sql(); } diff --git a/src/plugins/dbghelpplug.c b/src/plugins/dbghelpplug.c index 6ed16d7a6..b5f1fe485 100644 --- a/src/plugins/dbghelpplug.c +++ b/src/plugins/dbghelpplug.c @@ -5,8 +5,9 @@ // Ported from eAthena Dev Team's version @ http://eathena-project.googlecode.com/svn/trunk/src/plugins/dbghelpplug.c // Currently supported dbghelp 5.1 +#include "common/hercules.h" + #include "common/sysinfo.h" -#include "common/HPMi.h" #include "common/HPMDataCheck.h" @@ -108,8 +109,6 @@ typedef enum _SymTag { */ #endif /* _NO_CVCONST_H */ -struct sysinfo_interface *sysinfo; - ///////////////////////////////////////////////////////////////////// // dbghelp function prototypes // @@ -1800,7 +1799,6 @@ static LPTOP_LEVEL_EXCEPTION_FILTER previousFilter; **/ HPExport void plugin_init (void) { previousFilter = SetUnhandledExceptionFilter(Dhp__UnhandledExceptionFilter); - sysinfo = GET_SYMBOL("sysinfo"); } /** diff --git a/src/plugins/sample.c b/src/plugins/sample.c index b034775b0..275edb129 100644 --- a/src/plugins/sample.c +++ b/src/plugins/sample.c @@ -2,7 +2,7 @@ // See the LICENSE file // Sample Hercules Plugin -#include "common/HPMi.h" +#include "common/hercules.h" /* Should always be the first Hercules file included! (if you don't make it first, you won't be able to use interfaces) */ #include "common/malloc.h" #include "common/mmo.h" #include "common/socket.h" @@ -11,7 +11,7 @@ #include "map/pc.h" #include "map/script.h" -#include "common/HPMDataCheck.h" /* should always be the last file included! (if you don't make it last, it'll intentionally break compile time) */ +#include "common/HPMDataCheck.h" /* should always be the last Hercules file included! (if you don't make it last, it'll intentionally break compile time) */ #include <stdio.h> #include <stdlib.h> @@ -44,15 +44,15 @@ struct sample_data_struct { /* cmd 0xf3 - it is a client-server existent id, for clif_parse_GlobalMessage */ /* in this sample we do nothing and simply redirect */ void sample_packet0f3(int fd) { - struct map_session_data *sd = session[fd]->session_data; + struct map_session_data *sd = sockt->session[fd]->session_data; struct sample_data_struct *data; if( !sd ) return;/* socket didn't fully log-in? this packet shouldn't do anything then! */ ShowInfo("sample_packet0f3: Hello World! received 0xf3 for '%s', redirecting!\n",sd->status.name); - /* sample usage of appending data to a socket_data (session[]) entry */ - if( !(data = getFromSession(session[fd],0)) ) { + /* sample usage of appending data to a socket_data (sockt->session[]) entry */ + if( !(data = getFromSession(sockt->session[fd],0)) ) { CREATE(data,struct sample_data_struct,1); data->lastMSGPosition.map = sd->status.last_point.map; @@ -60,13 +60,13 @@ void sample_packet0f3(int fd) { data->lastMSGPosition.y = sd->status.last_point.y; data->someNumber = rand()%777; - ShowInfo("Created Appended session[] data, %d %d %d %d\n",data->lastMSGPosition.map,data->lastMSGPosition.x,data->lastMSGPosition.y,data->someNumber); - addToSession(session[fd],data,0,true); + ShowInfo("Created Appended sockt->session[] data, %d %d %d %d\n",data->lastMSGPosition.map,data->lastMSGPosition.x,data->lastMSGPosition.y,data->someNumber); + addToSession(sockt->session[fd],data,0,true); } else { - ShowInfo("Existent Appended session[] data, %d %d %d %d\n",data->lastMSGPosition.map,data->lastMSGPosition.x,data->lastMSGPosition.y,data->someNumber); + ShowInfo("Existent Appended sockt->session[] data, %d %d %d %d\n",data->lastMSGPosition.map,data->lastMSGPosition.x,data->lastMSGPosition.y,data->someNumber); if( rand()%4 == 2 ) { - ShowInfo("Removing Appended session[] data\n"); - removeFromSession(session[fd],0); + ShowInfo("Removing Appended sockt->session[] data\n"); + removeFromSession(sockt->session[fd],0); } } @@ -117,34 +117,15 @@ void parse_my_setting(const char *val) { } /* run when server starts */ HPExport void plugin_init (void) { - char *server_type; - char *server_name; + ShowInfo("Server type is "); - /* core vars */ - server_type = GET_SYMBOL("SERVER_TYPE"); - server_name = GET_SYMBOL("SERVER_NAME"); - - /* core interfaces */ - iMalloc = GET_SYMBOL("iMalloc"); - - /* map-server interfaces */ - script = GET_SYMBOL("script"); - clif = GET_SYMBOL("clif"); - pc = GET_SYMBOL("pc"); - strlib = GET_SYMBOL("strlib"); - - /* session[] */ - session = GET_SYMBOL("session"); - - ShowInfo ("Server type is "); - - switch (*server_type) { - case SERVER_TYPE_LOGIN: printf ("Login Server\n"); break; - case SERVER_TYPE_CHAR: printf ("Char Server\n"); break; + switch (SERVER_TYPE) { + case SERVER_TYPE_LOGIN: printf("Login Server\n"); break; + case SERVER_TYPE_CHAR: printf("Char Server\n"); break; case SERVER_TYPE_MAP: printf ("Map Server\n"); break; } - ShowInfo ("I'm being run from the '%s' filename\n", server_name); + ShowInfo("I'm being run from the '%s' filename\n", SERVER_NAME); /* addAtcommand("command-key",command-function) tells map server to call ACMD(sample) when "sample" command is used */ /* - it will print a warning when used on a non-map-server plugin */ diff --git a/src/plugins/script_mapquit.c b/src/plugins/script_mapquit.c new file mode 100644 index 000000000..8ed108f82 --- /dev/null +++ b/src/plugins/script_mapquit.c @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2014 Hercules Dev Team + * Base author: Haru <haru@dotalux.com> + * + * This plugin 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 + * (at your option) any later version. + * + * This plugin 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 this plugin. If not, see <http://www.gnu.org/licenses/>. + */ + +/// mapquit() script command + +#include "common/hercules.h" +#include "map/map.h" +#include "map/script.h" + +#include "common/HPMDataCheck.h" + +HPExport struct hplugin_info pinfo = { + "script_mapquit", // Plugin name + SERVER_TYPE_MAP, // Which server types this plugin works with? + "0.1", // Plugin version + HPM_VERSION, // HPM Version (don't change, macro is automatically updated) +}; + +BUILDIN(mapquit) { + if (script_hasdata(st, 2)) { + map->retval = script_getnum(st, 2); + } + map->do_shutdown(); + return true; +} +HPExport void server_preinit(void) { +} +HPExport void plugin_init(void) { + addScriptCommand("mapquit", "?", mapquit); +} |