diff options
Diffstat (limited to 'src/plugins')
| -rw-r--r-- | src/plugins/HPMHooking/HPMHooking.Defs.inc | 34 | ||||
| -rw-r--r-- | src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc | 60 | ||||
| -rw-r--r-- | src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc | 15 | ||||
| -rw-r--r-- | src/plugins/HPMHooking/HPMHooking_map.Hooks.inc | 371 |
4 files changed, 391 insertions, 89 deletions
diff --git a/src/plugins/HPMHooking/HPMHooking.Defs.inc b/src/plugins/HPMHooking/HPMHooking.Defs.inc index ef71f1967..93f4ba960 100644 --- a/src/plugins/HPMHooking/HPMHooking.Defs.inc +++ b/src/plugins/HPMHooking/HPMHooking.Defs.inc @@ -5224,20 +5224,32 @@ typedef bool (*HPMHOOK_pre_mapit_exists) (struct s_mapiterator **iter); typedef bool (*HPMHOOK_post_mapit_exists) (bool retVal___, struct s_mapiterator *iter); #endif // MAP_MAP_H #ifdef MAP_MAPREG_H /* mapreg */ -typedef void (*HPMHOOK_pre_mapreg_init) (void); -typedef void (*HPMHOOK_post_mapreg_init) (void); -typedef void (*HPMHOOK_pre_mapreg_final) (void); -typedef void (*HPMHOOK_post_mapreg_final) (void); typedef int (*HPMHOOK_pre_mapreg_readreg) (int64 *uid); typedef int (*HPMHOOK_post_mapreg_readreg) (int retVal___, int64 uid); typedef char* (*HPMHOOK_pre_mapreg_readregstr) (int64 *uid); typedef char* (*HPMHOOK_post_mapreg_readregstr) (char* retVal___, int64 uid); +typedef bool (*HPMHOOK_pre_mapreg_set_num_db) (int64 *uid, const char **name, unsigned int *index, int *value); +typedef bool (*HPMHOOK_post_mapreg_set_num_db) (bool retVal___, int64 uid, const char *name, unsigned int index, int value); +typedef bool (*HPMHOOK_pre_mapreg_delete_num_db) (int64 *uid, const char **name, unsigned int *index); +typedef bool (*HPMHOOK_post_mapreg_delete_num_db) (bool retVal___, int64 uid, const char *name, unsigned int index); typedef bool (*HPMHOOK_pre_mapreg_setreg) (int64 *uid, int *val); typedef bool (*HPMHOOK_post_mapreg_setreg) (bool retVal___, int64 uid, int val); +typedef bool (*HPMHOOK_pre_mapreg_set_str_db) (int64 *uid, const char **name, unsigned int *index, const char **value); +typedef bool (*HPMHOOK_post_mapreg_set_str_db) (bool retVal___, int64 uid, const char *name, unsigned int index, const char *value); +typedef bool (*HPMHOOK_pre_mapreg_delete_str_db) (int64 *uid, const char **name, unsigned int *index); +typedef bool (*HPMHOOK_post_mapreg_delete_str_db) (bool retVal___, int64 uid, const char *name, unsigned int index); typedef bool (*HPMHOOK_pre_mapreg_setregstr) (int64 *uid, const char **str); typedef bool (*HPMHOOK_post_mapreg_setregstr) (bool retVal___, int64 uid, const char *str); +typedef void (*HPMHOOK_pre_mapreg_load_num_db) (void); +typedef void (*HPMHOOK_post_mapreg_load_num_db) (void); +typedef void (*HPMHOOK_pre_mapreg_load_str_db) (void); +typedef void (*HPMHOOK_post_mapreg_load_str_db) (void); typedef void (*HPMHOOK_pre_mapreg_load) (void); typedef void (*HPMHOOK_post_mapreg_load) (void); +typedef void (*HPMHOOK_pre_mapreg_save_num_db) (const char **name, unsigned int *index, int *value); +typedef void (*HPMHOOK_post_mapreg_save_num_db) (const char *name, unsigned int index, int value); +typedef void (*HPMHOOK_pre_mapreg_save_str_db) (const char **name, unsigned int *index, const char **value); +typedef void (*HPMHOOK_post_mapreg_save_str_db) (const char *name, unsigned int index, const char *value); typedef void (*HPMHOOK_pre_mapreg_save) (void); typedef void (*HPMHOOK_post_mapreg_save) (void); typedef int (*HPMHOOK_pre_mapreg_save_timer) (int *tid, int64 *tick, int *id, intptr_t *data); @@ -5246,8 +5258,12 @@ typedef int (*HPMHOOK_pre_mapreg_destroyreg) (union DBKey *key, struct DBData ** typedef int (*HPMHOOK_post_mapreg_destroyreg) (int retVal___, union DBKey key, struct DBData *data, va_list ap); typedef void (*HPMHOOK_pre_mapreg_reload) (void); typedef void (*HPMHOOK_post_mapreg_reload) (void); -typedef bool (*HPMHOOK_pre_mapreg_config_read) (const char **filename, const struct config_setting_t **config, bool *imported); -typedef bool (*HPMHOOK_post_mapreg_config_read) (bool retVal___, const char *filename, const struct config_setting_t *config, bool imported); +typedef bool (*HPMHOOK_pre_mapreg_config_read_registry) (const char **filename, const struct config_setting_t **config, bool *imported); +typedef bool (*HPMHOOK_post_mapreg_config_read_registry) (bool retVal___, const char *filename, const struct config_setting_t *config, bool imported); +typedef void (*HPMHOOK_pre_mapreg_final) (void); +typedef void (*HPMHOOK_post_mapreg_final) (void); +typedef void (*HPMHOOK_pre_mapreg_init) (void); +typedef void (*HPMHOOK_post_mapreg_init) (void); #endif // MAP_MAPREG_H #ifdef COMMON_MD5CALC_H /* md5 */ typedef void (*HPMHOOK_pre_md5_string) (const char **string, char **output); @@ -6858,8 +6874,8 @@ typedef void (*HPMHOOK_pre_script_set_constant2) (const char **name, int *value, typedef void (*HPMHOOK_post_script_set_constant2) (const char *name, int value, bool is_parameter, bool is_deprecated); typedef bool (*HPMHOOK_pre_script_get_constant) (const char **name, int **value); typedef bool (*HPMHOOK_post_script_get_constant) (bool retVal___, const char *name, int *value); -typedef void (*HPMHOOK_pre_script_label_add) (int *key, int *pos); -typedef void (*HPMHOOK_post_script_label_add) (int key, int pos); +typedef void (*HPMHOOK_pre_script_label_add) (int *key, int *pos, enum script_label_flags *flags); +typedef void (*HPMHOOK_post_script_label_add) (int key, int pos, enum script_label_flags flags); typedef void (*HPMHOOK_pre_script_run) (struct script_code **rootscript, int *pos, int *rid, int *oid); typedef void (*HPMHOOK_post_script_run) (struct script_code *rootscript, int pos, int rid, int oid); typedef void (*HPMHOOK_pre_script_run_npc) (struct script_code **rootscript, int *pos, int *rid, int *oid); @@ -6924,6 +6940,8 @@ typedef const char* (*HPMHOOK_pre_script_parse_syntax_close_sub) (const char **p typedef const char* (*HPMHOOK_post_script_parse_syntax_close_sub) (const char* retVal___, const char *p, int *flag); typedef const char* (*HPMHOOK_pre_script_parse_syntax) (const char **p); typedef const char* (*HPMHOOK_post_script_parse_syntax) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_syntax_function) (const char **p, bool *is_public); +typedef const char* (*HPMHOOK_post_script_parse_syntax_function) (const char* retVal___, const char *p, bool is_public); typedef c_op (*HPMHOOK_pre_script_get_com) (const struct script_buf **scriptbuf, int **pos); typedef c_op (*HPMHOOK_post_script_get_com) (c_op retVal___, const struct script_buf *scriptbuf, int *pos); typedef int (*HPMHOOK_pre_script_get_num) (const struct script_buf **scriptbuf, int **pos); diff --git a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc index e8cb41240..df3a28bcb 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc @@ -3828,20 +3828,32 @@ struct { struct HPMHookPoint *HP_mapit_prev_post; struct HPMHookPoint *HP_mapit_exists_pre; struct HPMHookPoint *HP_mapit_exists_post; - struct HPMHookPoint *HP_mapreg_init_pre; - struct HPMHookPoint *HP_mapreg_init_post; - struct HPMHookPoint *HP_mapreg_final_pre; - struct HPMHookPoint *HP_mapreg_final_post; struct HPMHookPoint *HP_mapreg_readreg_pre; struct HPMHookPoint *HP_mapreg_readreg_post; struct HPMHookPoint *HP_mapreg_readregstr_pre; struct HPMHookPoint *HP_mapreg_readregstr_post; + struct HPMHookPoint *HP_mapreg_set_num_db_pre; + struct HPMHookPoint *HP_mapreg_set_num_db_post; + struct HPMHookPoint *HP_mapreg_delete_num_db_pre; + struct HPMHookPoint *HP_mapreg_delete_num_db_post; struct HPMHookPoint *HP_mapreg_setreg_pre; struct HPMHookPoint *HP_mapreg_setreg_post; + struct HPMHookPoint *HP_mapreg_set_str_db_pre; + struct HPMHookPoint *HP_mapreg_set_str_db_post; + struct HPMHookPoint *HP_mapreg_delete_str_db_pre; + struct HPMHookPoint *HP_mapreg_delete_str_db_post; struct HPMHookPoint *HP_mapreg_setregstr_pre; struct HPMHookPoint *HP_mapreg_setregstr_post; + struct HPMHookPoint *HP_mapreg_load_num_db_pre; + struct HPMHookPoint *HP_mapreg_load_num_db_post; + struct HPMHookPoint *HP_mapreg_load_str_db_pre; + struct HPMHookPoint *HP_mapreg_load_str_db_post; struct HPMHookPoint *HP_mapreg_load_pre; struct HPMHookPoint *HP_mapreg_load_post; + struct HPMHookPoint *HP_mapreg_save_num_db_pre; + struct HPMHookPoint *HP_mapreg_save_num_db_post; + struct HPMHookPoint *HP_mapreg_save_str_db_pre; + struct HPMHookPoint *HP_mapreg_save_str_db_post; struct HPMHookPoint *HP_mapreg_save_pre; struct HPMHookPoint *HP_mapreg_save_post; struct HPMHookPoint *HP_mapreg_save_timer_pre; @@ -3850,8 +3862,12 @@ struct { struct HPMHookPoint *HP_mapreg_destroyreg_post; struct HPMHookPoint *HP_mapreg_reload_pre; struct HPMHookPoint *HP_mapreg_reload_post; - struct HPMHookPoint *HP_mapreg_config_read_pre; - struct HPMHookPoint *HP_mapreg_config_read_post; + struct HPMHookPoint *HP_mapreg_config_read_registry_pre; + struct HPMHookPoint *HP_mapreg_config_read_registry_post; + struct HPMHookPoint *HP_mapreg_final_pre; + struct HPMHookPoint *HP_mapreg_final_post; + struct HPMHookPoint *HP_mapreg_init_pre; + struct HPMHookPoint *HP_mapreg_init_post; struct HPMHookPoint *HP_md5_string_pre; struct HPMHookPoint *HP_md5_string_post; struct HPMHookPoint *HP_md5_binary_pre; @@ -5454,6 +5470,8 @@ struct { struct HPMHookPoint *HP_script_parse_syntax_close_sub_post; struct HPMHookPoint *HP_script_parse_syntax_pre; struct HPMHookPoint *HP_script_parse_syntax_post; + struct HPMHookPoint *HP_script_parse_syntax_function_pre; + struct HPMHookPoint *HP_script_parse_syntax_function_post; struct HPMHookPoint *HP_script_get_com_pre; struct HPMHookPoint *HP_script_get_com_post; struct HPMHookPoint *HP_script_get_num_pre; @@ -10729,20 +10747,32 @@ struct { int HP_mapit_prev_post; int HP_mapit_exists_pre; int HP_mapit_exists_post; - int HP_mapreg_init_pre; - int HP_mapreg_init_post; - int HP_mapreg_final_pre; - int HP_mapreg_final_post; int HP_mapreg_readreg_pre; int HP_mapreg_readreg_post; int HP_mapreg_readregstr_pre; int HP_mapreg_readregstr_post; + int HP_mapreg_set_num_db_pre; + int HP_mapreg_set_num_db_post; + int HP_mapreg_delete_num_db_pre; + int HP_mapreg_delete_num_db_post; int HP_mapreg_setreg_pre; int HP_mapreg_setreg_post; + int HP_mapreg_set_str_db_pre; + int HP_mapreg_set_str_db_post; + int HP_mapreg_delete_str_db_pre; + int HP_mapreg_delete_str_db_post; int HP_mapreg_setregstr_pre; int HP_mapreg_setregstr_post; + int HP_mapreg_load_num_db_pre; + int HP_mapreg_load_num_db_post; + int HP_mapreg_load_str_db_pre; + int HP_mapreg_load_str_db_post; int HP_mapreg_load_pre; int HP_mapreg_load_post; + int HP_mapreg_save_num_db_pre; + int HP_mapreg_save_num_db_post; + int HP_mapreg_save_str_db_pre; + int HP_mapreg_save_str_db_post; int HP_mapreg_save_pre; int HP_mapreg_save_post; int HP_mapreg_save_timer_pre; @@ -10751,8 +10781,12 @@ struct { int HP_mapreg_destroyreg_post; int HP_mapreg_reload_pre; int HP_mapreg_reload_post; - int HP_mapreg_config_read_pre; - int HP_mapreg_config_read_post; + int HP_mapreg_config_read_registry_pre; + int HP_mapreg_config_read_registry_post; + int HP_mapreg_final_pre; + int HP_mapreg_final_post; + int HP_mapreg_init_pre; + int HP_mapreg_init_post; int HP_md5_string_pre; int HP_md5_string_post; int HP_md5_binary_pre; @@ -12355,6 +12389,8 @@ struct { int HP_script_parse_syntax_close_sub_post; int HP_script_parse_syntax_pre; int HP_script_parse_syntax_post; + int HP_script_parse_syntax_function_pre; + int HP_script_parse_syntax_function_post; int HP_script_get_com_pre; int HP_script_get_com_post; int HP_script_get_num_pre; diff --git a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc index 6b89841ad..3720e8a51 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc @@ -1960,18 +1960,26 @@ struct HookingPointData HookingPoints[] = { { HP_POP(mapit->prev, HP_mapit_prev) }, { HP_POP(mapit->exists, HP_mapit_exists) }, /* mapreg_interface */ - { HP_POP(mapreg->init, HP_mapreg_init) }, - { HP_POP(mapreg->final, HP_mapreg_final) }, { HP_POP(mapreg->readreg, HP_mapreg_readreg) }, { HP_POP(mapreg->readregstr, HP_mapreg_readregstr) }, + { HP_POP(mapreg->set_num_db, HP_mapreg_set_num_db) }, + { HP_POP(mapreg->delete_num_db, HP_mapreg_delete_num_db) }, { HP_POP(mapreg->setreg, HP_mapreg_setreg) }, + { HP_POP(mapreg->set_str_db, HP_mapreg_set_str_db) }, + { HP_POP(mapreg->delete_str_db, HP_mapreg_delete_str_db) }, { HP_POP(mapreg->setregstr, HP_mapreg_setregstr) }, + { HP_POP(mapreg->load_num_db, HP_mapreg_load_num_db) }, + { HP_POP(mapreg->load_str_db, HP_mapreg_load_str_db) }, { HP_POP(mapreg->load, HP_mapreg_load) }, + { HP_POP(mapreg->save_num_db, HP_mapreg_save_num_db) }, + { HP_POP(mapreg->save_str_db, HP_mapreg_save_str_db) }, { HP_POP(mapreg->save, HP_mapreg_save) }, { HP_POP(mapreg->save_timer, HP_mapreg_save_timer) }, { HP_POP(mapreg->destroyreg, HP_mapreg_destroyreg) }, { HP_POP(mapreg->reload, HP_mapreg_reload) }, - { HP_POP(mapreg->config_read, HP_mapreg_config_read) }, + { HP_POP(mapreg->config_read_registry, HP_mapreg_config_read_registry) }, + { HP_POP(mapreg->final, HP_mapreg_final) }, + { HP_POP(mapreg->init, HP_mapreg_init) }, /* md5_interface */ { HP_POP(md5->string, HP_md5_string) }, { HP_POP(md5->binary, HP_md5_binary) }, @@ -2793,6 +2801,7 @@ struct HookingPointData HookingPoints[] = { { HP_POP(script->parse_syntax_close, HP_script_parse_syntax_close) }, { HP_POP(script->parse_syntax_close_sub, HP_script_parse_syntax_close_sub) }, { HP_POP(script->parse_syntax, HP_script_parse_syntax) }, + { HP_POP(script->parse_syntax_function, HP_script_parse_syntax_function) }, { HP_POP(script->get_com, HP_script_get_com) }, { HP_POP(script->get_num, HP_script_get_num) }, { HP_POP(script->op2name, HP_script_op2name) }, diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc index 02d55228e..d5ab95ba2 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc @@ -50618,58 +50618,6 @@ bool HP_mapit_exists(struct s_mapiterator *iter) { return retVal___; } /* mapreg_interface */ -void HP_mapreg_init(void) { - int hIndex = 0; - if (HPMHooks.count.HP_mapreg_init_pre > 0) { - void (*preHookFunc) (void); - *HPMforce_return = false; - for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_pre; hIndex++) { - preHookFunc = HPMHooks.list.HP_mapreg_init_pre[hIndex].func; - preHookFunc(); - } - if (*HPMforce_return) { - *HPMforce_return = false; - return; - } - } - { - HPMHooks.source.mapreg.init(); - } - if (HPMHooks.count.HP_mapreg_init_post > 0) { - void (*postHookFunc) (void); - for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_post; hIndex++) { - postHookFunc = HPMHooks.list.HP_mapreg_init_post[hIndex].func; - postHookFunc(); - } - } - return; -} -void HP_mapreg_final(void) { - int hIndex = 0; - if (HPMHooks.count.HP_mapreg_final_pre > 0) { - void (*preHookFunc) (void); - *HPMforce_return = false; - for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_pre; hIndex++) { - preHookFunc = HPMHooks.list.HP_mapreg_final_pre[hIndex].func; - preHookFunc(); - } - if (*HPMforce_return) { - *HPMforce_return = false; - return; - } - } - { - HPMHooks.source.mapreg.final(); - } - if (HPMHooks.count.HP_mapreg_final_post > 0) { - void (*postHookFunc) (void); - for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_post; hIndex++) { - postHookFunc = HPMHooks.list.HP_mapreg_final_post[hIndex].func; - postHookFunc(); - } - } - return; -} int HP_mapreg_readreg(int64 uid) { int hIndex = 0; int retVal___ = 0; @@ -50724,6 +50672,60 @@ char* HP_mapreg_readregstr(int64 uid) { } return retVal___; } +bool HP_mapreg_set_num_db(int64 uid, const char *name, unsigned int index, int value) { + int hIndex = 0; + bool retVal___ = false; + if (HPMHooks.count.HP_mapreg_set_num_db_pre > 0) { + bool (*preHookFunc) (int64 *uid, const char **name, unsigned int *index, int *value); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_set_num_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_set_num_db_pre[hIndex].func; + retVal___ = preHookFunc(&uid, &name, &index, &value); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapreg.set_num_db(uid, name, index, value); + } + if (HPMHooks.count.HP_mapreg_set_num_db_post > 0) { + bool (*postHookFunc) (bool retVal___, int64 uid, const char *name, unsigned int index, int value); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_set_num_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_set_num_db_post[hIndex].func; + retVal___ = postHookFunc(retVal___, uid, name, index, value); + } + } + return retVal___; +} +bool HP_mapreg_delete_num_db(int64 uid, const char *name, unsigned int index) { + int hIndex = 0; + bool retVal___ = false; + if (HPMHooks.count.HP_mapreg_delete_num_db_pre > 0) { + bool (*preHookFunc) (int64 *uid, const char **name, unsigned int *index); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_delete_num_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_delete_num_db_pre[hIndex].func; + retVal___ = preHookFunc(&uid, &name, &index); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapreg.delete_num_db(uid, name, index); + } + if (HPMHooks.count.HP_mapreg_delete_num_db_post > 0) { + bool (*postHookFunc) (bool retVal___, int64 uid, const char *name, unsigned int index); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_delete_num_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_delete_num_db_post[hIndex].func; + retVal___ = postHookFunc(retVal___, uid, name, index); + } + } + return retVal___; +} bool HP_mapreg_setreg(int64 uid, int val) { int hIndex = 0; bool retVal___ = false; @@ -50751,6 +50753,60 @@ bool HP_mapreg_setreg(int64 uid, int val) { } return retVal___; } +bool HP_mapreg_set_str_db(int64 uid, const char *name, unsigned int index, const char *value) { + int hIndex = 0; + bool retVal___ = false; + if (HPMHooks.count.HP_mapreg_set_str_db_pre > 0) { + bool (*preHookFunc) (int64 *uid, const char **name, unsigned int *index, const char **value); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_set_str_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_set_str_db_pre[hIndex].func; + retVal___ = preHookFunc(&uid, &name, &index, &value); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapreg.set_str_db(uid, name, index, value); + } + if (HPMHooks.count.HP_mapreg_set_str_db_post > 0) { + bool (*postHookFunc) (bool retVal___, int64 uid, const char *name, unsigned int index, const char *value); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_set_str_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_set_str_db_post[hIndex].func; + retVal___ = postHookFunc(retVal___, uid, name, index, value); + } + } + return retVal___; +} +bool HP_mapreg_delete_str_db(int64 uid, const char *name, unsigned int index) { + int hIndex = 0; + bool retVal___ = false; + if (HPMHooks.count.HP_mapreg_delete_str_db_pre > 0) { + bool (*preHookFunc) (int64 *uid, const char **name, unsigned int *index); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_delete_str_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_delete_str_db_pre[hIndex].func; + retVal___ = preHookFunc(&uid, &name, &index); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.mapreg.delete_str_db(uid, name, index); + } + if (HPMHooks.count.HP_mapreg_delete_str_db_post > 0) { + bool (*postHookFunc) (bool retVal___, int64 uid, const char *name, unsigned int index); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_delete_str_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_delete_str_db_post[hIndex].func; + retVal___ = postHookFunc(retVal___, uid, name, index); + } + } + return retVal___; +} bool HP_mapreg_setregstr(int64 uid, const char *str) { int hIndex = 0; bool retVal___ = false; @@ -50778,6 +50834,58 @@ bool HP_mapreg_setregstr(int64 uid, const char *str) { } return retVal___; } +void HP_mapreg_load_num_db(void) { + int hIndex = 0; + if (HPMHooks.count.HP_mapreg_load_num_db_pre > 0) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_num_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_load_num_db_pre[hIndex].func; + preHookFunc(); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapreg.load_num_db(); + } + if (HPMHooks.count.HP_mapreg_load_num_db_post > 0) { + void (*postHookFunc) (void); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_num_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_load_num_db_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_mapreg_load_str_db(void) { + int hIndex = 0; + if (HPMHooks.count.HP_mapreg_load_str_db_pre > 0) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_str_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_load_str_db_pre[hIndex].func; + preHookFunc(); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapreg.load_str_db(); + } + if (HPMHooks.count.HP_mapreg_load_str_db_post > 0) { + void (*postHookFunc) (void); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_str_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_load_str_db_post[hIndex].func; + postHookFunc(); + } + } + return; +} void HP_mapreg_load(void) { int hIndex = 0; if (HPMHooks.count.HP_mapreg_load_pre > 0) { @@ -50804,6 +50912,58 @@ void HP_mapreg_load(void) { } return; } +void HP_mapreg_save_num_db(const char *name, unsigned int index, int value) { + int hIndex = 0; + if (HPMHooks.count.HP_mapreg_save_num_db_pre > 0) { + void (*preHookFunc) (const char **name, unsigned int *index, int *value); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_num_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_save_num_db_pre[hIndex].func; + preHookFunc(&name, &index, &value); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapreg.save_num_db(name, index, value); + } + if (HPMHooks.count.HP_mapreg_save_num_db_post > 0) { + void (*postHookFunc) (const char *name, unsigned int index, int value); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_num_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_save_num_db_post[hIndex].func; + postHookFunc(name, index, value); + } + } + return; +} +void HP_mapreg_save_str_db(const char *name, unsigned int index, const char *value) { + int hIndex = 0; + if (HPMHooks.count.HP_mapreg_save_str_db_pre > 0) { + void (*preHookFunc) (const char **name, unsigned int *index, const char **value); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_str_db_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_save_str_db_pre[hIndex].func; + preHookFunc(&name, &index, &value); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapreg.save_str_db(name, index, value); + } + if (HPMHooks.count.HP_mapreg_save_str_db_post > 0) { + void (*postHookFunc) (const char *name, unsigned int index, const char *value); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_str_db_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_save_str_db_post[hIndex].func; + postHookFunc(name, index, value); + } + } + return; +} void HP_mapreg_save(void) { int hIndex = 0; if (HPMHooks.count.HP_mapreg_save_pre > 0) { @@ -50916,14 +51076,14 @@ void HP_mapreg_reload(void) { } return; } -bool HP_mapreg_config_read(const char *filename, const struct config_setting_t *config, bool imported) { +bool HP_mapreg_config_read_registry(const char *filename, const struct config_setting_t *config, bool imported) { int hIndex = 0; bool retVal___ = false; - if (HPMHooks.count.HP_mapreg_config_read_pre > 0) { + if (HPMHooks.count.HP_mapreg_config_read_registry_pre > 0) { bool (*preHookFunc) (const char **filename, const struct config_setting_t **config, bool *imported); *HPMforce_return = false; - for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_pre; hIndex++) { - preHookFunc = HPMHooks.list.HP_mapreg_config_read_pre[hIndex].func; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_registry_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_config_read_registry_pre[hIndex].func; retVal___ = preHookFunc(&filename, &config, &imported); } if (*HPMforce_return) { @@ -50932,17 +51092,69 @@ bool HP_mapreg_config_read(const char *filename, const struct config_setting_t * } } { - retVal___ = HPMHooks.source.mapreg.config_read(filename, config, imported); + retVal___ = HPMHooks.source.mapreg.config_read_registry(filename, config, imported); } - if (HPMHooks.count.HP_mapreg_config_read_post > 0) { + if (HPMHooks.count.HP_mapreg_config_read_registry_post > 0) { bool (*postHookFunc) (bool retVal___, const char *filename, const struct config_setting_t *config, bool imported); - for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_post; hIndex++) { - postHookFunc = HPMHooks.list.HP_mapreg_config_read_post[hIndex].func; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_registry_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_config_read_registry_post[hIndex].func; retVal___ = postHookFunc(retVal___, filename, config, imported); } } return retVal___; } +void HP_mapreg_final(void) { + int hIndex = 0; + if (HPMHooks.count.HP_mapreg_final_pre > 0) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_final_pre[hIndex].func; + preHookFunc(); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapreg.final(); + } + if (HPMHooks.count.HP_mapreg_final_post > 0) { + void (*postHookFunc) (void); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_mapreg_init(void) { + int hIndex = 0; + if (HPMHooks.count.HP_mapreg_init_pre > 0) { + void (*preHookFunc) (void); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_mapreg_init_pre[hIndex].func; + preHookFunc(); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.mapreg.init(); + } + if (HPMHooks.count.HP_mapreg_init_post > 0) { + void (*postHookFunc) (void); + for (hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_mapreg_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} /* md5_interface */ void HP_md5_string(const char *string, char *output) { int hIndex = 0; @@ -71749,14 +71961,14 @@ bool HP_script_get_constant(const char *name, int *value) { } return retVal___; } -void HP_script_label_add(int key, int pos) { +void HP_script_label_add(int key, int pos, enum script_label_flags flags) { int hIndex = 0; if (HPMHooks.count.HP_script_label_add_pre > 0) { - void (*preHookFunc) (int *key, int *pos); + void (*preHookFunc) (int *key, int *pos, enum script_label_flags *flags); *HPMforce_return = false; for (hIndex = 0; hIndex < HPMHooks.count.HP_script_label_add_pre; hIndex++) { preHookFunc = HPMHooks.list.HP_script_label_add_pre[hIndex].func; - preHookFunc(&key, &pos); + preHookFunc(&key, &pos, &flags); } if (*HPMforce_return) { *HPMforce_return = false; @@ -71764,13 +71976,13 @@ void HP_script_label_add(int key, int pos) { } } { - HPMHooks.source.script.label_add(key, pos); + HPMHooks.source.script.label_add(key, pos, flags); } if (HPMHooks.count.HP_script_label_add_post > 0) { - void (*postHookFunc) (int key, int pos); + void (*postHookFunc) (int key, int pos, enum script_label_flags flags); for (hIndex = 0; hIndex < HPMHooks.count.HP_script_label_add_post; hIndex++) { postHookFunc = HPMHooks.list.HP_script_label_add_post[hIndex].func; - postHookFunc(key, pos); + postHookFunc(key, pos, flags); } } return; @@ -72625,6 +72837,33 @@ const char* HP_script_parse_syntax(const char *p) { } return retVal___; } +const char* HP_script_parse_syntax_function(const char *p, bool is_public) { + int hIndex = 0; + const char* retVal___ = NULL; + if (HPMHooks.count.HP_script_parse_syntax_function_pre > 0) { + const char* (*preHookFunc) (const char **p, bool *is_public); + *HPMforce_return = false; + for (hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_function_pre; hIndex++) { + preHookFunc = HPMHooks.list.HP_script_parse_syntax_function_pre[hIndex].func; + retVal___ = preHookFunc(&p, &is_public); + } + if (*HPMforce_return) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.script.parse_syntax_function(p, is_public); + } + if (HPMHooks.count.HP_script_parse_syntax_function_post > 0) { + const char* (*postHookFunc) (const char* retVal___, const char *p, bool is_public); + for (hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_function_post; hIndex++) { + postHookFunc = HPMHooks.list.HP_script_parse_syntax_function_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p, is_public); + } + } + return retVal___; +} c_op HP_script_get_com(const struct script_buf *scriptbuf, int *pos) { int hIndex = 0; c_op retVal___ = C_NOP; |