diff options
Diffstat (limited to 'src/plugins/HPMHooking/HPMHooking_login.Hooks.inc')
| -rw-r--r-- | src/plugins/HPMHooking/HPMHooking_login.Hooks.inc | 1451 |
1 files changed, 721 insertions, 730 deletions
diff --git a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc index 91909b819..3c31062b8 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc @@ -54,11 +54,11 @@ 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); + 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); + retVal___ = preHookFunc(&file); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -81,11 +81,11 @@ 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); + 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); + retVal___ = preHookFunc(&file, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -161,11 +161,11 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, 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); + 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); + retVal___ = preHookFunc(&pluginID, &name, &shortname, &func, &help, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -176,10 +176,10 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, 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); + 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); + retVal___ = postHookFunc(retVal___, pluginID, name, shortname, func, help, options); } } return retVal___; @@ -188,11 +188,11 @@ 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); + 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); + retVal___ = preHookFunc(&argc, &argv, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -203,10 +203,10 @@ int HP_cmdline_exec(int argc, char **argv, unsigned int options) { 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); + 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); + retVal___ = postHookFunc(retVal___, argc, argv, options); } } return retVal___; @@ -215,11 +215,11 @@ 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); + 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); + retVal___ = preHookFunc(&name, ¤t_arg, &argc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -230,10 +230,10 @@ bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { 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); + 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); + retVal___ = postHookFunc(retVal___, name, current_arg, argc); } } return retVal___; @@ -242,11 +242,11 @@ 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); + 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); + retVal___ = preHookFunc(&arg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -417,10 +417,10 @@ enum DBOptions HP_DB_fix_options(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.fix_options(type, options); } if( HPMHooks.count.HP_DB_fix_options_post ) { - enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType *type, enum DBOptions *options); + enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType type, enum 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); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -444,10 +444,10 @@ DBComparator HP_DB_default_cmp(enum DBType type) { retVal___ = HPMHooks.source.DB.default_cmp(type); } if( HPMHooks.count.HP_DB_default_cmp_post ) { - DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType *type); + DBComparator (*postHookFunc) (DBComparator retVal___, enum 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); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -471,10 +471,10 @@ DBHasher HP_DB_default_hash(enum DBType type) { retVal___ = HPMHooks.source.DB.default_hash(type); } if( HPMHooks.count.HP_DB_default_hash_post ) { - DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType *type); + DBHasher (*postHookFunc) (DBHasher retVal___, enum 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); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -498,10 +498,10 @@ DBReleaser HP_DB_default_release(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.default_release(type, options); } if( HPMHooks.count.HP_DB_default_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType *type, enum DBOptions *options); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType type, enum 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); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -525,10 +525,10 @@ DBReleaser HP_DB_custom_release(enum DBReleaseOption which) { retVal___ = HPMHooks.source.DB.custom_release(which); } if( HPMHooks.count.HP_DB_custom_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption *which); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption 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); + retVal___ = postHookFunc(retVal___, which); } } return retVal___; @@ -537,11 +537,11 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT int hIndex = 0; struct DBMap* retVal___ = NULL; if( HPMHooks.count.HP_DB_alloc_pre ) { - struct DBMap* (*preHookFunc) (const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*preHookFunc) (const char **file, const char **func, int *line, enum DBType *type, enum 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); + retVal___ = preHookFunc(&file, &func, &line, &type, &options, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -552,18 +552,17 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen); } if( HPMHooks.count.HP_DB_alloc_post ) { - struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int line, enum DBType type, enum 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); + retVal___ = postHookFunc(retVal___, file, func, line, type, options, maxlen); } } return retVal___; } union DBKey HP_DB_i2key(int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2key_pre ) { union DBKey (*preHookFunc) (int *key); *HPMforce_return = false; @@ -580,18 +579,17 @@ union DBKey HP_DB_i2key(int key) { retVal___ = HPMHooks.source.DB.i2key(key); } if( HPMHooks.count.HP_DB_i2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int *key); + union DBKey (*postHookFunc) (union 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); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui2key(unsigned int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2key_pre ) { union DBKey (*preHookFunc) (unsigned int *key); *HPMforce_return = false; @@ -608,24 +606,23 @@ union DBKey HP_DB_ui2key(unsigned int key) { retVal___ = HPMHooks.source.DB.ui2key(key); } if( HPMHooks.count.HP_DB_ui2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int *key); + union DBKey (*postHookFunc) (union 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); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_str2key(const char *key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_str2key_pre ) { - union DBKey (*preHookFunc) (const char *key); + union 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); + retVal___ = preHookFunc(&key); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -646,8 +643,7 @@ union DBKey HP_DB_str2key(const char *key) { } union DBKey HP_DB_i642key(int64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i642key_pre ) { union DBKey (*preHookFunc) (int64 *key); *HPMforce_return = false; @@ -664,18 +660,17 @@ union DBKey HP_DB_i642key(int64 key) { retVal___ = HPMHooks.source.DB.i642key(key); } if( HPMHooks.count.HP_DB_i642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int64 *key); + union DBKey (*postHookFunc) (union 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); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui642key(uint64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui642key_pre ) { union DBKey (*preHookFunc) (uint64 *key); *HPMforce_return = false; @@ -692,18 +687,17 @@ union DBKey HP_DB_ui642key(uint64 key) { retVal___ = HPMHooks.source.DB.ui642key(key); } if( HPMHooks.count.HP_DB_ui642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, uint64 *key); + union DBKey (*postHookFunc) (union 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); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } struct DBData HP_DB_i2data(int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2data_pre ) { struct DBData (*preHookFunc) (int *data); *HPMforce_return = false; @@ -720,18 +714,17 @@ struct DBData HP_DB_i2data(int data) { retVal___ = HPMHooks.source.DB.i2data(data); } if( HPMHooks.count.HP_DB_i2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, int *data); + struct DBData (*postHookFunc) (struct 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); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ui2data(unsigned int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2data_pre ) { struct DBData (*preHookFunc) (unsigned int *data); *HPMforce_return = false; @@ -748,24 +741,23 @@ struct DBData HP_DB_ui2data(unsigned int data) { retVal___ = HPMHooks.source.DB.ui2data(data); } if( HPMHooks.count.HP_DB_ui2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int *data); + struct DBData (*postHookFunc) (struct 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); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ptr2data(void *data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ptr2data_pre ) { - struct DBData (*preHookFunc) (void *data); + struct 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); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -788,11 +780,11 @@ int HP_DB_data2i(struct DBData *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_DB_data2i_pre ) { - int (*preHookFunc) (struct DBData *data); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -815,11 +807,11 @@ unsigned int HP_DB_data2ui(struct DBData *data) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_DB_data2ui_pre ) { - unsigned int (*preHookFunc) (struct DBData *data); + unsigned int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -842,11 +834,11 @@ void* HP_DB_data2ptr(struct DBData *data) { int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_DB_data2ptr_pre ) { - void* (*preHookFunc) (struct DBData *data); + void* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -988,10 +980,10 @@ void HP_lclif_connection_error(int fd, uint8 error) { HPMHooks.source.lclif.connection_error(fd, error); } if( HPMHooks.count.HP_lclif_connection_error_post ) { - void (*postHookFunc) (int *fd, uint8 *error); + void (*postHookFunc) (int fd, uint8 error); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_connection_error_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_connection_error_post[hIndex].func; - postHookFunc(&fd, &error); + postHookFunc(fd, error); } } return; @@ -1000,11 +992,11 @@ bool HP_lclif_server_list(struct login_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_lclif_server_list_pre ) { - bool (*preHookFunc) (struct login_session_data *sd); + bool (*preHookFunc) (struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_server_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_lclif_server_list_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1041,10 +1033,10 @@ void HP_lclif_auth_failed(int fd, time_t ban, uint32 error) { HPMHooks.source.lclif.auth_failed(fd, ban, error); } if( HPMHooks.count.HP_lclif_auth_failed_post ) { - void (*postHookFunc) (int *fd, time_t *ban, uint32 *error); + void (*postHookFunc) (int fd, time_t ban, uint32 error); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_auth_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_auth_failed_post[hIndex].func; - postHookFunc(&fd, &ban, &error); + postHookFunc(fd, ban, error); } } return; @@ -1067,10 +1059,10 @@ void HP_lclif_login_error(int fd, uint8 error) { HPMHooks.source.lclif.login_error(fd, error); } if( HPMHooks.count.HP_lclif_login_error_post ) { - void (*postHookFunc) (int *fd, uint8 *error); + void (*postHookFunc) (int fd, uint8 error); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_login_error_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_login_error_post[hIndex].func; - postHookFunc(&fd, &error); + postHookFunc(fd, error); } } return; @@ -1078,11 +1070,11 @@ void HP_lclif_login_error(int fd, uint8 error) { void HP_lclif_coding_key(int fd, struct login_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_lclif_coding_key_pre ) { - void (*preHookFunc) (int *fd, struct login_session_data *sd); + void (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_coding_key_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_lclif_coding_key_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1093,10 +1085,10 @@ void HP_lclif_coding_key(int fd, struct login_session_data *sd) { HPMHooks.source.lclif.coding_key(fd, sd); } if( HPMHooks.count.HP_lclif_coding_key_post ) { - void (*postHookFunc) (int *fd, struct login_session_data *sd); + void (*postHookFunc) (int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_coding_key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_coding_key_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -1120,10 +1112,10 @@ const struct login_packet_db* HP_lclif_packet(int16 packet_id) { retVal___ = HPMHooks.source.lclif.packet(packet_id); } if( HPMHooks.count.HP_lclif_packet_post ) { - const struct login_packet_db* (*postHookFunc) (const struct login_packet_db* retVal___, int16 *packet_id); + const struct login_packet_db* (*postHookFunc) (const struct login_packet_db* retVal___, int16 packet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_packet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_packet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &packet_id); + retVal___ = postHookFunc(retVal___, packet_id); } } return retVal___; @@ -1132,11 +1124,11 @@ enum parsefunc_rcode HP_lclif_parse_packet(const struct login_packet_db *lpd, in int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_lclif_parse_packet_pre ) { - enum parsefunc_rcode (*preHookFunc) (const struct login_packet_db *lpd, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (const struct login_packet_db **lpd, int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_parse_packet_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_lclif_parse_packet_pre[hIndex].func; - retVal___ = preHookFunc(lpd, &fd, sd); + retVal___ = preHookFunc(&lpd, &fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1147,10 +1139,10 @@ enum parsefunc_rcode HP_lclif_parse_packet(const struct login_packet_db *lpd, in retVal___ = HPMHooks.source.lclif.parse_packet(lpd, fd, sd); } if( HPMHooks.count.HP_lclif_parse_packet_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, const struct login_packet_db *lpd, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, const struct login_packet_db *lpd, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_parse_packet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_parse_packet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, lpd, &fd, sd); + retVal___ = postHookFunc(retVal___, lpd, fd, sd); } } return retVal___; @@ -1174,10 +1166,10 @@ int HP_lclif_parse(int fd) { retVal___ = HPMHooks.source.lclif.parse(fd); } if( HPMHooks.count.HP_lclif_parse_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -1213,11 +1205,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_sub(int fd, struct login_session_data int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_sub_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_sub_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1228,10 +1220,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_sub(int fd, struct login_session_data retVal___ = HPMHooks.source.PRIV__lclif.parse_sub(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_sub_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1240,11 +1232,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED(int fd, struct int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1255,10 +1247,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED(int fd, struct retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_CONNECT_INFO_CHANGED(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1267,11 +1259,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_EXE_HASHCHECK(int fd, struct login_ int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1282,10 +1274,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_EXE_HASHCHECK(int fd, struct login_ retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_EXE_HASHCHECK(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1294,11 +1286,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN(int fd, struct login_session_ int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1309,10 +1301,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN(int fd, struct login_session_ retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1321,11 +1313,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN2(int fd, struct login_session int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN2_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1336,10 +1328,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN2(int fd, struct login_session retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN2(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1348,11 +1340,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN3(int fd, struct login_session int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN3_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1363,10 +1355,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN3(int fd, struct login_session retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN3(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN3_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1375,11 +1367,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN4(int fd, struct login_session int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN4_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1390,10 +1382,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN4(int fd, struct login_session retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN4(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN4_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1402,11 +1394,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_PCBANG(int fd, struct login_s int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1417,10 +1409,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_PCBANG(int fd, struct login_s retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN_PCBANG(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1429,11 +1421,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_HAN(int fd, struct login_sess int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_HAN_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1444,10 +1436,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_HAN(int fd, struct login_sess retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN_HAN(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_HAN_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1456,11 +1448,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ(int fd, struct login_ int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1471,10 +1463,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ(int fd, struct login_ retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_SSO_LOGIN_REQ(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1483,11 +1475,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_REQ_HASH(int fd, struct login_sessi int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_REQ_HASH_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1498,10 +1490,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_REQ_HASH(int fd, struct login_sessi retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_REQ_HASH(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_REQ_HASH_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1510,11 +1502,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT(int fd, struct lo int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1525,10 +1517,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT(int fd, struct lo retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_CHARSERVERCONNECT(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1538,11 +1530,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_pre ) { - int (*preHookFunc) (struct config_t *config, FILE *stream); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1564,11 +1556,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { void HP_libconfig_write(const struct config_t *config, FILE *stream) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_write_pre ) { - void (*preHookFunc) (const struct config_t *config, FILE *stream); + void (*preHookFunc) (const struct 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); + preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1590,11 +1582,11 @@ void HP_libconfig_write(const struct config_t *config, FILE *stream) { void HP_libconfig_set_options(struct config_t *config, int options) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_options_pre ) { - void (*preHookFunc) (struct config_t *config, int *options); + void (*preHookFunc) (struct config_t **config, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_options_pre[hIndex].func; - preHookFunc(config, &options); + preHookFunc(&config, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1605,10 +1597,10 @@ void HP_libconfig_set_options(struct config_t *config, int options) { HPMHooks.source.libconfig.set_options(config, options); } if( HPMHooks.count.HP_libconfig_set_options_post ) { - void (*postHookFunc) (struct config_t *config, int *options); + void (*postHookFunc) (struct config_t *config, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_set_options_post[hIndex].func; - postHookFunc(config, &options); + postHookFunc(config, options); } } return; @@ -1617,11 +1609,11 @@ int HP_libconfig_get_options(const struct config_t *config) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_get_options_pre ) { - int (*preHookFunc) (const struct config_t *config); + int (*preHookFunc) (const struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_get_options_pre[hIndex].func; - retVal___ = preHookFunc(config); + retVal___ = preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1644,11 +1636,11 @@ int HP_libconfig_read_string(struct config_t *config, const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_string_pre ) { - int (*preHookFunc) (struct config_t *config, const char *str); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&config, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1671,11 +1663,11 @@ int HP_libconfig_read_file_src(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_file_src_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1698,11 +1690,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_write_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1724,11 +1716,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) (void *)) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_destructor_pre ) { - void (*preHookFunc) (struct config_t *config, void ( *destructor ) (void *)); + void (*preHookFunc) (struct 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); + preHookFunc(&config, &destructor); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1750,11 +1742,11 @@ void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) ( void HP_libconfig_set_include_dir(struct config_t *config, const char *include_dir) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) { - void (*preHookFunc) (struct config_t *config, const char *include_dir); + void (*preHookFunc) (struct 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); + preHookFunc(&config, &include_dir); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1776,11 +1768,11 @@ void HP_libconfig_set_include_dir(struct config_t *config, const char *include_d void HP_libconfig_init(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_init_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct 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); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1802,11 +1794,11 @@ void HP_libconfig_init(struct config_t *config) { void HP_libconfig_destroy(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_destroy_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct 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); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1829,11 +1821,11 @@ int HP_libconfig_setting_get_int(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1856,11 +1848,11 @@ long long HP_libconfig_setting_get_int64(const struct config_setting_t *setting) int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting); + long long (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1883,11 +1875,11 @@ double HP_libconfig_setting_get_float(const struct config_setting_t *setting) { int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting); + double (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1910,11 +1902,11 @@ int HP_libconfig_setting_get_bool(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1937,11 +1929,11 @@ const char* HP_libconfig_setting_get_string(const struct config_setting_t *setti int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting); + const char* (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1964,11 +1956,11 @@ struct config_setting_t* HP_libconfig_setting_lookup(struct config_setting_t *se int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_pre[hIndex].func; - retVal___ = preHookFunc(setting, name); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1991,11 +1983,11 @@ int HP_libconfig_setting_lookup_int(const struct config_setting_t *setting, cons int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2018,11 +2010,11 @@ int HP_libconfig_setting_lookup_int64(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, long long *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2045,11 +2037,11 @@ int HP_libconfig_setting_lookup_float(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, double *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2072,11 +2064,11 @@ int HP_libconfig_setting_lookup_bool(const struct config_setting_t *setting, con int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2099,11 +2091,11 @@ int HP_libconfig_setting_lookup_string(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, const char **value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2126,11 +2118,11 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2141,10 +2133,10 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2153,11 +2145,11 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, long long *value); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2168,10 +2160,10 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long *value); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2180,11 +2172,11 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, double *value); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2195,10 +2187,10 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double *value); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2207,11 +2199,11 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2222,10 +2214,10 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2234,11 +2226,11 @@ int HP_libconfig_setting_set_string(struct config_setting_t *setting, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, const char *value); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2261,11 +2253,11 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, short *format); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &format); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2276,10 +2268,10 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format); } if( HPMHooks.count.HP_libconfig_setting_set_format_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short *format); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, format); } } return retVal___; @@ -2288,11 +2280,11 @@ short HP_libconfig_setting_get_format(const struct config_setting_t *setting) { int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) { - short (*preHookFunc) (const struct config_setting_t *setting); + short (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2315,11 +2307,11 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2330,10 +2322,10 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in 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 struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct 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); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2342,11 +2334,11 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting, int *idx); + long long (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2357,10 +2349,10 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set 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 struct config_setting_t *setting, int *idx); + long long (*postHookFunc) (long long retVal___, const struct 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); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2369,11 +2361,11 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting, int *idx); + double (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2384,10 +2376,10 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin 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 struct config_setting_t *setting, int *idx); + double (*postHookFunc) (double retVal___, const struct 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); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2396,11 +2388,11 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2411,10 +2403,10 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i 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 struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct 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); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2423,11 +2415,11 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting, int *idx); + const char* (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2438,10 +2430,10 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * 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 struct config_setting_t *setting, int *idx); + const char* (*postHookFunc) (const char* retVal___, const struct 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); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2450,11 +2442,11 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2465,10 +2457,10 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2477,11 +2469,11 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2492,10 +2484,10 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2504,11 +2496,11 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2519,10 +2511,10 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2531,11 +2523,11 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2546,10 +2538,10 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2558,11 +2550,11 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2573,10 +2565,10 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct 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); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2585,11 +2577,11 @@ int HP_libconfig_setting_index(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_index_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2612,11 +2604,11 @@ int HP_libconfig_setting_length(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_length_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2639,11 +2631,11 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2654,10 +2646,10 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct 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); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2666,11 +2658,11 @@ struct config_setting_t* HP_libconfig_setting_get_member(const struct config_set int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2693,11 +2685,11 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_add_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&parent, &name, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2708,10 +2700,10 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type); } if( HPMHooks.count.HP_libconfig_setting_add_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct 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); + retVal___ = postHookFunc(retVal___, parent, name, type); } } return retVal___; @@ -2720,11 +2712,11 @@ int HP_libconfig_setting_remove(struct config_setting_t *parent, const char *nam int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const char *name); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&parent, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2747,11 +2739,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, unsigned int *idx); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&parent, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2762,10 +2754,10 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx); } if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int *idx); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, parent, idx); } } return retVal___; @@ -2773,11 +2765,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i void HP_libconfig_setting_set_hook(struct config_setting_t *setting, void *hook) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) { - void (*preHookFunc) (struct config_setting_t *setting, void *hook); + void (*preHookFunc) (struct 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); + preHookFunc(&setting, &hook); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2800,11 +2792,11 @@ struct config_setting_t* HP_libconfig_lookup(const struct config_t *config, cons int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_t *config, const char *filepath); + struct config_setting_t* (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&config, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2827,11 +2819,11 @@ int HP_libconfig_lookup_int(const struct config_t *config, const char *filepath, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2854,11 +2846,11 @@ int HP_libconfig_lookup_int64(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, long long *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2881,11 +2873,11 @@ int HP_libconfig_lookup_float(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_float_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, double *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2908,11 +2900,11 @@ int HP_libconfig_lookup_bool(const struct config_t *config, const char *filepath int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2935,11 +2927,11 @@ int HP_libconfig_lookup_string(const struct config_t *config, const char *filepa int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, const char **value); + int (*preHookFunc) (const struct 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); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2962,11 +2954,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_load_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *config_filename); + int (*preHookFunc) (struct config_t **config, const char **config_filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_load_file_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_load_file_pre[hIndex].func; - retVal___ = preHookFunc(config, config_filename); + retVal___ = preHookFunc(&config, &config_filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2988,11 +2980,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct 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); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3014,11 +3006,11 @@ void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const str void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct 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); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3040,11 +3032,11 @@ void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struc void HP_libconfig_setting_copy_aggregate(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct 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); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3067,11 +3059,11 @@ int HP_libconfig_setting_copy(struct config_setting_t *parent, const struct conf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_copy_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + int (*preHookFunc) (struct config_setting_t **parent, const struct 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); + retVal___ = preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3094,11 +3086,11 @@ bool HP_libconfig_setting_get_bool_real(const struct config_setting_t *setting) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_libconfig_setting_get_bool_real_pre ) { - bool (*preHookFunc) (const struct config_setting_t *setting); + bool (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3121,11 +3113,11 @@ uint32 HP_libconfig_setting_get_uint32(const struct config_setting_t *setting) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint32_pre ) { - uint32 (*preHookFunc) (const struct config_setting_t *setting); + uint32 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3148,11 +3140,11 @@ uint16 HP_libconfig_setting_get_uint16(const struct config_setting_t *setting) { int hIndex = 0; uint16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint16_pre ) { - uint16 (*preHookFunc) (const struct config_setting_t *setting); + uint16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3175,11 +3167,11 @@ int16 HP_libconfig_setting_get_int16(const struct config_setting_t *setting) { int hIndex = 0; int16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int16_pre ) { - int16 (*preHookFunc) (const struct config_setting_t *setting); + int16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3202,11 +3194,11 @@ int HP_libconfig_setting_lookup_bool_real(const struct config_setting_t *setting int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, bool *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, bool **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3229,11 +3221,11 @@ int HP_libconfig_setting_lookup_uint32(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint32 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint32 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3256,11 +3248,11 @@ int HP_libconfig_setting_lookup_uint16(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3283,11 +3275,11 @@ int HP_libconfig_setting_lookup_int16(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3310,11 +3302,11 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, out, &out_size); + retVal___ = preHookFunc(&setting, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3325,10 +3317,10 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se retVal___ = HPMHooks.source.libconfig.setting_lookup_mutable_string(setting, name, out, out_size); } if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, name, out, &out_size); + retVal___ = postHookFunc(retVal___, setting, name, out, out_size); } } return retVal___; @@ -3337,11 +3329,11 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_t **config, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(config, name, out, &out_size); + retVal___ = preHookFunc(&config, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3352,10 +3344,10 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char retVal___ = HPMHooks.source.libconfig.lookup_mutable_string(config, name, out, out_size); } if( HPMHooks.count.HP_libconfig_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, config, name, out, &out_size); + retVal___ = postHookFunc(retVal___, config, name, out, out_size); } } return retVal___; @@ -3365,11 +3357,11 @@ int HP_login_mmo_auth(struct login_session_data *sd, bool isServer) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_mmo_auth_pre ) { - int (*preHookFunc) (struct login_session_data *sd, bool *isServer); + int (*preHookFunc) (struct login_session_data **sd, bool *isServer); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_mmo_auth_pre[hIndex].func; - retVal___ = preHookFunc(sd, &isServer); + retVal___ = preHookFunc(&sd, &isServer); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3380,10 +3372,10 @@ int HP_login_mmo_auth(struct login_session_data *sd, bool isServer) { retVal___ = HPMHooks.source.login.mmo_auth(sd, isServer); } if( HPMHooks.count.HP_login_mmo_auth_post ) { - int (*postHookFunc) (int retVal___, struct login_session_data *sd, bool *isServer); + int (*postHookFunc) (int retVal___, struct login_session_data *sd, bool isServer); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_mmo_auth_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &isServer); + retVal___ = postHookFunc(retVal___, sd, isServer); } } return retVal___; @@ -3392,11 +3384,11 @@ int HP_login_mmo_auth_new(const char *userid, const char *pass, const char sex, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_mmo_auth_new_pre ) { - int (*preHookFunc) (const char *userid, const char *pass, const char *sex, const char *last_ip); + int (*preHookFunc) (const char **userid, const char **pass, const char *sex, const char **last_ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_new_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_mmo_auth_new_pre[hIndex].func; - retVal___ = preHookFunc(userid, pass, &sex, last_ip); + retVal___ = preHookFunc(&userid, &pass, &sex, &last_ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3407,10 +3399,10 @@ int HP_login_mmo_auth_new(const char *userid, const char *pass, const char sex, retVal___ = HPMHooks.source.login.mmo_auth_new(userid, pass, sex, last_ip); } if( HPMHooks.count.HP_login_mmo_auth_new_post ) { - int (*postHookFunc) (int retVal___, const char *userid, const char *pass, const char *sex, const char *last_ip); + int (*postHookFunc) (int retVal___, const char *userid, const char *pass, const char sex, const char *last_ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_new_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_mmo_auth_new_post[hIndex].func; - retVal___ = postHookFunc(retVal___, userid, pass, &sex, last_ip); + retVal___ = postHookFunc(retVal___, userid, pass, sex, last_ip); } } return retVal___; @@ -3434,18 +3426,17 @@ int HP_login_waiting_disconnect_timer(int tid, int64 tick, int id, intptr_t data retVal___ = HPMHooks.source.login.waiting_disconnect_timer(tid, tick, id, data); } if( HPMHooks.count.HP_login_waiting_disconnect_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_waiting_disconnect_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_waiting_disconnect_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; } struct DBData HP_login_create_online_user(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_login_create_online_user_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -3466,11 +3457,11 @@ struct DBData HP_login_create_online_user(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_login_create_online_user_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_create_online_user_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_login_create_online_user_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -3495,10 +3486,10 @@ struct online_login_data* HP_login_add_online_user(int char_server, int account_ retVal___ = HPMHooks.source.login.add_online_user(char_server, account_id); } if( HPMHooks.count.HP_login_add_online_user_post ) { - struct online_login_data* (*postHookFunc) (struct online_login_data* retVal___, int *char_server, int *account_id); + struct online_login_data* (*postHookFunc) (struct online_login_data* retVal___, int char_server, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_add_online_user_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_add_online_user_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_server, &account_id); + retVal___ = postHookFunc(retVal___, char_server, account_id); } } return retVal___; @@ -3521,10 +3512,10 @@ void HP_login_remove_online_user(int account_id) { HPMHooks.source.login.remove_online_user(account_id); } if( HPMHooks.count.HP_login_remove_online_user_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_remove_online_user_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_remove_online_user_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -3533,12 +3524,12 @@ int HP_login_online_db_setoffline(union DBKey key, struct DBData *data, va_list int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_online_db_setoffline_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_db_setoffline_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_login_online_db_setoffline_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -3552,11 +3543,11 @@ int HP_login_online_db_setoffline(union DBKey key, struct DBData *data, va_list va_end(ap___copy); } if( HPMHooks.count.HP_login_online_db_setoffline_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_db_setoffline_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_login_online_db_setoffline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -3566,12 +3557,12 @@ int HP_login_online_data_cleanup_sub(union DBKey key, struct DBData *data, va_li int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_online_data_cleanup_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_data_cleanup_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_login_online_data_cleanup_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -3585,11 +3576,11 @@ int HP_login_online_data_cleanup_sub(union DBKey key, struct DBData *data, va_li va_end(ap___copy); } if( HPMHooks.count.HP_login_online_data_cleanup_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_data_cleanup_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_login_online_data_cleanup_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -3614,10 +3605,10 @@ int HP_login_online_data_cleanup(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.login.online_data_cleanup(tid, tick, id, data); } if( HPMHooks.count.HP_login_online_data_cleanup_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_data_cleanup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_online_data_cleanup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -3641,10 +3632,10 @@ int HP_login_sync_ip_addresses(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.login.sync_ip_addresses(tid, tick, id, data); } if( HPMHooks.count.HP_login_sync_ip_addresses_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_sync_ip_addresses_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_sync_ip_addresses_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -3653,11 +3644,11 @@ bool HP_login_check_encrypted(const char *str1, const char *str2, const char *pa int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_login_check_encrypted_pre ) { - bool (*preHookFunc) (const char *str1, const char *str2, const char *passwd); + bool (*preHookFunc) (const char **str1, const char **str2, const char **passwd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_check_encrypted_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_check_encrypted_pre[hIndex].func; - retVal___ = preHookFunc(str1, str2, passwd); + retVal___ = preHookFunc(&str1, &str2, &passwd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3680,11 +3671,11 @@ bool HP_login_check_password(const char *md5key, int passwdenc, const char *pass int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_login_check_password_pre ) { - bool (*preHookFunc) (const char *md5key, int *passwdenc, const char *passwd, const char *refpass); + bool (*preHookFunc) (const char **md5key, int *passwdenc, const char **passwd, const char **refpass); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_check_password_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_check_password_pre[hIndex].func; - retVal___ = preHookFunc(md5key, &passwdenc, passwd, refpass); + retVal___ = preHookFunc(&md5key, &passwdenc, &passwd, &refpass); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3695,10 +3686,10 @@ bool HP_login_check_password(const char *md5key, int passwdenc, const char *pass retVal___ = HPMHooks.source.login.check_password(md5key, passwdenc, passwd, refpass); } if( HPMHooks.count.HP_login_check_password_post ) { - bool (*postHookFunc) (bool retVal___, const char *md5key, int *passwdenc, const char *passwd, const char *refpass); + bool (*postHookFunc) (bool retVal___, const char *md5key, int passwdenc, const char *passwd, const char *refpass); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_check_password_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_check_password_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md5key, &passwdenc, passwd, refpass); + retVal___ = postHookFunc(retVal___, md5key, passwdenc, passwd, refpass); } } return retVal___; @@ -3722,10 +3713,10 @@ uint32 HP_login_lan_subnet_check(uint32 ip) { retVal___ = HPMHooks.source.login.lan_subnet_check(ip); } if( HPMHooks.count.HP_login_lan_subnet_check_post ) { - uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip); + 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); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -3733,11 +3724,11 @@ uint32 HP_login_lan_subnet_check(uint32 ip) { 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 ) { - void (*preHookFunc) (int *fd, int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd, struct mmo_account *acc); + void (*preHookFunc) (int *fd, int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd, struct mmo_account **acc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_accinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_accinfo_pre[hIndex].func; - preHookFunc(&fd, &account_id, &u_fd, &u_aid, &u_group, &map_fd, acc); + preHookFunc(&fd, &account_id, &u_fd, &u_aid, &u_group, &map_fd, &acc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3748,10 +3739,10 @@ void HP_login_fromchar_accinfo(int fd, int account_id, int u_fd, int u_aid, int HPMHooks.source.login.fromchar_accinfo(fd, account_id, u_fd, u_aid, u_group, map_fd, acc); } if( HPMHooks.count.HP_login_fromchar_accinfo_post ) { - void (*postHookFunc) (int *fd, int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd, struct mmo_account *acc); + void (*postHookFunc) (int fd, int account_id, int u_fd, int u_aid, int u_group, int map_fd, struct mmo_account *acc); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_accinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_accinfo_post[hIndex].func; - postHookFunc(&fd, &account_id, &u_fd, &u_aid, &u_group, &map_fd, acc); + postHookFunc(fd, account_id, u_fd, u_aid, u_group, map_fd, acc); } } return; @@ -3759,11 +3750,11 @@ void HP_login_fromchar_accinfo(int fd, int account_id, int u_fd, int u_aid, int void HP_login_fromchar_account(int fd, int account_id, struct mmo_account *acc) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_account_pre ) { - void (*preHookFunc) (int *fd, int *account_id, struct mmo_account *acc); + void (*preHookFunc) (int *fd, int *account_id, struct mmo_account **acc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_account_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_account_pre[hIndex].func; - preHookFunc(&fd, &account_id, acc); + preHookFunc(&fd, &account_id, &acc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3774,10 +3765,10 @@ void HP_login_fromchar_account(int fd, int account_id, struct mmo_account *acc) HPMHooks.source.login.fromchar_account(fd, account_id, acc); } if( HPMHooks.count.HP_login_fromchar_account_post ) { - void (*postHookFunc) (int *fd, int *account_id, struct mmo_account *acc); + void (*postHookFunc) (int fd, int account_id, struct mmo_account *acc); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_account_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_account_post[hIndex].func; - postHookFunc(&fd, &account_id, acc); + postHookFunc(fd, account_id, acc); } } return; @@ -3800,10 +3791,10 @@ void HP_login_fromchar_account_update_other(int account_id, unsigned int state) HPMHooks.source.login.fromchar_account_update_other(account_id, state); } if( HPMHooks.count.HP_login_fromchar_account_update_other_post ) { - void (*postHookFunc) (int *account_id, unsigned int *state); + void (*postHookFunc) (int account_id, unsigned int state); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_account_update_other_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_account_update_other_post[hIndex].func; - postHookFunc(&account_id, &state); + postHookFunc(account_id, state); } } return; @@ -3811,11 +3802,11 @@ void HP_login_fromchar_account_update_other(int account_id, unsigned int state) void HP_login_fromchar_auth_ack(int fd, int account_id, uint32 login_id1, uint32 login_id2, uint8 sex, int request_id, struct login_auth_node *node) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_auth_ack_pre ) { - void (*preHookFunc) (int *fd, int *account_id, uint32 *login_id1, uint32 *login_id2, uint8 *sex, int *request_id, struct login_auth_node *node); + void (*preHookFunc) (int *fd, int *account_id, uint32 *login_id1, uint32 *login_id2, uint8 *sex, int *request_id, struct login_auth_node **node); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_auth_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_auth_ack_pre[hIndex].func; - preHookFunc(&fd, &account_id, &login_id1, &login_id2, &sex, &request_id, node); + preHookFunc(&fd, &account_id, &login_id1, &login_id2, &sex, &request_id, &node); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3826,10 +3817,10 @@ void HP_login_fromchar_auth_ack(int fd, int account_id, uint32 login_id1, uint32 HPMHooks.source.login.fromchar_auth_ack(fd, account_id, login_id1, login_id2, sex, request_id, node); } if( HPMHooks.count.HP_login_fromchar_auth_ack_post ) { - void (*postHookFunc) (int *fd, int *account_id, uint32 *login_id1, uint32 *login_id2, uint8 *sex, int *request_id, struct login_auth_node *node); + void (*postHookFunc) (int fd, int account_id, uint32 login_id1, uint32 login_id2, uint8 sex, int request_id, struct login_auth_node *node); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_auth_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_auth_ack_post[hIndex].func; - postHookFunc(&fd, &account_id, &login_id1, &login_id2, &sex, &request_id, node); + postHookFunc(fd, account_id, login_id1, login_id2, sex, request_id, node); } } return; @@ -3852,10 +3843,10 @@ void HP_login_fromchar_ban(int account_id, time_t timestamp) { HPMHooks.source.login.fromchar_ban(account_id, timestamp); } if( HPMHooks.count.HP_login_fromchar_ban_post ) { - void (*postHookFunc) (int *account_id, time_t *timestamp); + void (*postHookFunc) (int account_id, time_t timestamp); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_ban_post[hIndex].func; - postHookFunc(&account_id, ×tamp); + postHookFunc(account_id, timestamp); } } return; @@ -3878,10 +3869,10 @@ void HP_login_fromchar_change_sex_other(int account_id, char sex) { HPMHooks.source.login.fromchar_change_sex_other(account_id, sex); } if( HPMHooks.count.HP_login_fromchar_change_sex_other_post ) { - void (*postHookFunc) (int *account_id, char *sex); + void (*postHookFunc) (int account_id, char sex); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_change_sex_other_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_change_sex_other_post[hIndex].func; - postHookFunc(&account_id, &sex); + postHookFunc(account_id, sex); } } return; @@ -3904,10 +3895,10 @@ void HP_login_fromchar_pong(int fd) { HPMHooks.source.login.fromchar_pong(fd); } if( HPMHooks.count.HP_login_fromchar_pong_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_pong_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_pong_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3915,11 +3906,11 @@ void HP_login_fromchar_pong(int fd) { void HP_login_fromchar_parse_auth(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_auth_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_auth_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_auth_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3930,10 +3921,10 @@ void HP_login_fromchar_parse_auth(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_auth(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_auth_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_auth_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_auth_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -3956,10 +3947,10 @@ void HP_login_fromchar_parse_update_users(int fd, int id) { HPMHooks.source.login.fromchar_parse_update_users(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_update_users_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_update_users_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_update_users_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -3967,11 +3958,11 @@ void HP_login_fromchar_parse_update_users(int fd, int id) { void HP_login_fromchar_parse_request_change_email(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_request_change_email_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_request_change_email_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_request_change_email_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3982,10 +3973,10 @@ void HP_login_fromchar_parse_request_change_email(int fd, int id, const char *ip HPMHooks.source.login.fromchar_parse_request_change_email(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_request_change_email_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_request_change_email_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_request_change_email_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -3993,11 +3984,11 @@ void HP_login_fromchar_parse_request_change_email(int fd, int id, const char *ip void HP_login_fromchar_parse_account_data(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_account_data_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_data_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4008,10 +3999,10 @@ void HP_login_fromchar_parse_account_data(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_account_data(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_account_data_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_data_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4034,10 +4025,10 @@ void HP_login_fromchar_parse_ping(int fd) { HPMHooks.source.login.fromchar_parse_ping(fd); } if( HPMHooks.count.HP_login_fromchar_parse_ping_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_ping_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_ping_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4045,11 +4036,11 @@ void HP_login_fromchar_parse_ping(int fd) { void HP_login_fromchar_parse_change_email(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_change_email_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_email_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_email_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4060,10 +4051,10 @@ void HP_login_fromchar_parse_change_email(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_change_email(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_change_email_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_email_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_email_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4071,11 +4062,11 @@ void HP_login_fromchar_parse_change_email(int fd, int id, const char *ip) { void HP_login_fromchar_parse_account_update(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_account_update_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_update_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4086,10 +4077,10 @@ void HP_login_fromchar_parse_account_update(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_account_update(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_account_update_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_update_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4097,11 +4088,11 @@ void HP_login_fromchar_parse_account_update(int fd, int id, const char *ip) { void HP_login_fromchar_parse_ban(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_ban_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_ban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_ban_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4112,10 +4103,10 @@ void HP_login_fromchar_parse_ban(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_ban(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_ban_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_ban_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4123,11 +4114,11 @@ void HP_login_fromchar_parse_ban(int fd, int id, const char *ip) { void HP_login_fromchar_parse_change_sex(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_change_sex_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_sex_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_sex_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4138,10 +4129,10 @@ void HP_login_fromchar_parse_change_sex(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_change_sex(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_change_sex_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_sex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_sex_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4149,11 +4140,11 @@ void HP_login_fromchar_parse_change_sex(int fd, int id, const char *ip) { void HP_login_fromchar_parse_account_reg2(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_account_reg2_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_reg2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_reg2_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4164,10 +4155,10 @@ void HP_login_fromchar_parse_account_reg2(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_account_reg2(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_account_reg2_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_reg2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_reg2_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4175,11 +4166,11 @@ void HP_login_fromchar_parse_account_reg2(int fd, int id, const char *ip) { void HP_login_fromchar_parse_unban(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_unban_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_unban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_unban_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4190,10 +4181,10 @@ void HP_login_fromchar_parse_unban(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_unban(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_unban_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_unban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_unban_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4216,10 +4207,10 @@ void HP_login_fromchar_parse_account_online(int fd, int id) { HPMHooks.source.login.fromchar_parse_account_online(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_account_online_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_online_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_online_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4242,10 +4233,10 @@ void HP_login_fromchar_parse_account_offline(int fd) { HPMHooks.source.login.fromchar_parse_account_offline(fd); } if( HPMHooks.count.HP_login_fromchar_parse_account_offline_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_offline_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4268,10 +4259,10 @@ void HP_login_fromchar_parse_online_accounts(int fd, int id) { HPMHooks.source.login.fromchar_parse_online_accounts(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_online_accounts_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_online_accounts_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_online_accounts_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4294,10 +4285,10 @@ void HP_login_fromchar_parse_request_account_reg2(int fd) { HPMHooks.source.login.fromchar_parse_request_account_reg2(fd); } if( HPMHooks.count.HP_login_fromchar_parse_request_account_reg2_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_request_account_reg2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_request_account_reg2_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4320,10 +4311,10 @@ void HP_login_fromchar_parse_update_wan_ip(int fd, int id) { HPMHooks.source.login.fromchar_parse_update_wan_ip(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_update_wan_ip_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_update_wan_ip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_update_wan_ip_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4346,10 +4337,10 @@ void HP_login_fromchar_parse_all_offline(int fd, int id) { HPMHooks.source.login.fromchar_parse_all_offline(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_all_offline_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_all_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_all_offline_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4372,10 +4363,10 @@ void HP_login_fromchar_parse_change_pincode(int fd) { HPMHooks.source.login.fromchar_parse_change_pincode(fd); } if( HPMHooks.count.HP_login_fromchar_parse_change_pincode_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_pincode_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_pincode_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4399,10 +4390,10 @@ bool HP_login_fromchar_parse_wrong_pincode(int fd) { retVal___ = HPMHooks.source.login.fromchar_parse_wrong_pincode(fd); } if( HPMHooks.count.HP_login_fromchar_parse_wrong_pincode_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_wrong_pincode_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_wrong_pincode_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -4425,10 +4416,10 @@ void HP_login_fromchar_parse_accinfo(int fd) { HPMHooks.source.login.fromchar_parse_accinfo(fd); } if( HPMHooks.count.HP_login_fromchar_parse_accinfo_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_accinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_accinfo_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4452,10 +4443,10 @@ int HP_login_parse_fromchar(int fd) { retVal___ = HPMHooks.source.login.parse_fromchar(fd); } if( HPMHooks.count.HP_login_parse_fromchar_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_parse_fromchar_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_parse_fromchar_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -4463,11 +4454,11 @@ int HP_login_parse_fromchar(int fd) { void HP_login_kick(struct login_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_login_kick_pre ) { - void (*preHookFunc) (struct login_session_data *sd); + void (*preHookFunc) (struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_kick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_kick_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4489,11 +4480,11 @@ void HP_login_kick(struct login_session_data *sd) { void HP_login_auth_ok(struct login_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_login_auth_ok_pre ) { - void (*preHookFunc) (struct login_session_data *sd); + void (*preHookFunc) (struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_auth_ok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_auth_ok_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4515,11 +4506,11 @@ void HP_login_auth_ok(struct login_session_data *sd) { void HP_login_auth_failed(struct login_session_data *sd, int result) { int hIndex = 0; if( HPMHooks.count.HP_login_auth_failed_pre ) { - void (*preHookFunc) (struct login_session_data *sd, int *result); + void (*preHookFunc) (struct login_session_data **sd, int *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_auth_failed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_auth_failed_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4530,10 +4521,10 @@ void HP_login_auth_failed(struct login_session_data *sd, int result) { HPMHooks.source.login.auth_failed(sd, result); } if( HPMHooks.count.HP_login_auth_failed_post ) { - void (*postHookFunc) (struct login_session_data *sd, int *result); + void (*postHookFunc) (struct login_session_data *sd, int result); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_auth_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_auth_failed_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -4542,11 +4533,11 @@ bool HP_login_client_login(int fd, struct login_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_login_client_login_pre ) { - bool (*preHookFunc) (int *fd, struct login_session_data *sd); + bool (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_client_login_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_client_login_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4557,10 +4548,10 @@ bool HP_login_client_login(int fd, struct login_session_data *sd) { retVal___ = HPMHooks.source.login.client_login(fd, sd); } if( HPMHooks.count.HP_login_client_login_post ) { - bool (*postHookFunc) (bool retVal___, int *fd, struct login_session_data *sd); + bool (*postHookFunc) (bool retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_client_login_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_client_login_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -4568,11 +4559,11 @@ bool HP_login_client_login(int fd, struct login_session_data *sd) { void HP_login_char_server_connection_status(int fd, struct login_session_data *sd, uint8 status) { int hIndex = 0; if( HPMHooks.count.HP_login_char_server_connection_status_pre ) { - void (*preHookFunc) (int *fd, struct login_session_data *sd, uint8 *status); + void (*preHookFunc) (int *fd, struct login_session_data **sd, uint8 *status); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_char_server_connection_status_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_char_server_connection_status_pre[hIndex].func; - preHookFunc(&fd, sd, &status); + preHookFunc(&fd, &sd, &status); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4583,10 +4574,10 @@ void HP_login_char_server_connection_status(int fd, struct login_session_data *s HPMHooks.source.login.char_server_connection_status(fd, sd, status); } if( HPMHooks.count.HP_login_char_server_connection_status_post ) { - void (*postHookFunc) (int *fd, struct login_session_data *sd, uint8 *status); + void (*postHookFunc) (int fd, struct login_session_data *sd, uint8 status); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_char_server_connection_status_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_char_server_connection_status_post[hIndex].func; - postHookFunc(&fd, sd, &status); + postHookFunc(fd, sd, status); } } return; @@ -4594,11 +4585,11 @@ void HP_login_char_server_connection_status(int fd, struct login_session_data *s 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, uint32 *ipl); + 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, &ipl); + preHookFunc(&fd, &sd, &ip, &ipl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4609,10 +4600,10 @@ void HP_login_parse_request_connection(int fd, struct login_session_data *sd, co 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, uint32 *ipl); + 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, &ipl); + postHookFunc(fd, sd, ip, ipl); } } return; @@ -4647,11 +4638,11 @@ int HP_login_config_read(const char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_config_read_pre ) { - int (*preHookFunc) (const char *cfgName); + int (*preHookFunc) (const char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4727,11 +4718,11 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun 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); + 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); + retVal___ = preHookFunc(&size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4742,10 +4733,10 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun 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); + 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); + retVal___ = postHookFunc(retVal___, size, file, line, func); } } return retVal___; @@ -4754,11 +4745,11 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con 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); + 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); + retVal___ = preHookFunc(&num, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4769,10 +4760,10 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con 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); + 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); + retVal___ = postHookFunc(retVal___, num, size, file, line, func); } } return retVal___; @@ -4781,11 +4772,11 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const 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); + 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); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4796,10 +4787,10 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const 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); + 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); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -4808,11 +4799,11 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons 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); + 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); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4823,10 +4814,10 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons 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); + 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); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -4835,11 +4826,11 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * 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); + 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); + retVal___ = preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4850,10 +4841,10 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * 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); + 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); + retVal___ = postHookFunc(retVal___, p, file, line, func); } } return retVal___; @@ -4862,11 +4853,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_astrndup_pre ) { - char* (*preHookFunc) (const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*preHookFunc) (const char **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_astrndup_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4877,10 +4868,10 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line retVal___ = HPMHooks.source.iMalloc.astrndup(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_astrndup_post ) { - char* (*postHookFunc) (char* retVal___, const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*postHookFunc) (char* retVal___, const char *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_astrndup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -4888,11 +4879,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line 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); + 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); + preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4903,10 +4894,10 @@ void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { 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); + 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); + postHookFunc(p, file, line, func); } } return; @@ -4941,11 +4932,11 @@ 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); + 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); + retVal___ = preHookFunc(&ptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5047,11 +5038,11 @@ void HP_iMalloc_init_messages(void) { 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); + 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); + preHookFunc(&file, &line, &func, &targetname, &title); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5062,10 +5053,10 @@ void HP_nullpo_assert_report(const char *file, int line, const char *func, const 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); + 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); + postHookFunc(file, line, func, targetname, title); } } return; @@ -5153,12 +5144,12 @@ 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); + 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); + retVal___ = preHookFunc(&string, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -5254,10 +5245,10 @@ int HP_sockt_perform(int next) { retVal___ = HPMHooks.source.sockt.perform(next); } if( HPMHooks.count.HP_sockt_perform_post ) { - int (*postHookFunc) (int retVal___, int *next); + 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); + retVal___ = postHookFunc(retVal___, next); } } return retVal___; @@ -5280,10 +5271,10 @@ void HP_sockt_datasync(int fd, bool send) { HPMHooks.source.sockt.datasync(fd, send); } if( HPMHooks.count.HP_sockt_datasync_post ) { - void (*postHookFunc) (int *fd, bool *send); + 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); + postHookFunc(fd, send); } } return; @@ -5307,10 +5298,10 @@ int HP_sockt_make_listen_bind(uint32 ip, uint16 port) { 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); + 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); + retVal___ = postHookFunc(retVal___, ip, port); } } return retVal___; @@ -5319,11 +5310,11 @@ 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); + 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); + retVal___ = preHookFunc(&ip, &port, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5334,10 +5325,10 @@ int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { 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); + 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); + retVal___ = postHookFunc(retVal___, ip, port, opt); } } return retVal___; @@ -5361,10 +5352,10 @@ int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_si 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); + 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); + retVal___ = postHookFunc(retVal___, fd, rfifo_size, wfifo_size); } } return retVal___; @@ -5388,10 +5379,10 @@ int HP_sockt_realloc_writefifo(int fd, size_t addition) { 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); + 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); + retVal___ = postHookFunc(retVal___, fd, addition); } } return retVal___; @@ -5415,10 +5406,10 @@ int HP_sockt_wfifoset(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.wfifoset(fd, len); } if( HPMHooks.count.HP_sockt_wfifoset_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + 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); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -5442,10 +5433,10 @@ int HP_sockt_rfifoskip(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len); } if( HPMHooks.count.HP_sockt_rfifoskip_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + 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); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -5468,10 +5459,10 @@ void HP_sockt_close(int fd) { HPMHooks.source.sockt.close(fd); } if( HPMHooks.count.HP_sockt_close_post ) { - void (*postHookFunc) (int *fd); + 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); + postHookFunc(fd); } } return; @@ -5495,10 +5486,10 @@ bool HP_sockt_session_is_valid(int fd) { retVal___ = HPMHooks.source.sockt.session_is_valid(fd); } if( HPMHooks.count.HP_sockt_session_is_valid_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + 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); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -5522,10 +5513,10 @@ bool HP_sockt_session_is_active(int fd) { retVal___ = HPMHooks.source.sockt.session_is_active(fd); } if( HPMHooks.count.HP_sockt_session_is_active_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + 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); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -5548,10 +5539,10 @@ void HP_sockt_flush(int fd) { HPMHooks.source.sockt.flush(fd); } if( HPMHooks.count.HP_sockt_flush_post ) { - void (*postHookFunc) (int *fd); + 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); + postHookFunc(fd); } } return; @@ -5600,10 +5591,10 @@ void HP_sockt_set_nonblocking(int fd, unsigned long yes) { HPMHooks.source.sockt.set_nonblocking(fd, yes); } if( HPMHooks.count.HP_sockt_set_nonblocking_post ) { - void (*postHookFunc) (int *fd, unsigned long *yes); + 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); + postHookFunc(fd, yes); } } return; @@ -5626,10 +5617,10 @@ void HP_sockt_set_defaultparse(ParseFunc defaultparse) { HPMHooks.source.sockt.set_defaultparse(defaultparse); } if( HPMHooks.count.HP_sockt_set_defaultparse_post ) { - void (*postHookFunc) (ParseFunc *defaultparse); + 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); + postHookFunc(defaultparse); } } return; @@ -5638,11 +5629,11 @@ 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); + 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); + retVal___ = preHookFunc(&hostname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5665,11 +5656,11 @@ 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); + 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); + retVal___ = preHookFunc(&ip, &ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5680,10 +5671,10 @@ const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { 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); + 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); + retVal___ = postHookFunc(retVal___, ip, ip_str); } } return retVal___; @@ -5692,11 +5683,11 @@ 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); + 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); + retVal___ = preHookFunc(&ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5734,10 +5725,10 @@ uint16 HP_sockt_ntows(uint16 netshort) { retVal___ = HPMHooks.source.sockt.ntows(netshort); } if( HPMHooks.count.HP_sockt_ntows_post ) { - uint16 (*postHookFunc) (uint16 retVal___, uint16 *netshort); + 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); + retVal___ = postHookFunc(retVal___, netshort); } } return retVal___; @@ -5746,11 +5737,11 @@ 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); + 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); + retVal___ = preHookFunc(&ips, &max); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5761,10 +5752,10 @@ int HP_sockt_getips(uint32 *ips, int max) { retVal___ = HPMHooks.source.sockt.getips(ips, max); } if( HPMHooks.count.HP_sockt_getips_post ) { - int (*postHookFunc) (int retVal___, uint32 *ips, int *max); + 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); + retVal___ = postHookFunc(retVal___, ips, max); } } return retVal___; @@ -5787,10 +5778,10 @@ void HP_sockt_eof(int fd) { HPMHooks.source.sockt.eof(fd); } if( HPMHooks.count.HP_sockt_eof_post ) { - void (*postHookFunc) (int *fd); + 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); + postHookFunc(fd); } } return; @@ -5799,11 +5790,11 @@ 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); + 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); + retVal___ = preHookFunc(&ip, &info); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5814,10 +5805,10 @@ uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { 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); + 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); + retVal___ = postHookFunc(retVal___, ip, info); } } return retVal___; @@ -5841,10 +5832,10 @@ bool HP_sockt_allowed_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip); } if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + 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); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -5868,10 +5859,10 @@ bool HP_sockt_trusted_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip); } if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + 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); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -5880,11 +5871,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) { - int (*preHookFunc) (struct config_setting_t *t, struct s_subnet_vector *list, const char *filename, const char *groupname); + int (*preHookFunc) (struct config_setting_t **t, struct s_subnet_vector **list, 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, filename, groupname); + retVal___ = preHookFunc(&t, &list, &filename, &groupname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5906,11 +5897,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec 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); + 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); + preHookFunc(&filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5934,11 +5925,11 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Connect_pre ) { - int (*preHookFunc) (struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &user, &passwd, &host, &port, &db); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5949,10 +5940,10 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db); } if( HPMHooks.count.HP_SQL_Connect_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, self, user, passwd, host, port, db); } } return retVal___; @@ -5961,11 +5952,11 @@ int HP_SQL_GetTimeout(struct Sql *self, uint32 *out_timeout) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetTimeout_pre ) { - int (*preHookFunc) (struct Sql *self, uint32 *out_timeout); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &out_timeout); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5988,11 +5979,11 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) { - int (*preHookFunc) (struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &table, &out_buf, &buf_len, &sep); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6003,10 +5994,10 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep); } if( HPMHooks.count.HP_SQL_GetColumnNames_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, self, table, out_buf, buf_len, sep); } } return retVal___; @@ -6015,11 +6006,11 @@ int HP_SQL_SetEncoding(struct Sql *self, const char *encoding) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_SetEncoding_pre ) { - int (*preHookFunc) (struct Sql *self, const char *encoding); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &encoding); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6042,11 +6033,11 @@ int HP_SQL_Ping(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Ping_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6069,11 +6060,11 @@ size_t HP_SQL_EscapeString(struct 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) (struct Sql *self, char *out_to, const char *from); + size_t (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &out_to, &from); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6096,11 +6087,11 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) { - size_t (*preHookFunc) (struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &out_to, &from, &from_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6111,10 +6102,10 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len); } if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) { - size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*postHookFunc) (size_t retVal___, struct 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); + retVal___ = postHookFunc(retVal___, self, out_to, from, from_len); } } return retVal___; @@ -6123,12 +6114,12 @@ int HP_SQL_QueryV(struct Sql *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryV_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query, va_list args); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -6156,11 +6147,11 @@ int HP_SQL_QueryStr(struct Sql *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryStr_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6183,11 +6174,11 @@ uint64 HP_SQL_LastInsertId(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_LastInsertId_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6210,11 +6201,11 @@ uint32 HP_SQL_NumColumns(struct Sql *self) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumColumns_pre ) { - uint32 (*preHookFunc) (struct Sql *self); + uint32 (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6237,11 +6228,11 @@ uint64 HP_SQL_NumRows(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumRows_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6264,11 +6255,11 @@ int HP_SQL_NextRow(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_NextRow_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6291,11 +6282,11 @@ int HP_SQL_GetData(struct 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) (struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &col, &out_buf, &out_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6306,10 +6297,10 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len); } if( HPMHooks.count.HP_SQL_GetData_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*postHookFunc) (int retVal___, struct 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); + retVal___ = postHookFunc(retVal___, self, col, out_buf, out_len); } } return retVal___; @@ -6317,11 +6308,11 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len void HP_SQL_FreeResult(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_FreeResult_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6343,11 +6334,11 @@ void HP_SQL_FreeResult(struct Sql *self) { void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_ShowDebug__pre ) { - void (*preHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct 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); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6358,10 +6349,10 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_ShowDebug__post ) { - void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct 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); + postHookFunc(self, debug_file, debug_line); } } return; @@ -6369,11 +6360,11 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned void HP_SQL_Free(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_Free_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6423,11 +6414,11 @@ struct SqlStmt* HP_SQL_StmtMalloc(struct Sql *sql) { int hIndex = 0; struct SqlStmt* retVal___ = NULL; if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) { - struct SqlStmt* (*preHookFunc) (struct Sql *sql); + struct SqlStmt* (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&sql); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6450,12 +6441,12 @@ int HP_SQL_StmtPrepareV(struct SqlStmt *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query, va_list args); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -6483,11 +6474,11 @@ int HP_SQL_StmtPrepareStr(struct SqlStmt *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6510,11 +6501,11 @@ size_t HP_SQL_StmtNumParams(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6537,11 +6528,11 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, const 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); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6552,10 +6543,10 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len); } if( HPMHooks.count.HP_SQL_StmtBindParam_post ) { - int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, const 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); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len); } } return retVal___; @@ -6564,11 +6555,11 @@ int HP_SQL_StmtExecute(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtExecute_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6591,11 +6582,11 @@ uint64 HP_SQL_StmtLastInsertId(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6618,11 +6609,11 @@ size_t HP_SQL_StmtNumColumns(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6645,11 +6636,11 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum 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); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len, &out_length, &out_is_null); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6660,10 +6651,10 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf 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___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum 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); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); } } return retVal___; @@ -6672,11 +6663,11 @@ uint64 HP_SQL_StmtNumRows(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6699,11 +6690,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6725,11 +6716,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { void HP_SQL_StmtFreeResult(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6751,11 +6742,11 @@ void HP_SQL_StmtFreeResult(struct SqlStmt *self) { void HP_SQL_StmtFree(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFree_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6777,11 +6768,11 @@ void HP_SQL_StmtFree(struct SqlStmt *self) { void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) { - void (*preHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct 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); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6792,10 +6783,10 @@ void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const u HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) { - void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct 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); + postHookFunc(self, debug_file, debug_line); } } return; @@ -6831,11 +6822,11 @@ StringBuf* HP_StrBuf_Malloc(void) { void HP_StrBuf_Init(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Init_pre ) { - void (*preHookFunc) (StringBuf *self); + 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6858,12 +6849,12 @@ 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); + 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); + retVal___ = preHookFunc(&self, &fmt, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -6891,11 +6882,11 @@ 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); + 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); + retVal___ = preHookFunc(&self, &sbuf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6918,11 +6909,11 @@ 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); + 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); + retVal___ = preHookFunc(&self, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6945,11 +6936,11 @@ int HP_StrBuf_Length(StringBuf *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Length_pre ) { - int (*preHookFunc) (StringBuf *self); + 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6972,11 +6963,11 @@ char* HP_StrBuf_Value(StringBuf *self) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_StrBuf_Value_pre ) { - char* (*preHookFunc) (StringBuf *self); + 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); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6998,11 +6989,11 @@ char* HP_StrBuf_Value(StringBuf *self) { void HP_StrBuf_Clear(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Clear_pre ) { - void (*preHookFunc) (StringBuf *self); + 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7024,11 +7015,11 @@ void HP_StrBuf_Clear(StringBuf *self) { void HP_StrBuf_Destroy(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Destroy_pre ) { - void (*preHookFunc) (StringBuf *self); + 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7050,11 +7041,11 @@ void HP_StrBuf_Destroy(StringBuf *self) { void HP_StrBuf_Free(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Free_pre ) { - void (*preHookFunc) (StringBuf *self); + 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); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7078,11 +7069,11 @@ char* HP_strlib_jstrescape(char *pt) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_jstrescape_pre ) { - char* (*preHookFunc) (char *pt); + 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); + retVal___ = preHookFunc(&pt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7105,11 +7096,11 @@ 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); + 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); + retVal___ = preHookFunc(&pt, &spt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7132,11 +7123,11 @@ 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); + 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); + retVal___ = preHookFunc(&pt, &spt, &size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7147,10 +7138,10 @@ int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { 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); + 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); + retVal___ = postHookFunc(retVal___, pt, spt, size); } } return retVal___; @@ -7159,11 +7150,11 @@ 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); + 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); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7186,11 +7177,11 @@ char* HP_strlib_trim_(char *str) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_trim__pre ) { - char* (*preHookFunc) (char *str); + 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); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7213,11 +7204,11 @@ 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); + 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); + retVal___ = preHookFunc(&str, &delims); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7240,11 +7231,11 @@ 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); + 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); + retVal___ = preHookFunc(&haystack, &needle); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7267,11 +7258,11 @@ 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); + 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); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7282,10 +7273,10 @@ size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { 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); + 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); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -7294,11 +7285,11 @@ 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); + 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); + retVal___ = preHookFunc(&s1, &s2, &lasts); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7321,11 +7312,11 @@ 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); + 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); + retVal___ = preHookFunc(&email); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7348,11 +7339,11 @@ 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); + 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); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7375,11 +7366,11 @@ 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); + 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); + retVal___ = preHookFunc(&dst, &src, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7390,10 +7381,10 @@ char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { 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); + 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); + retVal___ = postHookFunc(retVal___, dst, src, n); } } return retVal___; @@ -7402,11 +7393,11 @@ 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); + 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); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7417,10 +7408,10 @@ size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { 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); + 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); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -7429,11 +7420,11 @@ 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); + 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); + retVal___ = preHookFunc(&str, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7444,10 +7435,10 @@ int HP_strlib_strline_(const char *str, size_t pos) { retVal___ = HPMHooks.source.strlib.strline_(str, pos); } if( HPMHooks.count.HP_strlib_strline__post ) { - int (*postHookFunc) (int retVal___, const char *str, size_t *pos); + 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); + retVal___ = postHookFunc(retVal___, str, pos); } } return retVal___; @@ -7456,11 +7447,11 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_strlib_bin2hex__pre ) { - bool (*preHookFunc) (char *output, const unsigned char *input, size_t *count); + bool (*preHookFunc) (char **output, const 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); + retVal___ = preHookFunc(&output, &input, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7471,10 +7462,10 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count); } if( HPMHooks.count.HP_strlib_bin2hex__post ) { - bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t *count); + bool (*postHookFunc) (bool retVal___, char *output, const 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); + retVal___ = postHookFunc(retVal___, output, input, count); } } return retVal___; @@ -7484,11 +7475,11 @@ 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); + 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); + retVal___ = preHookFunc(&svstate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7511,11 +7502,11 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos 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); + 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); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_pos, &npos, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7526,10 +7517,10 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos 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); + 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); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_pos, npos, opt); } } return retVal___; @@ -7538,11 +7529,11 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, 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); + 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); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_fields, &nfields, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7553,10 +7544,10 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, 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); + 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); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_fields, nfields, opt); } } return retVal___; @@ -7565,11 +7556,11 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e 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); + 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); + retVal___ = preHookFunc(&out_dest, &src, &len, &escapes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7580,10 +7571,10 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e 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); + 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); + retVal___ = postHookFunc(retVal___, out_dest, src, len, escapes); } } return retVal___; @@ -7592,11 +7583,11 @@ 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); + 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); + retVal___ = preHookFunc(&out_dest, &src, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7607,10 +7598,10 @@ size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { 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); + 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); + retVal___ = postHookFunc(retVal___, out_dest, src, len); } } return retVal___; @@ -7619,11 +7610,11 @@ 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); + 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); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7646,11 +7637,11 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m 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)); + 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); + retVal___ = preHookFunc(&directory, &filename, &delim, &mincols, &maxcols, &maxrows, &parseproc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7661,10 +7652,10 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m 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)); + 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); + retVal___ = postHookFunc(retVal___, directory, filename, delim, mincols, maxcols, maxrows, parseproc); } } return retVal___; @@ -8227,10 +8218,10 @@ int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) { 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); + 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); + retVal___ = postHookFunc(retVal___, tick, func, id, data); } } return retVal___; @@ -8254,10 +8245,10 @@ int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int 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); + 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); + retVal___ = postHookFunc(retVal___, tick, func, id, data, interval); } } return retVal___; @@ -8281,10 +8272,10 @@ const struct TimerData* HP_timer_get(int tid) { retVal___ = HPMHooks.source.timer.get(tid); } if( HPMHooks.count.HP_timer_get_post ) { - const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int *tid); + 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); + retVal___ = postHookFunc(retVal___, tid); } } return retVal___; @@ -8308,10 +8299,10 @@ int HP_timer_delete(int tid, TimerFunc func) { retVal___ = HPMHooks.source.timer.delete(tid, func); } if( HPMHooks.count.HP_timer_delete_post ) { - int (*postHookFunc) (int retVal___, int *tid, TimerFunc *func); + 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); + retVal___ = postHookFunc(retVal___, tid, func); } } return retVal___; @@ -8335,10 +8326,10 @@ int64 HP_timer_addtick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.addtick(tid, tick); } if( HPMHooks.count.HP_timer_addtick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + 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); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -8362,10 +8353,10 @@ int64 HP_timer_settick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.settick(tid, tick); } if( HPMHooks.count.HP_timer_settick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + 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); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -8374,11 +8365,11 @@ 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); + 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); + retVal___ = preHookFunc(&func, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8389,10 +8380,10 @@ int HP_timer_add_func_list(TimerFunc func, char *name) { 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); + 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); + retVal___ = postHookFunc(retVal___, func, name); } } return retVal___; @@ -8443,10 +8434,10 @@ int HP_timer_perform(int64 tick) { retVal___ = HPMHooks.source.timer.perform(tick); } if( HPMHooks.count.HP_timer_perform_post ) { - int (*postHookFunc) (int retVal___, int64 *tick); + 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); + retVal___ = postHookFunc(retVal___, tick); } } return retVal___; |