(svn r221) -Feature: console command and variable hooking

-Fix: added another network.c stub
-Consolecommand: "scrollto <tile>" center main view on <tile> [Darkvater]
-Consolecommand: "resettile <tile>" force bulldoze <tile> without any checks (DEBUG only) [Darkvater]
-Fix: resetengines is hooked to be not available in network games
-Codechange: "connect <connectstr>": the connect command now uses a connectionstring like the network-gui
-Fix: Direct Connect editbox can handle up to max ~35 characters [Darkvater]

1 files changed, 810 insertions, 908 deletions

diff --git a/console.c b/console.c
index 50bae0353..05012fbc3 100644
--- a/console.c
+++ b/console.c
@@ -9,7 +9,6 @@
 #include <stdarg.h>
 #include "console.h"
 
-
 // ** main console ** //
 static bool _iconsole_inited;
 static byte* _iconsole_buffer[80];
@@ -20,15 +19,19 @@ static byte _iconsole_mode = ICONSOLE_CLOSED;
 static Window *_iconsole_win = NULL;
 static byte _iconsole_scroll;
 
-// ** main console cmd buffer ** // sign_de: especialy for Celestar :D
-static byte* _iconsole_cmdbuffer[20];
-static byte _iconsole_cmdbufferpos;
-
 // ** console cursor ** //
 static bool _icursor_state;
 static byte _icursor_rate;
 static byte _icursor_counter;
 
+// ** stdlib ** //
+byte _stdlib_developer=1;
+bool _stdlib_con_developer=false;
+
+// ** main console cmd buffer ** // sign_de: especialy for Celestar :D
+static byte* _iconsole_cmdbuffer[20];
+static byte _iconsole_cmdbufferpos;
+
 // ** console window ** //
 static void IConsoleWndProc(Window *w, WindowEvent *e);
 static const Widget _iconsole_window_widgets[] = {{WIDGETS_END}};
@@ -40,15 +43,6 @@ static const WindowDesc _iconsole_window_desc = {
 	IConsoleWndProc,
 };
 
-// ** console parser ** //
-static _iconsole_cmd * _iconsole_cmds; // list of registred commands
-static _iconsole_var * _iconsole_vars; // list of registred vars
-
-// ** console std lib ** //
-static byte _stdlib_developer=1;
-static bool _stdlib_con_developer=false;
-static void IConsoleStdLibRegister();
-
 /* *************** */
 /*  end of header  */
 /* *************** */
@@ -188,57 +182,58 @@ static void IConsoleWndProc(Window *w, WindowEvent *e)
 
 void IConsoleInit()
 {
-int i;
-#if defined(WITH_REV)
-extern char _openttd_revision[];
-#endif
-_iconsole_color_default = 1;
-_iconsole_color_error = 3;
-_iconsole_color_debug = 5;
-_iconsole_color_commands = 2;
-_iconsole_scroll=79;
-_iconsole_cmdbufferpos=19;
-_iconsole_inited=true;
-_iconsole_mode=ICONSOLE_CLOSED;
-_iconsole_win=NULL;
-_icursor_state=false;
-_icursor_rate=5;
-_icursor_counter=0;
-for (i=0;i<20;i++) {
-	_iconsole_cmdbuffer[i]=NULL;
-	}
-for (i=0;i<80;i++) {
-	_iconsole_buffer[i]=NULL;
-	_iconsole_cbuffer[i]=0;
-	}
-IConsoleStdLibRegister();
-#if defined(WITH_REV)
-IConsolePrintF(13,"OpenTTD Game Console Revision 3 - %s",_openttd_revision);
-#else
-IConsolePrint(13,"OpenTTD Game Console Revision 3");
-#endif
-IConsolePrint(12,"---------------------------------");
-IConsolePrint(12,"use \"help\" for more info");
-IConsolePrint(12,"");
-IConsoleClearCommand();
-IConsoleCmdBufferAdd("");
+	int i;
+	#if defined(WITH_REV)
+	extern char _openttd_revision[];
+	#endif
+	_iconsole_color_default = 1;
+	_iconsole_color_error = 3;
+	_iconsole_color_debug = 5;
+	_iconsole_color_commands = 2;
+	_iconsole_scroll=79;
+	_iconsole_cmdbufferpos=19;
+	_iconsole_inited=true;
+	_iconsole_mode=ICONSOLE_CLOSED;
+	_iconsole_win=NULL;
+	_icursor_state=false;
+	_icursor_rate=5;
+	_icursor_counter=0;
+	for (i=0;i<20;i++) {
+		_iconsole_cmdbuffer[i]=NULL;
+		}
+	for (i=0;i<80;i++) {
+		_iconsole_buffer[i]=NULL;
+		_iconsole_cbuffer[i]=0;
+		}
+	IConsoleStdLibRegister();
+	#if defined(WITH_REV)
+	IConsolePrintF(13,"OpenTTD Game Console Revision 3 - %s",_openttd_revision);
+	#else
+	IConsolePrint(13,"OpenTTD Game Console Revision 3");
+	#endif
+	IConsolePrint(12,"---------------------------------");
+	IConsolePrint(12,"use \"help\" for more info");
+	IConsolePrint(12,"");
+	IConsoleClearCommand();
+	IConsoleCmdBufferAdd("");
 }
 
 void IConsoleClear()
 {
-int i;
-for (i=0;i<80;i++) if (_iconsole_buffer[i]!=NULL) {
-	free(_iconsole_buffer[i]);
-	}
+	int i;
+	for (i=0;i<80;i++) if (_iconsole_buffer[i]!=NULL) {
+		free(_iconsole_buffer[i]);
+		}
 }
 
 void IConsoleFree()
 {
-_iconsole_inited=false;
-IConsoleClear();
+	_iconsole_inited=false;
+	IConsoleClear();
 }
 
