1 files changed, 0 insertions, 373 deletions

diff --git a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc
index 290c2283a..097b4b283 100644
--- a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc
@@ -4716,379 +4716,6 @@ bool HP_login_config_read(const char *filename, bool included) {
 	}
 	return retVal___;
 }
-/* malloc_interface */
-void HP_iMalloc_init(void) {
-	int hIndex = 0;
-	if( HPMHooks.count.HP_iMalloc_init_pre ) {
-		void (*preHookFunc) (void);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_init_pre[hIndex].func;
-			preHookFunc();
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return;
-		}
-	}
-	{
-		HPMHooks.source.iMalloc.init();
-	}
-	if( HPMHooks.count.HP_iMalloc_init_post ) {
-		void (*postHookFunc) (void);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_init_post[hIndex].func;
-			postHookFunc();
-		}
-	}
-	return;
-}
-void HP_iMalloc_final(void) {
-	int hIndex = 0;
-	if( HPMHooks.count.HP_iMalloc_final_pre ) {
-		void (*preHookFunc) (void);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_final_pre[hIndex].func;
-			preHookFunc();
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return;
-		}
-	}
-	{
-		HPMHooks.source.iMalloc.final();
-	}
-	if( HPMHooks.count.HP_iMalloc_final_post ) {
-		void (*postHookFunc) (void);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_final_post[hIndex].func;
-			postHookFunc();
-		}
-	}
-	return;
-}
-void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *func) {
-	int hIndex = 0;
-	void* retVal___ = NULL;
-	if( HPMHooks.count.HP_iMalloc_malloc_pre ) {
-		void* (*preHookFunc) (size_t *size, const char **file, int *line, const char **func);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func;
-			retVal___ = preHookFunc(&size, &file, &line, &func);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func);
-	}
-	if( HPMHooks.count.HP_iMalloc_malloc_post ) {
-		void* (*postHookFunc) (void* retVal___, size_t size, const char *file, int line, const char *func);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func;
-			retVal___ = postHookFunc(retVal___, size, file, line, func);
-		}
-	}
-	return retVal___;
-}
-void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, const char *func) {
-	int hIndex = 0;
-	void* retVal___ = NULL;
-	if( HPMHooks.count.HP_iMalloc_calloc_pre ) {
-		void* (*preHookFunc) (size_t *num, size_t *size, const char **file, int *line, const char **func);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func;
-			retVal___ = preHookFunc(&num, &size, &file, &line, &func);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func);
-	}
-	if( HPMHooks.count.HP_iMalloc_calloc_post ) {
-		void* (*postHookFunc) (void* retVal___, size_t num, size_t size, const char *file, int line, const char *func);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func;
-			retVal___ = postHookFunc(retVal___, num, size, file, line, func);
-		}
-	}
-	return retVal___;
-}
-void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const char *func) {
-	int hIndex = 0;
-	void* retVal___ = NULL;
-	if( HPMHooks.count.HP_iMalloc_realloc_pre ) {
-		void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func;
-			retVal___ = preHookFunc(&p, &size, &file, &line, &func);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func);
-	}
-	if( HPMHooks.count.HP_iMalloc_realloc_post ) {
-		void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func;
-			retVal___ = postHookFunc(retVal___, p, size, file, line, func);
-		}
-	}
-	return retVal___;
-}
-void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, const char *func) {
-	int hIndex = 0;
-	void* retVal___ = NULL;
-	if( HPMHooks.count.HP_iMalloc_reallocz_pre ) {
-		void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func;
-			retVal___ = preHookFunc(&p, &size, &file, &line, &func);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func);
-	}
-	if( HPMHooks.count.HP_iMalloc_reallocz_post ) {
-		void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func;
-			retVal___ = postHookFunc(retVal___, p, size, file, line, func);
-		}
-	}
-	return retVal___;
-}
-char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char *func) {
-	int hIndex = 0;
-	char* retVal___ = NULL;
-	if( HPMHooks.count.HP_iMalloc_astrdup_pre ) {
-		char* (*preHookFunc) (const char **p, const char **file, int *line, const char **func);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func;
-			retVal___ = preHookFunc(&p, &file, &line, &func);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func);
-	}
-	if( HPMHooks.count.HP_iMalloc_astrdup_post ) {
-		char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int line, const char *func);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func;
-			retVal___ = postHookFunc(retVal___, p, file, line, func);
-		}
-	}
-	return retVal___;
-}
-char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line, const char *func) {
-	int hIndex = 0;
-	char* retVal___ = NULL;
-	if( HPMHooks.count.HP_iMalloc_astrndup_pre ) {
-		char* (*preHookFunc) (const char **p, size_t *size, const char **file, int *line, const char **func);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_astrndup_pre[hIndex].func;
-			retVal___ = preHookFunc(&p, &size, &file, &line, &func);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		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);
-		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);
-		}
-	}
-	return retVal___;
-}
-void HP_iMalloc_free(void *p, const char *file, int line, const char *func) {
-	int hIndex = 0;
-	if( HPMHooks.count.HP_iMalloc_free_pre ) {
-		void (*preHookFunc) (void **p, const char **file, int *line, const char **func);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func;
-			preHookFunc(&p, &file, &line, &func);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return;
-		}
-	}
-	{
-		HPMHooks.source.iMalloc.free(p, file, line, func);
-	}
-	if( HPMHooks.count.HP_iMalloc_free_post ) {
-		void (*postHookFunc) (void *p, const char *file, int line, const char *func);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func;
-			postHookFunc(p, file, line, func);
-		}
-	}
-	return;
-}
-void HP_iMalloc_memory_check(void) {
-	int hIndex = 0;
-	if( HPMHooks.count.HP_iMalloc_memory_check_pre ) {
-		void (*preHookFunc) (void);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_memory_check_pre[hIndex].func;
-			preHookFunc();
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return;
-		}
-	}
-	{
-		HPMHooks.source.iMalloc.memory_check();
-	}
-	if( HPMHooks.count.HP_iMalloc_memory_check_post ) {
-		void (*postHookFunc) (void);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_memory_check_post[hIndex].func;
-			postHookFunc();
-		}
-	}
-	return;
-}
-bool HP_iMalloc_verify_ptr(void *ptr) {
-	int hIndex = 0;
-	bool retVal___ = false;
-	if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) {
-		bool (*preHookFunc) (void **ptr);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func;
-			retVal___ = preHookFunc(&ptr);
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		retVal___ = HPMHooks.source.iMalloc.verify_ptr(ptr);
-	}
-	if( HPMHooks.count.HP_iMalloc_verify_ptr_post ) {
-		bool (*postHookFunc) (bool retVal___, void *ptr);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_post[hIndex].func;
-			retVal___ = postHookFunc(retVal___, ptr);
-		}
-	}
-	return retVal___;
-}
-size_t HP_iMalloc_usage(void) {
-	int hIndex = 0;
-	size_t retVal___ = 0;
-	if( HPMHooks.count.HP_iMalloc_usage_pre ) {
-		size_t (*preHookFunc) (void);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_usage_pre[hIndex].func;
-			retVal___ = preHookFunc();
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return retVal___;
-		}
-	}
-	{
-		retVal___ = HPMHooks.source.iMalloc.usage();
-	}
-	if( HPMHooks.count.HP_iMalloc_usage_post ) {
-		size_t (*postHookFunc) (size_t retVal___);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_usage_post[hIndex].func;
-			retVal___ = postHookFunc(retVal___);
-		}
-	}
-	return retVal___;
-}
-void HP_iMalloc_post_shutdown(void) {
-	int hIndex = 0;
-	if( HPMHooks.count.HP_iMalloc_post_shutdown_pre ) {
-		void (*preHookFunc) (void);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_pre[hIndex].func;
-			preHookFunc();
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return;
-		}
-	}
-	{
-		HPMHooks.source.iMalloc.post_shutdown();
-	}
-	if( HPMHooks.count.HP_iMalloc_post_shutdown_post ) {
-		void (*postHookFunc) (void);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_post[hIndex].func;
-			postHookFunc();
-		}
-	}
-	return;
-}
-void HP_iMalloc_init_messages(void) {
-	int hIndex = 0;
-	if( HPMHooks.count.HP_iMalloc_init_messages_pre ) {
-		void (*preHookFunc) (void);
-		*HPMforce_return = false;
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_pre; hIndex++ ) {
-			preHookFunc = HPMHooks.list.HP_iMalloc_init_messages_pre[hIndex].func;
-			preHookFunc();
-		}
-		if( *HPMforce_return ) {
-			*HPMforce_return = false;
-			return;
-		}
-	}
-	{
-		HPMHooks.source.iMalloc.init_messages();
-	}
-	if( HPMHooks.count.HP_iMalloc_init_messages_post ) {
-		void (*postHookFunc) (void);
-		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_post; hIndex++ ) {
-			postHookFunc = HPMHooks.list.HP_iMalloc_init_messages_post[hIndex].func;
-			postHookFunc();
-		}
-	}
-	return;
-}
 /* md5_interface */
 void HP_md5_string(const char *string, char *output) {
 	int hIndex = 0;