summaryrefslogtreecommitdiff
path: root/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/HPMHooking/HPMHooking_login.Hooks.inc')
-rw-r--r--src/plugins/HPMHooking/HPMHooking_login.Hooks.inc620
1 files changed, 310 insertions, 310 deletions
diff --git a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc
index bedadf9e3..d520c957f 100644
--- a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc
@@ -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___;
@@ -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___;
@@ -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, &current_arg, &argc);
+ retVal___ = postHookFunc(retVal___, name, current_arg, argc);
}
}
return retVal___;
@@ -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___;
@@ -552,10 +552,10 @@ 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___;
@@ -579,10 +579,10 @@ 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___;
@@ -606,10 +606,10 @@ 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___;
@@ -660,10 +660,10 @@ 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___;
@@ -687,10 +687,10 @@ 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___;
@@ -714,10 +714,10 @@ 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___;
@@ -741,10 +741,10 @@ 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___;
@@ -980,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;
@@ -1033,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;
@@ -1059,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;
@@ -1085,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;
@@ -1112,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___;
@@ -1139,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___;
@@ -1166,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___;
@@ -1220,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___;
@@ -1247,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___;
@@ -1274,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___;
@@ -1301,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___;
@@ -1328,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___;
@@ -1355,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___;
@@ -1382,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___;
@@ -1409,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___;
@@ -1436,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___;
@@ -1463,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___;
@@ -1490,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___;
@@ -1517,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___;
@@ -1597,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;
@@ -2133,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___;
@@ -2160,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___;
@@ -2187,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___;
@@ -2214,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___;
@@ -2268,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___;
@@ -2322,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___;
@@ -2349,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___;
@@ -2376,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___;
@@ -2403,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___;
@@ -2430,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___;
@@ -2457,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___;
@@ -2484,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___;
@@ -2511,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___;
@@ -2538,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___;
@@ -2565,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___;
@@ -2646,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___;
@@ -2700,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___;
@@ -2754,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___;
@@ -3317,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___;
@@ -3344,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___;
@@ -3372,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___;
@@ -3399,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___;
@@ -3426,10 +3426,10 @@ 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___;
@@ -3457,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);
}
}
@@ -3486,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___;
@@ -3512,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;
@@ -3543,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);
}
}
@@ -3576,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);
}
}
@@ -3605,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___;
@@ -3632,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___;
@@ -3686,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___;
@@ -3713,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___;
@@ -3739,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;
@@ -3765,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;
@@ -3791,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;
@@ -3817,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;
@@ -3843,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, &timestamp);
+ postHookFunc(account_id, timestamp);
}
}
return;
@@ -3869,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;
@@ -3895,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;
@@ -3921,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;
@@ -3947,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;
@@ -3973,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;
@@ -3999,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;
@@ -4025,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;
@@ -4051,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;
@@ -4077,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;
@@ -4103,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;
@@ -4129,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;
@@ -4155,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;
@@ -4181,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;
@@ -4207,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;
@@ -4233,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;
@@ -4259,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;
@@ -4285,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;
@@ -4311,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;
@@ -4337,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;
@@ -4363,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;
@@ -4390,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___;
@@ -4416,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;
@@ -4443,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___;
@@ -4521,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;
@@ -4548,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___;
@@ -4574,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;
@@ -4600,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;
@@ -4733,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___;
@@ -4760,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___;
@@ -4787,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___;
@@ -4814,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___;
@@ -4841,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___;
@@ -4868,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___;
@@ -4894,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;
@@ -5053,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;
@@ -5245,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___;
@@ -5271,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;
@@ -5298,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___;
@@ -5325,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___;
@@ -5352,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___;
@@ -5379,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___;
@@ -5406,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___;
@@ -5433,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___;
@@ -5459,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;
@@ -5486,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___;
@@ -5513,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___;
@@ -5539,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;
@@ -5591,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;
@@ -5617,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;
@@ -5671,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___;
@@ -5725,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___;
@@ -5752,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___;
@@ -5778,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;
@@ -5805,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___;
@@ -5832,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___;
@@ -5859,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___;
@@ -5940,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___;
@@ -5994,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___;
@@ -6102,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___;
@@ -6297,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___;
@@ -6349,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;
@@ -6543,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___;
@@ -6651,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___;
@@ -6783,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;
@@ -7138,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___;
@@ -7273,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___;
@@ -7381,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___;
@@ -7408,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___;
@@ -7435,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___;
@@ -7462,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___;
@@ -7517,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___;
@@ -7544,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___;
@@ -7571,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___;
@@ -7598,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___;
@@ -7652,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___;
@@ -8218,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___;
@@ -8245,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___;
@@ -8272,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___;
@@ -8299,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___;
@@ -8326,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___;
@@ -8353,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___;
@@ -8380,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___;
@@ -8434,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___;