-void IConsoleResize() {
+void IConsoleResize()
+{
 	if (_iconsole_win!=NULL) {
 		_iconsole_win->height = _screen.height / 3;
 		_iconsole_win->width= _screen.width;
@@ -263,80 +258,84 @@ void IConsoleSwitch()
 	_video_driver->make_dirty(0,0,_screen.width,_screen.height);
 }
 
-void IConsoleClose() {
-if (_iconsole_mode==ICONSOLE_OPENED)  IConsoleSwitch();
-_iconsole_mode=ICONSOLE_CLOSED;
+void IConsoleClose()
+{
+	if (_iconsole_mode==ICONSOLE_OPENED)  IConsoleSwitch();
+	_iconsole_mode=ICONSOLE_CLOSED;
 }
 
-void IConsoleOpen() {
-if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();
+void IConsoleOpen()
+{
+	if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();
 }
 
-void IConsoleCmdBufferAdd(byte * cmd) {
-int i;
-if (_iconsole_cmdbufferpos != 19) return;
-if (_iconsole_cmdbuffer[18]!=NULL) free(_iconsole_cmdbuffer[18]);
-for (i=18; i>0; i--) _iconsole_cmdbuffer[i]=_iconsole_cmdbuffer[i-1];
-i=strlen((char *)cmd);
-_iconsole_cmdbuffer[0]=malloc(i+1);
-memset(((void *)_iconsole_cmdbuffer[0]),0,i+1);
-memcpy(((void *)_iconsole_cmdbuffer[0]),(void *)cmd,i);
-_iconsole_cmdbuffer[0][i]=0;
-_iconsole_cmdbufferpos = 19;
+void IConsoleCmdBufferAdd(byte * cmd)
+{
+	int i;
+	if (_iconsole_cmdbufferpos != 19) return;
+	if (_iconsole_cmdbuffer[18]!=NULL) free(_iconsole_cmdbuffer[18]);
+	for (i=18; i>0; i--) _iconsole_cmdbuffer[i]=_iconsole_cmdbuffer[i-1];
+	i=strlen((char *)cmd);
+	_iconsole_cmdbuffer[0]=malloc(i+1);
+	memset(((void *)_iconsole_cmdbuffer[0]),0,i+1);
+	memcpy(((void *)_iconsole_cmdbuffer[0]),(void *)cmd,i);
+	_iconsole_cmdbuffer[0][i]=0;
+	_iconsole_cmdbufferpos = 19;
 }
 
-void IConsoleCmdBufferNavigate(signed char direction) {
-int i;
-i=_iconsole_cmdbufferpos + direction;
-if (i<0) i=19;
-if (i>19) i=0;
-if (direction>0) while (_iconsole_cmdbuffer[i]==NULL) {
-	i++;
-	if (i>19) i=0;
-	}
-if (direction<0) while (_iconsole_cmdbuffer[i]==NULL) {
-	i--;
+void IConsoleCmdBufferNavigate(signed char direction)
+{
+	int i;
+	i=_iconsole_cmdbufferpos + direction;
 	if (i<0) i=19;
-	}
-_iconsole_cmdbufferpos = i;
-IConsoleClearCommand();
-memcpy((void *)_iconsole_cmdline,(void *)_iconsole_cmdbuffer[i],strlen(_iconsole_cmdbuffer[i]));
-_iconsole_cmdpos =strlen(_iconsole_cmdbuffer[i]);
+	if (i>19) i=0;
+	if (direction>0) while (_iconsole_cmdbuffer[i]==NULL) {
+		i++;
+		if (i>19) i=0;
+		}
+	if (direction<0) while (_iconsole_cmdbuffer[i]==NULL) {
+		i--;
+		if (i<0) i=19;
+		}
+	_iconsole_cmdbufferpos = i;
+	IConsoleClearCommand();
+	memcpy((void *)_iconsole_cmdline,(void *)_iconsole_cmdbuffer[i],strlen(_iconsole_cmdbuffer[i]));
+	_iconsole_cmdpos =strlen(_iconsole_cmdbuffer[i]);
 }
 
 void IConsolePrint(byte color_code, byte* string)
 {
-byte * _ex;
-byte * _new;
-byte _exc;
-byte _newc;
-int i,j;
-
-if (!_iconsole_inited) return;
-
-_newc=color_code;
-i=strlen((char *)string);
-_new=malloc(i+1);
-memset(_new,0,i+1);
-memcpy(_new,string,i);
-
-for (j=0;j<i;j++) {
-	if (_new[j]<0x1F) _new[j]=0x20;
-	}
+	byte * _ex;
+	byte * _new;
+	byte _exc;
+	byte _newc;
+	int i,j;
 
-i=79;
-while (i>=0) {
-	_ex=_iconsole_buffer[i];
-	_exc=_iconsole_cbuffer[i];
-	_iconsole_buffer[i]=_new;
-	_iconsole_cbuffer[i]=_newc;
-	_new=_ex;
-	_newc=_exc;
-	i--;
-	}
-if (_ex!=NULL) free(_ex);
+	if (!_iconsole_inited) return;
+
+	_newc=color_code;
+	i=strlen((char *)string);
+	_new=malloc(i+1);
+	memset(_new,0,i+1);
+	memcpy(_new,string,i);
+
+	for (j=0;j<i;j++) {
+		if (_new[j]<0x1F) _new[j]=0x20;
+		}
+
+	i=79;
+	while (i>=0) {
+		_ex=_iconsole_buffer[i];
+		_exc=_iconsole_cbuffer[i];
+		_iconsole_buffer[i]=_new;
+		_iconsole_cbuffer[i]=_newc;
+		_new=_ex;
+		_newc=_exc;
+		i--;
+		}
+	if (_ex!=NULL) free(_ex);
 
-if (_iconsole_win!=NULL) SetWindowDirty(_iconsole_win);
+	if (_iconsole_win!=NULL) SetWindowDirty(_iconsole_win);
 }
 
 
@@ -350,247 +349,277 @@ void CDECL IConsolePrintF(byte color_code, const char *s, ...)
 	IConsolePrint(color_code, (byte *) &buf);
 }
 
-void IConsoleDebug(byte* string) {
-if (_stdlib_developer>1) IConsolePrintF(_iconsole_color_debug, "DEBUG: %s", string);
+void IConsoleDebug(byte* string)
+{
+	if (_stdlib_developer>1) IConsolePrintF(_iconsole_color_debug, "DEBUG: %s", string);
 }
 
-void IConsoleError(byte* string) {
-if (_stdlib_developer>0) IConsolePrintF(_iconsole_color_error, "ERROR: %s", string);
+void IConsoleError(byte* string)
+{
+	if (_stdlib_developer>0) IConsolePrintF(_iconsole_color_error, "ERROR: %s", string);
 }
 
-void IConsoleCmdRegister(byte * name, void * addr) {
-byte * _new;
-_iconsole_cmd * item;
-_iconsole_cmd * item_new;
-int i;
-
-	i=strlen((char *)name);
-	_new=malloc(i+1);
-	memset(_new,0,i+1);
-	memcpy(_new,name,i);
+void IConsoleCmdRegister(byte * name, void * addr)
+{
+	byte * _new;
+	_iconsole_cmd * item;
+	_iconsole_cmd * item_new;
+	int i;
 
-item_new = malloc(sizeof(_iconsole_cmd));
+		i=strlen((char *)name);
+		_new=malloc(i+1);
+		memset(_new,0,i+1);
+		memcpy(_new,name,i);
 
-item_new->_next = NULL;
-item_new->addr  = addr;
-item_new->name  = _new;
+	item_new = malloc(sizeof(_iconsole_cmd));
 
-item = _iconsole_cmds;
-if (item == NULL) {
-	_iconsole_cmds = item_new;
-	} else {
-	while (item->_next != NULL) { item = item->_next; };
-	item->_next = item_new;
-	}
-}
+	item_new->_next = NULL;
+	item_new->addr  = addr;
+	item_new->name  = _new;
 
-void* IConsoleCmdGetAddr(byte * name) {
-_iconsole_cmd * item;
+	item_new->hook_access = NULL;
+	item_new->hook_after_exec = NULL;
+	item_new->hook_before_exec = NULL;
 
-item = _iconsole_cmds;
-while (item != NULL) {
-	if (strcmp(item->name,name)==0) return item->addr;
-	item = item->_next;
-	}
-return NULL;
+	item = _iconsole_cmds;
+	if (item == NULL) {
+		_iconsole_cmds = item_new;
+		} else {
+		while (item->_next != NULL) { item = item->_next; };
+		item->_next = item_new;
+		}
 }
 
-void IConsoleVarRegister(byte * name, void * addr, byte type) {
-byte * _new;
-_iconsole_var * item;
-_iconsole_var * item_new;
-int i;
-
-	i=strlen((char *)name)+1;
-	_new=malloc(i+1);
-	memset(_new,0,i+1);
-	_new[0]='*';
-	memcpy(_new+1,name,i);
+void* IConsoleCmdGet(byte * name)
+{
+	_iconsole_cmd * item;
 
-item_new = malloc(sizeof(_iconsole_var));
+	item = _iconsole_cmds;
+	while (item != NULL) {
+		if (strcmp(item->name,name)==0) return item;
+		item = item->_next;
+		}
+	return NULL;
+}
 
-item_new->_next = NULL;
-item_new->addr  = addr;
-item_new->name  = _new;
-item_new->type  = type;
-item_new->_malloc = false;
+void IConsoleVarRegister(byte * name, void * addr, byte type)
+{
+	byte * _new;
+	_iconsole_var * item;
+	_iconsole_var * item_new;
+	int i;
+
+		i=strlen((char *)name)+1;
+		_new=malloc(i+1);
+		memset(_new,0,i+1);
+		_new[0]='*';
+		memcpy(_new+1,name,i);
+
+	item_new = malloc(sizeof(_iconsole_var));
+
+	item_new->_next = NULL;
+	item_new->addr  = addr;
+	item_new->name  = _new;
+	item_new->type  = type;
+	item_new->_malloc = false;
+
+	item_new->hook_access = NULL;
+	item_new->hook_after_change = NULL;
+	item_new->hook_before_change = NULL;
+
+	item = _iconsole_vars;
+	if (item == NULL) {
+		_iconsole_vars = item_new;
+		} else {
+		while (item->_next != NULL) { item = item->_next; };
+		item->_next = item_new;
+		}
+}
 
-item = _iconsole_vars;
-if (item == NULL) {
-	_iconsole_vars = item_new;
-	} else {
-	while (item->_next != NULL) { item = item->_next; };
-	item->_next = item_new;
-	}
+void IConsoleVarMemRegister(byte * name, byte type)
+{
+	_iconsole_var * item;
+	item = IConsoleVarAlloc(type);
+	IConsoleVarInsert(item,name);
 }
 
-void IConsoleVarInsert(_iconsole_var * var, byte * name) {
-byte * _new;
-_iconsole_var * item;
-_iconsole_var * item_new;
-int i;
 
-item_new = var;
+void IConsoleVarInsert(_iconsole_var * var, byte * name)
+{
+	byte * _new;
+	_iconsole_var * item;
+	_iconsole_var * item_new;
+	int i;
 
-// dont allow to build variable rings
-if (item_new->_next != NULL) return;
+	item_new = var;
 
-	i=strlen((char *)name)+1;
-	_new=malloc(i+1);
-	memset(_new,0,i+1);
-	_new[0]='*';
-	memcpy(_new+1,name,i);
+	// dont allow to build variable rings
+	if (item_new->_next != NULL) return;
 
-item_new->name  = _new;
+		i=strlen((char *)name)+1;
+		_new=malloc(i+1);
+		memset(_new,0,i+1);
+		_new[0]='*';
+		memcpy(_new+1,name,i);
 
-item = _iconsole_vars;
-if (item == NULL) {
-	_iconsole_vars = item_new;
+	item_new->name  = _new;
+
+	item = _iconsole_vars;
+	if (item == NULL) {
+		_iconsole_vars = item_new;
 	} else {
-	while (item->_next != NULL) { item = item->_next; };
-	item->_next = item_new;
+		while (item->_next != NULL) { item = item->_next; };
+		item->_next = item_new;
 	}
 }
 
 
-_iconsole_var * IConsoleVarGet(byte * name) {
-_iconsole_var * item;
-
-item = _iconsole_vars;
-while (item != NULL) {
-	if (strcmp(item->name,name)==0) return item;
-	item = item->_next;
-	}
-return NULL;
-}
+_iconsole_var * IConsoleVarGet(byte * name)
+{
+	_iconsole_var * item;
 
-_iconsole_var * IConsoleVarAlloc(byte type) {
-_iconsole_var * item;
-item=malloc(sizeof(_iconsole_var));
-item->_next = NULL;
-item->name  = "";
-item->type  = type;
-switch (item->type) {
-		case ICONSOLE_VAR_BOOLEAN:
-				{
-				item->addr=malloc(sizeof(bool));
-				memset(item->addr,0,sizeof(bool));
-				item->_malloc=true;
-				}
-				break;
-		case ICONSOLE_VAR_BYTE:
-				{
-				item->addr=malloc(sizeof(byte));
-				memset(item->addr,0,sizeof(byte));
-				item->_malloc=true;
-				}
-				break;
-		case ICONSOLE_VAR_UINT16:
-				{
-				item->addr=malloc(sizeof(unsigned short));
-				memset(item->addr,0,sizeof(unsigned short));
-				item->_malloc=true;
-				}
-				break;
-		case ICONSOLE_VAR_UINT32:
-				{
-				item->addr=malloc(sizeof(unsigned int));
-				memset(item->addr,0,sizeof(unsigned int));
-				item->_malloc=true;
-				}
-				break;
-		case ICONSOLE_VAR_INT16:
-				{
-				item->addr=malloc(sizeof(signed short));
-				memset(item->addr,0,sizeof(signed short));
-				item->_malloc=true;
-				}
-				break;
-		case ICONSOLE_VAR_INT32:
-				{
-				item->addr=malloc(sizeof(signed int));
-				memset(item->addr,0,sizeof(signed int));
-				item->_malloc=true;
-				}
-				break;
-		default:
-				item->addr  = NULL;
-				item->_malloc = false;
-				break;
+	item = _iconsole_vars;
+	while (item != NULL) {
+		if (strcmp(item->name,name)==0) return item;
+		item = item->_next;
 		}
-return item;
+	return NULL;
 }
 
+_iconsole_var * IConsoleVarAlloc(byte type)
+{
+	_iconsole_var * item;
+	item=malloc(sizeof(_iconsole_var));
+	item->_next = NULL;
+	item->name  = "";
+	item->type  = type;
+	switch (item->type) {
+			case ICONSOLE_VAR_BOOLEAN:
+					{
+					item->addr=malloc(sizeof(bool));
+					memset(item->addr,0,sizeof(bool));
+					item->_malloc=true;
+					}
+					break;
+			case ICONSOLE_VAR_BYTE:
+					{
+					item->addr=malloc(sizeof(byte));
+					memset(item->addr,0,sizeof(byte));
+					item->_malloc=true;
+					}
+					break;
+			case ICONSOLE_VAR_UINT16:
+					{
+					item->addr=malloc(sizeof(unsigned short));
+					memset(item->addr,0,sizeof(unsigned short));
+					item->_malloc=true;
+					}
+					break;
+			case ICONSOLE_VAR_UINT32:
+					{
+					item->addr=malloc(sizeof(unsigned int));
+					memset(item->addr,0,sizeof(unsigned int));
+					item->_malloc=true;
+					}
+					break;
+			case ICONSOLE_VAR_INT16:
+					{
+					item->addr=malloc(sizeof(signed short));
+					memset(item->addr,0,sizeof(signed short));
+					item->_malloc=true;
+					}
+					break;
+			case ICONSOLE_VAR_INT32:
+					{
+					item->addr=malloc(sizeof(signed int));
+					memset(item->addr,0,sizeof(signed int));
+					item->_malloc=true;
+					}
+					break;
+			default:
+					item->addr  = NULL;
+					item->_malloc = false;
+					break;
+			}
 
-void IConsoleVarFree(_iconsole_var * var) {
-if (var ->_malloc) {
-	free(var ->addr);
-	}
-free(var);
+	item->hook_access = NULL;
+	item->hook_after_change = NULL;
+	item->hook_before_change = NULL;
+	return item;
 }
 
-void IConsoleVarSetString(_iconsole_var * var, byte * string) {
-int l;
 
-if (string == NULL) return;
+void IConsoleVarFree(_iconsole_var * var)
+{
+	if (var ->_malloc) {
+		free(var ->addr);
+		}
+	free(var);
+}
 
-if (var->_malloc) {
-	free(var->addr);
-	}
+void IConsoleVarSetString(_iconsole_var * var, byte * string)
+{
+	int l;
 
-l=strlen((char *) string);
-var->addr=malloc(l+1);
-var->_malloc=true;
-memset(var->addr,0,l);
-memcpy((void *) var->addr,(void *) string, l);
-((byte *)var->addr)[l]=0;
-}
+	if (string == NULL) return;
 
-void IConsoleVarSetValue(_iconsole_var * var, int value) {
-switch (var->type) {
-		case ICONSOLE_VAR_BOOLEAN:
-				{
-				(*(bool *)var->addr)=(value!=0);
-				}
-				break;
-		case ICONSOLE_VAR_BYTE:
-				{
-				(*(byte *)var->addr)=value;
-				}
-				break;
-		case ICONSOLE_VAR_UINT16:
-				{
-				(*(unsigned short *)var->addr)=value;
-				}
-				break;
-		case ICONSOLE_VAR_UINT32:
-				{
-				(*(unsigned int *)var->addr)=value;
-				}
-				break;
-		case ICONSOLE_VAR_INT16:
-				{
-				(*(signed short *)var->addr)=value;
-				}
-				break;
-		case ICONSOLE_VAR_INT32:
-				{
-				(*(signed int *)var->addr)=value;
-				}
-				break;
-		default:
-				break;
+	if (var->_malloc) {
+		free(var->addr);
 		}
-}
 
-void IConsoleVarDump(_iconsole_var * var, byte * dump_desc) {
+	l=strlen((char *) string);
+	var->addr=malloc(l+1);
+	var->_malloc=true;
+	memset(var->addr,0,l);
+	memcpy((void *) var->addr,(void *) string, l);
+	((byte *)var->addr)[l]=0;
+	}
 
-byte var_b; // TYPE BYTE
-unsigned short var_ui16; // TYPE UINT16
-unsigned int var_ui32; // TYPE UINT32
-signed short var_i16; // TYPE INT16
-signed int var_i32; // TYPE INT32
-byte * var_s; // TYPE STRING
+	void IConsoleVarSetValue(_iconsole_var * var, int value) {
+	switch (var->type) {
+			case ICONSOLE_VAR_BOOLEAN:
+					{
+					(*(bool *)var->addr)=(value!=0);
+					}
+					break;
+			case ICONSOLE_VAR_BYTE:
+					{
+					(*(byte *)var->addr)=value;
+					}
+					break;
+			case ICONSOLE_VAR_UINT16:
+					{
+					(*(unsigned short *)var->addr)=value;
+					}
+					break;
+			case ICONSOLE_VAR_UINT32:
+					{
+					(*(unsigned int *)var->addr)=value;
+					}
+					break;
+			case ICONSOLE_VAR_INT16:
+					{
+					(*(signed short *)var->addr)=value;
+					}
+					break;
+			case ICONSOLE_VAR_INT32:
+					{
+					(*(signed int *)var->addr)=value;
+					}
+					break;
+			default:
+					break;
+			}
+}
+
+void IConsoleVarDump(_iconsole_var * var, byte * dump_desc)
+{
+	byte var_b; // TYPE BYTE
+	unsigned short var_ui16; // TYPE UINT16
+	unsigned int var_ui32; // TYPE UINT32
+	signed short var_i16; // TYPE INT16
+	signed int var_i32; // TYPE INT32
+	byte * var_s; // TYPE STRING
 
 	if (dump_desc==NULL) dump_desc = var->name;
 
@@ -651,672 +680,545 @@ byte * var_s; // TYPE STRING
 				}
 				break;
 		}
+}
 
+// * ************************* * //
+// * hooking code              * //
+// * ************************* * //
+
+void IConsoleVarHook(byte * name, byte type, void * proc)
+{
+	_iconsole_var * hook_var;
+	hook_var = IConsoleVarGet(name);
+	if (hook_var == NULL) return;
+	switch (type) {
+	case ICONSOLE_HOOK_BEFORE_CHANGE:
+		hook_var->hook_after_change = proc;
+		break;
+	case ICONSOLE_HOOK_AFTER_CHANGE:
+		hook_var->hook_after_change = proc;
+		break;
+	case ICONSOLE_HOOK_ACCESS:
+		hook_var->hook_access = proc;
+		break;
+	}
 }
 
-void IConsoleCmdExec(byte * cmdstr) {
-_iconsole_var * (*function)(byte argc, byte* argv[], byte argt[]);
-byte * tokens[20];
-byte tokentypes[20];
-byte * tokenstream;
-byte * tokenstream_s;
-byte execution_mode;
-_iconsole_var * var = NULL;
-_iconsole_var * result = NULL;
-
-bool longtoken;
-bool valid_token;
-bool skip_lt_change;
-
-int c;
-int i;
-int l;
-
-//** clearing buffer **//
-
-for (i=0;i<20;i++) { tokens[i]=NULL; tokentypes[i]=ICONSOLE_VAR_NONE; };
-tokenstream_s=tokenstream=malloc(1024);
-memset(tokenstream,0,1024);
-
-//** parsing **//
-
-longtoken=false;
-valid_token=false;
-skip_lt_change=false;
-l=strlen((char *) cmdstr);
-i=0;
-c=0;
-tokens[c] = tokenstream;
-while (i<l) {
-	if (cmdstr[i]=='"') {
-		if (longtoken) {
-			if (cmdstr[i+1]=='"') {
-				i++;
-				*tokenstream = '"';
-				tokenstream++;
-				skip_lt_change=true;
+bool IConsoleVarHookHandle(_iconsole_var * hook_var, byte type)
+{
+	bool (*proc)(_iconsole_var * hook_var);
+	switch (type) {
+	case ICONSOLE_HOOK_BEFORE_CHANGE:
+		proc = hook_var->hook_before_change;
+		break;
+	case ICONSOLE_HOOK_AFTER_CHANGE:
+		proc = hook_var->hook_after_change;
+		break;
+	case ICONSOLE_HOOK_ACCESS:
+		proc = hook_var->hook_access;
+		break;
+	}
+	if (proc == NULL) return true;
+	return proc(hook_var);
+}
+
+void IConsoleCmdHook(byte * name, byte type, void * proc)
+{
+	_iconsole_cmd * hook_cmd;
+	hook_cmd = IConsoleCmdGet(name);
+	if (hook_cmd == NULL) return;
+	switch (type) {
+	case ICONSOLE_HOOK_AFTER_EXEC:
+		hook_cmd->hook_after_exec = proc;
+		break;
+	case ICONSOLE_HOOK_BEFORE_EXEC:
+		hook_cmd->hook_before_exec = proc;
+		break;
+	case ICONSOLE_HOOK_ACCESS:
+		hook_cmd->hook_access = proc;
+		break;
+	}
+}
+
+bool IConsoleCmdHookHandle(_iconsole_cmd * hook_cmd, byte type)
+{
+	bool (*proc)(_iconsole_cmd * hook_cmd);
+	switch (type) {
+	case ICONSOLE_HOOK_AFTER_EXEC:
+		proc = hook_cmd->hook_after_exec;
+		break;
+	case ICONSOLE_HOOK_BEFORE_EXEC:
+		proc = hook_cmd->hook_before_exec;
+		break;
+	case ICONSOLE_HOOK_ACCESS:
+		proc = hook_cmd->hook_access;
+		break;
+	}
+	if (proc == NULL) return true;
+	return proc(hook_cmd);
+}
+
+void IConsoleCmdExec(byte * cmdstr)
+{
+	_iconsole_var * (*function)(byte argc, byte* argv[], byte argt[]);
+	byte * tokens[20];
+	byte tokentypes[20];
+	byte * tokenstream;
+	byte * tokenstream_s;
+	byte execution_mode;
+	_iconsole_var * var = NULL;
+	_iconsole_var * result = NULL;
+	_iconsole_cmd * cmd = NULL;
+
+	bool longtoken;
+	bool valid_token;
+	bool skip_lt_change;
+
+	int c;
+	int i;
+	int l;
+
+	//** clearing buffer **//
+
+	for (i=0;i<20;i++) { tokens[i]=NULL; tokentypes[i]=ICONSOLE_VAR_NONE; };
+	tokenstream_s=tokenstream=malloc(1024);
+	memset(tokenstream,0,1024);
+
+	//** parsing **//
+
+	longtoken=false;
+	valid_token=false;
+	skip_lt_change=false;
+	l=strlen((char *) cmdstr);
+	i=0;
+	c=0;
+	tokens[c] = tokenstream;
+	while (i<l) {
+		if (cmdstr[i]=='"') {
+			if (longtoken) {
+				if (cmdstr[i+1]=='"') {
+					i++;
+					*tokenstream = '"';
+					tokenstream++;
+					skip_lt_change=true;
+					} else {
+					longtoken=!longtoken;
+					}
 				} else {
 				longtoken=!longtoken;
 				}
-			} else {
-			longtoken=!longtoken;
-			}
-		if (!skip_lt_change) {
-			if (!longtoken) {
-				if (valid_token) {
-					c++;
-					*tokenstream = 0;
-					tokenstream++;
-					tokens[c] = tokenstream;
-					valid_token = false;
+			if (!skip_lt_change) {
+				if (!longtoken) {
+					if (valid_token) {
+						c++;
+						*tokenstream = 0;
+						tokenstream++;
+						tokens[c] = tokenstream;
+						valid_token = false;
+						}
 					}
+				skip_lt_change=false;
 				}
-			skip_lt_change=false;
 			}
-		}
-	else if ((!longtoken) && (cmdstr[i]==' ')) {
-		if (valid_token) {
-			c++;
-			*tokenstream = 0;
+		else if ((!longtoken) && (cmdstr[i]==' ')) {
+			if (valid_token) {
+				c++;
+				*tokenstream = 0;
+				tokenstream++;
+				tokens[c] = tokenstream;
+				valid_token = false;
+				}
+			}
+		else {
+			valid_token=true;
+			*tokenstream = cmdstr[i];
 			tokenstream++;
-			tokens[c] = tokenstream;
-			valid_token = false;
 			}
+		i++;
 		}
-	else {
-		valid_token=true;
-		*tokenstream = cmdstr[i];
+
+	tokenstream--;
+	if (!(*tokenstream==0)) {
+		c++;
 		tokenstream++;
+		*tokenstream = 0;
 		}
-	i++;
-	}
-
-tokenstream--;
-if (!(*tokenstream==0)) {
-	c++;
-	tokenstream++;
-	*tokenstream = 0;
-	}
 
-//** interpreting **//
+	//** interpreting **//
 
-for (i=0; i<c; i++) {
-	tokentypes[i]=ICONSOLE_VAR_UNKNOWN;
-	if (tokens[i]!=NULL) if (i>0) if (strlen((char *) tokens[i])>0) {
-		if (tokens[i][0]=='*') {
-			if ((i==2) && (tokentypes[1]==ICONSOLE_VAR_UNKNOWN) && (strcmp(tokens[1],"<<")==0)) {
-				// dont change the variable to an pointer if execution_mode 4 is being prepared
-				// this is used to assign one variable the value of the other one [token 0 and 2]
-				} else {
-				var = IConsoleVarGet(tokens[i]);
-				if (var!=NULL) {
-					tokens[i]=(byte *)var->addr;
-					tokentypes[i]=var->type;
+	for (i=0; i<c; i++) {
+		tokentypes[i]=ICONSOLE_VAR_UNKNOWN;
+		if (tokens[i]!=NULL) if (i>0) if (strlen((char *) tokens[i])>0) {
+			if (tokens[i][0]=='*') {
+				if ((i==2) && (tokentypes[1]==ICONSOLE_VAR_UNKNOWN) && (strcmp(tokens[1],"<<")==0)) {
+					// dont change the variable to an pointer if execution_mode 4 is being prepared
+					// this is used to assign one variable the value of the other one [token 0 and 2]
+					} else {
+					var = IConsoleVarGet(tokens[i]);
+					if (var!=NULL) {
+						tokens[i]=(byte *)var->addr;
+						tokentypes[i]=var->type;
+						}
 					}
 				}
-			}
-		if (tokens[i]!=NULL) if (tokens[i][0]=='@') if (tokens[i][1]=='*') {
-			var = IConsoleVarGet(tokens[i]+1);
-			if (var!=NULL) {
-				tokens[i]=(byte *)var;
-				tokentypes[i]=ICONSOLE_VAR_REFERENCE;
+			if (tokens[i]!=NULL) if (tokens[i][0]=='@') if (tokens[i][1]=='*') {
+				var = IConsoleVarGet(tokens[i]+1);
+				if (var!=NULL) {
+					tokens[i]=(byte *)var;
+					tokentypes[i]=ICONSOLE_VAR_REFERENCE;
+					}
 				}
 			}
 		}
-	}
 
-execution_mode=0;
+	execution_mode=0;
 
-function = IConsoleCmdGetAddr(tokens[0]);
-if (function != NULL) {
-	execution_mode=1; // this is a command
-	} else {
-	var = IConsoleVarGet(tokens[0]);
-	if (var != NULL) {
-		execution_mode=2; // this is a variable
-		if (c>2) if (strcmp(tokens[1],"<<")==0) {
-			// this is command to variable mode [normal]
-			function = IConsoleCmdGetAddr(tokens[2]);
-			if (function != NULL) {
-				execution_mode=3;
-				} else {
-				result = IConsoleVarGet(tokens[2]);
-				if (result != NULL) {
-					execution_mode=4;
+	function = NULL;
+	cmd = IConsoleCmdGet(tokens[0]);
+	if (cmd != NULL) function = cmd->addr;
+
+	if (function != NULL) {
+		execution_mode=1; // this is a command
+		} else {
+		var = IConsoleVarGet(tokens[0]);
+		if (var != NULL) {
+			execution_mode=2; // this is a variable
+			if (c>2) if (strcmp(tokens[1],"<<")==0) {
+				// this is command to variable mode [normal]
+				
+				function = NULL;
+				cmd = IConsoleCmdGet(tokens[2]);
+				if (cmd != NULL) function = cmd->addr;
+
+				if (function != NULL) {
+					execution_mode=3;
+					} else {
+					result = IConsoleVarGet(tokens[2]);
+					if (result != NULL) {
+						execution_mode=4;
+						}
 					}
 				}
 			}
 		}
-	}
 
-//** executing **//
-if (_stdlib_con_developer) IConsolePrintF(_iconsole_color_debug,"CONDEBUG: execution_mode: %i",execution_mode);
-switch (execution_mode) {
-case 0:
-	{
-	// not found
-	IConsoleError("command or variable not found");
-	}
-	break;
-case 1:
-	{
-	// execution with command syntax
-	result = function(c,tokens,tokentypes);
-	if (result!=NULL) {
-		IConsoleVarDump(result,"result");
-		IConsoleVarFree(result);
+	//** executing **//
+	if (_stdlib_con_developer) IConsolePrintF(_iconsole_color_debug,"CONDEBUG: execution_mode: %i",execution_mode);
+	switch (execution_mode) {
+	case 0:
+		{
+		// not found
+		IConsoleError("command or variable not found");
 		}
-	}
-	break;
-case 2:
-	{
-	// execution with variable syntax
-	if ((c==2) || (c==3)) {
-		// ** variable modifications ** //
-		switch (var->type) {
-		case ICONSOLE_VAR_BOOLEAN:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						*(bool *)var->addr=(atoi((char *) tokens[2])!=0);
+		break;
+	case 1:
+		if (IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_ACCESS)) {
+		// execution with command syntax
+		IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_BEFORE_EXEC);
+		result = function(c,tokens,tokentypes);
+		if (result!=NULL) {
+			IConsoleVarDump(result,"result");
+			IConsoleVarFree(result);
+			}
+		IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_AFTER_EXEC);
+		}
+		break;
+	case 2:
+		{
+		// execution with variable syntax
+		if (IConsoleVarHookHandle(var,ICONSOLE_HOOK_ACCESS)) if ((c==2) || (c==3)) {
+			// ** variable modifications ** //
+			IConsoleVarHookHandle(var,ICONSOLE_HOOK_BEFORE_CHANGE);
+			switch (var->type) {
+			case ICONSOLE_VAR_BOOLEAN:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							*(bool *)var->addr=(atoi((char *) tokens[2])!=0);
+							IConsoleVarDump(var,NULL);
+							} else {
+							*(bool *)var->addr=false;
+							IConsoleVarDump(var,NULL);
+							}
+						}
+					else if (strcmp(tokens[1],"++")==0) {
+						*(bool *)var->addr=!*(bool *)var->addr;
 						IConsoleVarDump(var,NULL);
-						} else {
-						*(bool *)var->addr=false;
+						}
+					else if (strcmp(tokens[1],"--")==0) {
+						*(bool *)var->addr=!*(bool *)var->addr;
 						IConsoleVarDump(var,NULL);
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else if (strcmp(tokens[1],"++")==0) {
-					*(bool *)var->addr=!*(bool *)var->addr;
-					IConsoleVarDump(var,NULL);
-					}
-				else if (strcmp(tokens[1],"--")==0) {
-					*(bool *)var->addr=!*(bool *)var->addr;
-					IConsoleVarDump(var,NULL);
-					}
-				else { IConsoleError("operation not supported"); }
-				}
-				break;
-		case ICONSOLE_VAR_BYTE:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						*(byte *)var->addr=atoi((char *) tokens[2]);
+					break;
+			case ICONSOLE_VAR_BYTE:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							*(byte *)var->addr=atoi((char *) tokens[2]);
+							IConsoleVarDump(var,NULL);
+							} else {
+							*(byte *)var->addr=0;
+							IConsoleVarDump(var,NULL);
+							}
+						}
+					else if (strcmp(tokens[1],"++")==0) {
+						(*(byte *)var->addr)++;
 						IConsoleVarDump(var,NULL);
-						} else {
-						*(byte *)var->addr=0;
+						}
+					else if (strcmp(tokens[1],"--")==0) {
+						(*(byte *)var->addr)--;
 						IConsoleVarDump(var,NULL);
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else if (strcmp(tokens[1],"++")==0) {
-					(*(byte *)var->addr)++;
-					IConsoleVarDump(var,NULL);
-					}
-				else if (strcmp(tokens[1],"--")==0) {
-					(*(byte *)var->addr)--;
-					IConsoleVarDump(var,NULL);
-					}
-				else { IConsoleError("operation not supported"); }
-				}
-				break;
-		case ICONSOLE_VAR_UINT16:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						*(unsigned short *)var->addr=atoi((char *) tokens[2]);
+					break;
+			case ICONSOLE_VAR_UINT16:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							*(unsigned short *)var->addr=atoi((char *) tokens[2]);
+							IConsoleVarDump(var,NULL);
+							} else {
+							*(unsigned short *)var->addr=0;
+							IConsoleVarDump(var,NULL);
+							}
+						}
+					else if (strcmp(tokens[1],"++")==0) {
+						(*(unsigned short *)var->addr)++;
 						IConsoleVarDump(var,NULL);
-						} else {
-						*(unsigned short *)var->addr=0;
+						}
+					else if (strcmp(tokens[1],"--")==0) {
+						(*(unsigned short *)var->addr)--;
 						IConsoleVarDump(var,NULL);
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else if (strcmp(tokens[1],"++")==0) {
-					(*(unsigned short *)var->addr)++;
-					IConsoleVarDump(var,NULL);
-					}
-				else if (strcmp(tokens[1],"--")==0) {
-					(*(unsigned short *)var->addr)--;
-					IConsoleVarDump(var,NULL);
-					}
-				else { IConsoleError("operation not supported"); }
-				}
-				break;
-		case ICONSOLE_VAR_UINT32:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						*(unsigned int *)var->addr=atoi((char *) tokens[2]);
+					break;
+			case ICONSOLE_VAR_UINT32:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							*(unsigned int *)var->addr=atoi((char *) tokens[2]);
+							IConsoleVarDump(var,NULL);
+							} else {
+							*(unsigned int *)var->addr=0;
+							IConsoleVarDump(var,NULL);
+							}
+						}
+					else if (strcmp(tokens[1],"++")==0) {
+						(*(unsigned int *)var->addr)++;
 						IConsoleVarDump(var,NULL);
-						} else {
-						*(unsigned int *)var->addr=0;
+						}
+					else if (strcmp(tokens[1],"--")==0) {
+						(*(unsigned int *)var->addr)--;
 						IConsoleVarDump(var,NULL);
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else if (strcmp(tokens[1],"++")==0) {
-					(*(unsigned int *)var->addr)++;
-					IConsoleVarDump(var,NULL);
-					}
-				else if (strcmp(tokens[1],"--")==0) {
-					(*(unsigned int *)var->addr)--;
-					IConsoleVarDump(var,NULL);
-					}
-				else { IConsoleError("operation not supported"); }
-				}
-				break;
-		case ICONSOLE_VAR_INT16:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						*(signed short *)var->addr=atoi((char *) tokens[2]);
+					break;
+			case ICONSOLE_VAR_INT16:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							*(signed short *)var->addr=atoi((char *) tokens[2]);
+							IConsoleVarDump(var,NULL);
+							} else {
+							*(signed short *)var->addr=0;
+							IConsoleVarDump(var,NULL);
+							}
+						}
+					else if (strcmp(tokens[1],"++")==0) {
+						(*(signed short *)var->addr)++;
 						IConsoleVarDump(var,NULL);
-						} else {
-						*(signed short *)var->addr=0;
+						}
+					else if (strcmp(tokens[1],"--")==0) {
+						(*(signed short *)var->addr)--;
 						IConsoleVarDump(var,NULL);
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else if (strcmp(tokens[1],"++")==0) {
-					(*(signed short *)var->addr)++;
-					IConsoleVarDump(var,NULL);
-					}
-				else if (strcmp(tokens[1],"--")==0) {
-					(*(signed short *)var->addr)--;
-					IConsoleVarDump(var,NULL);
-					}
-				else { IConsoleError("operation not supported"); }
-				}
-				break;
-		case ICONSOLE_VAR_INT32:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						*(signed int *)var->addr=atoi((char *) tokens[2]);
+					break;
+			case ICONSOLE_VAR_INT32:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							*(signed int *)var->addr=atoi((char *) tokens[2]);
+							IConsoleVarDump(var,NULL);
+							} else {
+							*(signed int *)var->addr=0;
+							IConsoleVarDump(var,NULL);
+							}
+						}
+					else if (strcmp(tokens[1],"++")==0) {
+						(*(signed int *)var->addr)++;
 						IConsoleVarDump(var,NULL);
-						} else {
-						*(signed int *)var->addr=0;
+						}
+					else if (strcmp(tokens[1],"--")==0) {
+						(*(signed int *)var->addr)--;
 						IConsoleVarDump(var,NULL);
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else if (strcmp(tokens[1],"++")==0) {
-					(*(signed int *)var->addr)++;
-					IConsoleVarDump(var,NULL);
-					}
-				else if (strcmp(tokens[1],"--")==0) {
-					(*(signed int *)var->addr)--;
-					IConsoleVarDump(var,NULL);
-					}
-				else { IConsoleError("operation not supported"); }
-				}
-				break;
-		case ICONSOLE_VAR_STRING:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						IConsoleVarSetString(var, tokens[2]);
-						IConsoleVarDump(var,NULL);
-						} else {
-						IConsoleVarSetString(var, "");
-						IConsoleVarDump(var,NULL);
+					break;
+			case ICONSOLE_VAR_STRING:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							IConsoleVarSetString(var, tokens[2]);
+							IConsoleVarDump(var,NULL);
+							} else {
+							IConsoleVarSetString(var, "");
+							IConsoleVarDump(var,NULL);
+							}
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else { IConsoleError("operation not supported"); }
-				}
-				break;
-		case ICONSOLE_VAR_POINTER:
-				{
-				if (strcmp(tokens[1],"=")==0) {
-					if (c==3) {
-						if (tokentypes[2]==ICONSOLE_VAR_UNKNOWN) {
-							var->addr = (void *)atoi(tokens[2]);
+					break;
+			case ICONSOLE_VAR_POINTER:
+					{
+					if (strcmp(tokens[1],"=")==0) {
+						if (c==3) {
+							if (tokentypes[2]==ICONSOLE_VAR_UNKNOWN) {
+								var->addr = (void *)atoi(tokens[2]);
+								} else {
+								var->addr = (void *)tokens[2];
+								}
+							IConsoleVarDump(var,NULL);
 							} else {
-							var->addr = (void *)tokens[2];
+							var->addr = NULL;
+							IConsoleVarDump(var,NULL);
 							}
+						}
+					else if (strcmp(tokens[1],"++")==0) {
+						var->addr = ((char *)var->addr)+1;
 						IConsoleVarDump(var,NULL);
-						} else {
-						var->addr = NULL;
+						}
+					else if (strcmp(tokens[1],"--")==0) {
+						var->addr = ((char *)var->addr)-1;;
 						IConsoleVarDump(var,NULL);
 						}
+					else { IConsoleError("operation not supported"); }
 					}
-				else if (strcmp(tokens[1],"++")==0) {
-					var->addr = ((char *)var->addr)+1;
-					IConsoleVarDump(var,NULL);
-					}
-				else if (strcmp(tokens[1],"--")==0) {
-					var->addr = ((char *)var->addr)-1;;
-					IConsoleVarDump(var,NULL);
-					}
-				else { IConsoleError("operation not supported"); }
+					break;
 				}
-				break;
+				IConsoleVarHookHandle(var,ICONSOLE_HOOK_AFTER_CHANGE);
+		}
+		if (c==1) {
+			// ** variable output ** //
+			IConsoleVarDump(var,NULL);
 			}
-	}
-	if (c==1) {
-		// ** variable output ** //
-		IConsoleVarDump(var,NULL);
 		}
-	}
-	break;
-case 3:
-case 4:
-	{
-	// execute command with result or assign a variable
-	if (execution_mode==3) {
-		int i;
-		int diff;
-		void * temp;
-		byte temp2;
-
-		// tokenshifting
-		for (diff=0; diff<2; diff++) {
-			temp=tokens[0];
-			temp2=tokentypes[0];
-			for (i=1; i<20; i++) {
-				tokens[i-1]=tokens[i];
-				tokentypes[i-1]=tokentypes[i];
+		break;
+	case 3:
+	case 4:
+		{
+		// execute command with result or assign a variable
+			if (execution_mode==3) if (IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_ACCESS)) {
+			int i;
+			int diff;
+			void * temp;
+			byte temp2;
+
+			// tokenshifting
+			for (diff=0; diff<2; diff++) {
+				temp=tokens[0];
+				temp2=tokentypes[0];
+				for (i=1; i<20; i++) {
+					tokens[i-1]=tokens[i];
+					tokentypes[i-1]=tokentypes[i];
+					}
+				tokens[19]=temp;
+				tokentypes[19]=temp2;
 				}
-			tokens[19]=temp;
-			tokentypes[19]=temp2;
+			IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_BEFORE_EXEC);
+			result = function(c,tokens,tokentypes);
+			IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_AFTER_EXEC);
+			} else {
+				execution_mode=255;
 			}
 
-		result = function(c,tokens,tokentypes);
-		}
-
-	if (result!=NULL) {
-		if (result ->type != var -> type) {
-			IConsoleError("variable type missmatch");
-			} else {
-			switch (result->type) {
-			case ICONSOLE_VAR_BOOLEAN:
-				{
-				(*(bool *)var->addr)=(*(bool *)result->addr);
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			case ICONSOLE_VAR_BYTE:
-				{
-				(*(byte *)var->addr)=(*(byte *)result->addr);
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			case ICONSOLE_VAR_UINT16:
-				{
-				(*(unsigned short *)var->addr)=(*(unsigned short *)result->addr);
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			case ICONSOLE_VAR_UINT32:
-				{
-				(*(unsigned int *)var->addr)=(*(unsigned int *)result->addr);
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			case ICONSOLE_VAR_INT16:
-				{
-				(*(signed short *)var->addr)=(*(signed short *)result->addr);
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			case ICONSOLE_VAR_INT32:
-				{
-				(*(signed int *)var->addr)=(*(signed int *)result->addr);
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			case ICONSOLE_VAR_POINTER:
-				{
-				var->addr=result->addr;
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			case ICONSOLE_VAR_STRING:
-				{
-				IConsoleVarSetString(var,result->addr);
-				IConsoleVarDump(var,NULL);
-				}
-				break;
-			default:
-				{
+		if (IConsoleVarHookHandle(var,ICONSOLE_HOOK_ACCESS)) if (result!=NULL) {
+			if (result ->type != var -> type) {
 				IConsoleError("variable type missmatch");
+				} else {
+				IConsoleVarHookHandle(var,ICONSOLE_HOOK_BEFORE_CHANGE);
+				switch (result->type) {
+				case ICONSOLE_VAR_BOOLEAN:
+					{
+					(*(bool *)var->addr)=(*(bool *)result->addr);
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				case ICONSOLE_VAR_BYTE:
+					{
+					(*(byte *)var->addr)=(*(byte *)result->addr);
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				case ICONSOLE_VAR_UINT16:
+					{
+					(*(unsigned short *)var->addr)=(*(unsigned short *)result->addr);
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				case ICONSOLE_VAR_UINT32:
+					{
+					(*(unsigned int *)var->addr)=(*(unsigned int *)result->addr);
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				case ICONSOLE_VAR_INT16:
+					{
+					(*(signed short *)var->addr)=(*(signed short *)result->addr);
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				case ICONSOLE_VAR_INT32:
+					{
+					(*(signed int *)var->addr)=(*(signed int *)result->addr);
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				case ICONSOLE_VAR_POINTER:
+					{
+					var->addr=result->addr;
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				case ICONSOLE_VAR_STRING:
+					{
+					IConsoleVarSetString(var,result->addr);
+					IConsoleVarDump(var,NULL);
+					}
+					break;
+				default:
+					{
+					IConsoleError("variable type missmatch");
+					}
+					break;
+					}
+				IConsoleVarHookHandle(var,ICONSOLE_HOOK_AFTER_CHANGE);
 				}
-				break;
-				}
-			}
-
-		if (execution_mode==3) {
-			IConsoleVarFree(result);
-			result = NULL;
-			}
-		}
-
-	}
-	break;
-default:
-	{
-	// execution mode invalid
-	IConsoleError("invalid execution mode");
-	}
-}
-
-//** freeing the tokens **//
-for (i=0;i<20;i++) tokens[i]=NULL;
-free(tokenstream_s);
-
-}
-
-/* **************************** */
-/*   default console commands   */
-/* **************************** */
-
-
-static _iconsole_var * IConsoleStdLibEcho(byte argc, byte* argv[], byte argt[]) {
-	if (argc<2) return NULL;
-	IConsolePrint(_iconsole_color_default, argv[1]);
-	return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibEchoC(byte argc, byte* argv[], byte argt[]) {
-	if (argc<3) return NULL;
-	IConsolePrint(atoi(argv[1]), argv[2]);
-	return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibPrintF(byte argc, byte* argv[], byte argt[]) {
-	if (argc<3) return NULL;
-	IConsolePrintF(_iconsole_color_default, argv[1] ,argv[2],argv[3],argv[4],argv[5],argv[6],argv[7],argv[8],argv[9],argv[10],argv[11],argv[12],argv[13],argv[14],argv[15],argv[16],argv[17],argv[18],argv[19]);
-	return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibPrintFC(byte argc, byte* argv[], byte argt[]) {
-	if (argc<3) return NULL;
-	IConsolePrintF(atoi(argv[1]), argv[2] ,argv[3],argv[4],argv[5],argv[6],argv[7],argv[8],argv[9],argv[10],argv[11],argv[12],argv[13],argv[14],argv[15],argv[16],argv[17],argv[18],argv[19]);
-	return NULL;
-}
 
-static _iconsole_var * IConsoleStdLibScreenShot(byte argc, byte* argv[], byte argt[]) {
-
-	if (argc<2) {
-		_make_screenshot=1;
-	} else {
-		if (strcmp(argv[1],"big")==0) {
-			_make_screenshot=2;
-			}
-		if (strcmp(argv[1],"no_con")==0) {
-			IConsoleClose();
-			_make_screenshot=1;
+			if (execution_mode==3) {
+				IConsoleVarFree(result);
+				result = NULL;
+				}
 			}
-		}
-
-return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibVarInfo(byte argc, byte* argv[], byte argt[]) {
-if (argc<2) return NULL;
-if (argt[1]!=ICONSOLE_VAR_REFERENCE) {
-	IConsoleError("variable must be an variable reference");
-	} else {
-    _iconsole_var * item;
-    item = (_iconsole_var *) argv[1];
-	IConsolePrintF(_iconsole_color_default,"variable_name: %s",item->name);
-	IConsolePrintF(_iconsole_color_default,"variable_type: %i",item->type);
-	IConsolePrintF(_iconsole_color_default,"variable_addr: %i",item->addr);
-	if (item->_malloc) IConsolePrintF(_iconsole_color_default,"variable_malloc: internal allocated"); else IConsolePrintF(_iconsole_color_default, "variable_malloc: external allocated");
-	}
-return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibDebugLevel(byte argc, byte* argv[], byte argt[]) {
-	if (argc<2) return NULL;
-	SetDebugString(argv[1]);
-	return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibExit(byte argc, byte* argv[], byte argt[]) {
-	_exit_game = true;
-	return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibHelp(byte argc, byte* argv[], byte argt[]) {
-	IConsolePrint(13	," -- console help -- ");
-	IConsolePrint(1		," variables: [command to list them: list_vars]");
-	IConsolePrint(1		," *temp_string = \"my little \"");
-	IConsolePrint(1		,"");
-	IConsolePrint(1		," commands: [command to list them: list_cmds]");
-	IConsolePrint(1		," [command] [\"string argument with spaces\"] [argument 2] ...");
-	IConsolePrint(1		," printf \"%s world\" *temp_string");
-	IConsolePrint(1		,"");
-	IConsolePrint(1		," command/variable returning a value into an variable:");
-	IConsolePrint(1		," *temp_uint16 << random");
-	IConsolePrint(1		," *temp_uint16 << *temp_uint16_2");
-	IConsolePrint(1		,"");
-return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibRandom(byte argc, byte* argv[], byte argt[]) {
-_iconsole_var * result;
-result = IConsoleVarAlloc(ICONSOLE_VAR_UINT16);
-IConsoleVarSetValue(result,rand());
-return result;
-}
-
-static _iconsole_var * IConsoleStdLibListCommands(byte argc, byte* argv[], byte argt[]) {
-_iconsole_cmd * item;
-int l = 0;
-
-if (argv[1]!=NULL) l = strlen((char *) argv[1]);
-
-item = _iconsole_cmds;
-while (item != NULL) {
-	if (argv[1]!=NULL) {
-
-		if (memcmp((void *) item->name, (void *) argv[1],l)==0)
-				IConsolePrintF(_iconsole_color_default,"%s",item->name);
-
-		} else {
-
-		IConsolePrintF(_iconsole_color_default,"%s",item->name);
 
 		}
-	item = item->_next;
-	}
-
-return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibListVariables(byte argc, byte* argv[], byte argt[]) {
-_iconsole_var * item;
-int l = 0;
-
-if (argv[1]!=NULL) l = strlen((char *) argv[1]);
-
-item = _iconsole_vars;
-while (item != NULL) {
-	if (argv[1]!=NULL) {
-
-		if (memcmp((void *) item->name, (void *) argv[1],l)==0)
-				IConsolePrintF(_iconsole_color_default,"%s",item->name);
-
-		} else {
-
-		IConsolePrintF(_iconsole_color_default,"%s",item->name);
-
-		}
-	item = item->_next;
-	}
-
-return NULL;
-}
-
-static _iconsole_var * IConsoleStdLibListDumpVariables(byte argc, byte* argv[], byte argt[]) {
-_iconsole_var * item;
-int l = 0;
-
-if (argv[1]!=NULL) l = strlen((char *) argv[1]);
-
-item = _iconsole_vars;
-while (item != NULL) {
-	if (argv[1]!=NULL) {
-
-		if (memcmp((void *) item->name, (void *) argv[1],l)==0)
-				IConsoleVarDump(item,NULL);
-
-		} else {
-
-		IConsoleVarDump(item,NULL);
-
+		break;
+	default:
+		{
+		// execution mode invalid
+		IConsoleError("invalid execution mode");
 		}
-	item = item->_next;
 	}
 
-return NULL;
-}
+	//** freeing the tokens **//
+	for (i=0;i<20;i++) tokens[i]=NULL;
+	free(tokenstream_s);
 
-static void IConsoleStdLibRegister() {
-	// functions
-	IConsoleCmdRegister("debug_level",IConsoleStdLibDebugLevel);
-	IConsoleCmdRegister("dump_vars",IConsoleStdLibListDumpVariables);
-	IConsoleCmdRegister("echo",IConsoleStdLibEcho);
-	IConsoleCmdRegister("echoc",IConsoleStdLibEchoC);
-	IConsoleCmdRegister("exit",IConsoleStdLibExit);
-	IConsoleCmdRegister("help",IConsoleStdLibHelp);
-	IConsoleCmdRegister("printf",IConsoleStdLibPrintF);
-	IConsoleCmdRegister("printfc",IConsoleStdLibPrintFC);
-	IConsoleCmdRegister("quit",IConsoleStdLibExit);
-	IConsoleCmdRegister("random",IConsoleStdLibRandom);
-	IConsoleCmdRegister("list_cmds",IConsoleStdLibListCommands);
-	IConsoleCmdRegister("list_vars",IConsoleStdLibListVariables);
-	IConsoleCmdRegister("screenshot",IConsoleStdLibScreenShot);
-	IConsoleCmdRegister("varinfo",IConsoleStdLibVarInfo);
-	IConsoleCmdRegister("resetengines",IConsoleResetEngines);
-
-	// variables
-	IConsoleVarRegister("cursor_rate",(void *) &_icursor_rate,ICONSOLE_VAR_BYTE);
-	IConsoleVarRegister("con_developer",(void *) &_stdlib_con_developer,ICONSOLE_VAR_BOOLEAN);
-	IConsoleVarRegister("developer",(void *) &_stdlib_developer,ICONSOLE_VAR_BYTE);
-#if defined(_DEBUG)
-	{
-	_iconsole_var * var;
-	var = IConsoleVarAlloc(ICONSOLE_VAR_BOOLEAN);
-	IConsoleVarInsert(var,"temp_bool");
-
-	var = IConsoleVarAlloc(ICONSOLE_VAR_INT16);
-	IConsoleVarInsert(var,"temp_int16");
-	var = IConsoleVarAlloc(ICONSOLE_VAR_INT32);
-	IConsoleVarInsert(var,"temp_int32");
-
-	var = IConsoleVarAlloc(ICONSOLE_VAR_POINTER);
-	IConsoleVarInsert(var,"temp_pointer");
-
-	var = IConsoleVarAlloc(ICONSOLE_VAR_UINT16);
-	IConsoleVarInsert(var,"temp_uint16");
-	var = IConsoleVarAlloc(ICONSOLE_VAR_UINT16);
-	IConsoleVarInsert(var,"temp_uint16_2");
-	var = IConsoleVarAlloc(ICONSOLE_VAR_UINT32);
-	IConsoleVarInsert(var,"temp_uint32");
-
-	var = IConsoleVarAlloc(ICONSOLE_VAR_STRING);
-	IConsoleVarInsert(var,"temp_string");
-	var = IConsoleVarAlloc(ICONSOLE_VAR_STRING);
-	IConsoleVarInsert(var,"temp_string2");
-	}
-#endif
 }
-
-