|
@@ -204,15 +204,15 @@ void IConsoleInit()
|
|
|
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);
|
|
|
IConsolePrintF(13,"OpenTTD Game Console Revision 4 - %s",_openttd_revision);
|
|
|
#else
|
|
|
IConsolePrint(13,"OpenTTD Game Console Revision 3");
|
|
|
IConsolePrint(13,"OpenTTD Game Console Revision 4");
|
|
|
#endif
|
|
|
IConsolePrint(12,"---------------------------------");
|
|
|
IConsolePrint(12,"use \"help\" for more info");
|
|
|
IConsolePrint(12,"");
|
|
|
IConsoleClearCommand();
|
|
|
IConsoleCmdBufferAdd("");
|
|
@@ -266,22 +266,22 @@ void IConsoleClose()
|
|
|
|
|
|
void IConsoleOpen()
|
|
|
{
|
|
|
if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();
|
|
|
}
|
|
|
|
|
|
void IConsoleCmdBufferAdd(byte * cmd)
|
|
|
void IConsoleCmdBufferAdd(const 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);
|
|
|
i=strlen(cmd);
|
|
|
_iconsole_cmdbuffer[0]=malloc(i+1);
|
|
|
memset(((void *)_iconsole_cmdbuffer[0]),0,i+1);
|
|
|
memcpy(((void *)_iconsole_cmdbuffer[0]),(void *)cmd,i);
|
|
|
memcpy(((void *)_iconsole_cmdbuffer[0]),cmd,i);
|
|
|
_iconsole_cmdbuffer[0][i]=0;
|
|
|
_iconsole_cmdbufferpos = 19;
|
|
|
}
|
|
|
|
|
|
void IConsoleCmdBufferNavigate(signed char direction)
|
|
|
{
|
|
@@ -300,24 +300,24 @@ void IConsoleCmdBufferNavigate(signed ch
|
|
|
_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)
|
|
|
void IConsolePrint(byte color_code, const byte* string)
|
|
|
{
|
|
|
byte * _ex;
|
|
|
byte * _new;
|
|
|
byte _exc;
|
|
|
byte _newc;
|
|
|
int i,j;
|
|
|
|
|
|
if (!_iconsole_inited) return;
|
|
|
|
|
|
_newc=color_code;
|
|
|
i=strlen((char *)string);
|
|
|
i=strlen(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;
|
|
@@ -351,28 +351,28 @@ void CDECL IConsolePrintF(byte color_cod
|
|
|
|
|
|
void IConsoleDebug(byte* string)
|
|
|
{
|
|
|
if (_stdlib_developer>1) IConsolePrintF(_iconsole_color_debug, "DEBUG: %s", string);
|
|
|
}
|
|
|
|
|
|
void IConsoleError(byte* string)
|
|
|
void IConsoleError(const byte* string)
|
|
|
{
|
|
|
if (_stdlib_developer>0) IConsolePrintF(_iconsole_color_error, "ERROR: %s", string);
|
|
|
}
|
|
|
|
|
|
void IConsoleCmdRegister(byte * name, void * addr)
|
|
|
void IConsoleCmdRegister(const 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);
|
|
|
i=strlen(name);
|
|
|
_new=malloc(i+1);
|
|
|
memset(_new,0,i+1);
|
|
|
memcpy(_new,name,i);
|
|
|
|
|
|
item_new = malloc(sizeof(_iconsole_cmd));
|
|
|
|
|
|
item_new->_next = NULL;
|
|
|
item_new->addr = addr;
|
|
|
item_new->name = _new;
|
|
@@ -387,36 +387,36 @@ void IConsoleCmdRegister(byte * name, vo
|
|
|
} else {
|
|
|
while (item->_next != NULL) { item = item->_next; };
|
|
|
item->_next = item_new;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void* IConsoleCmdGet(byte * name)
|
|
|
void* IConsoleCmdGet(const byte * name)
|
|
|
{
|
|
|
_iconsole_cmd * item;
|
|
|
|
|
|
item = _iconsole_cmds;
|
|
|
while (item != NULL) {
|
|
|
if (strcmp(item->name,name)==0) return item;
|
|
|
item = item->_next;
|
|
|
}
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
void IConsoleVarRegister(byte * name, void * addr, byte type)
|
|
|
void IConsoleVarRegister(const 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);
|
|
|
i=strlen(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;
|
|
@@ -433,37 +433,37 @@ void IConsoleVarRegister(byte * name, vo
|
|
|
} else {
|
|
|
while (item->_next != NULL) { item = item->_next; };
|
|
|
item->_next = item_new;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IConsoleVarMemRegister(byte * name, byte type)
|
|
|
void IConsoleVarMemRegister(byte * name, byte type) /* XXX TRON */
|
|
|
{
|
|
|
_iconsole_var * item;
|
|
|
item = IConsoleVarAlloc(type);
|
|
|
IConsoleVarInsert(item,name);
|
|
|
}
|
|
|
|
|
|
|
|
|
void IConsoleVarInsert(_iconsole_var * var, byte * name)
|
|
|
void IConsoleVarInsert(_iconsole_var * var, const byte * name)
|
|
|
{
|
|
|
byte * _new;
|
|
|
_iconsole_var * item;
|
|
|
_iconsole_var * item_new;
|
|
|
int i;
|
|
|
|
|
|
item_new = var;
|
|
|
|
|
|
// dont allow to build variable rings
|
|
|
if (item_new->_next != NULL) return;
|
|
|
|
|
|
i=strlen((char *)name)+1;
|
|
|
_new=malloc(i+1);
|
|
|
memset(_new,0,i+1);
|
|
|
_new[0]='*';
|
|
|
memcpy(_new+1,name,i);
|
|
|
i=strlen(name)+1;
|
|
|
_new=malloc(i+1);
|
|
|
memset(_new,0,i+1);
|
|
|
_new[0]='*';
|
|
|
memcpy(_new+1,name,i);
|
|
|
|
|
|
item_new->name = _new;
|
|
|
|
|
|
item = _iconsole_vars;
|
|
|
if (item == NULL) {
|
|
|
_iconsole_vars = item_new;
|
|
@@ -471,13 +471,13 @@ void IConsoleVarInsert(_iconsole_var * v
|
|
|
while (item->_next != NULL) { item = item->_next; };
|
|
|
item->_next = item_new;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
_iconsole_var * IConsoleVarGet(byte * name)
|
|
|
_iconsole_var * IConsoleVarGet(const byte * name)
|
|
|
{
|
|
|
_iconsole_var * item;
|
|
|
|
|
|
item = _iconsole_vars;
|
|
|
while (item != NULL) {
|
|
|
if (strcmp(item->name,name)==0) return item;
|
|
@@ -548,74 +548,61 @@ void IConsoleVarInsert(_iconsole_var * v
|
|
|
return item;
|
|
|
}
|
|
|
|
|
|
|
|
|
void IConsoleVarFree(_iconsole_var * var)
|
|
|
{
|
|
|
if (var ->_malloc) {
|
|
|
free(var ->addr);
|
|
|
}
|
|
|
if (var->_malloc)
|
|
|
free(var->addr);
|
|
|
free(var);
|
|
|
}
|
|
|
|
|
|
void IConsoleVarSetString(_iconsole_var * var, byte * string)
|
|
|
void IConsoleVarSetString(_iconsole_var * var, const byte * string)
|
|
|
{
|
|
|
int l;
|
|
|
|
|
|
if (string == NULL) return;
|
|
|
|
|
|
if (var->_malloc) {
|
|
|
free(var->addr);
|
|
|
}
|
|
|
|
|
|
l=strlen((char *) string);
|
|
|
l=strlen(string);
|
|
|
var->addr=malloc(l+1);
|
|
|
var->_malloc=true;
|
|
|
memset(var->addr,0,l);
|
|
|
memcpy((void *) var->addr,(void *) string, l);
|
|
|
memcpy(var->addr, string, l);
|
|
|
((byte *)var->addr)[l]=0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IConsoleVarSetValue(_iconsole_var * var, int value) {
|
|
|
void IConsoleVarSetValue(_iconsole_var * var, int value) {
|
|
|
switch (var->type) {
|
|
|
case ICONSOLE_VAR_BOOLEAN:
|
|
|
{
|
|
|
(*(bool *)var->addr)=(value!=0);
|
|
|
}
|
|
|
*(bool *)var->addr = (value != 0);
|
|
|
break;
|
|
|
case ICONSOLE_VAR_BYTE:
|
|
|
{
|
|
|
(*(byte *)var->addr)=value;
|
|
|
}
|
|
|
*(byte *)var->addr = value;
|
|
|
break;
|
|
|
case ICONSOLE_VAR_UINT16:
|
|
|
{
|
|
|
(*(unsigned short *)var->addr)=value;
|
|
|
}
|
|
|
*(unsigned short *)var->addr = value;
|
|
|
break;
|
|
|
case ICONSOLE_VAR_UINT32:
|
|
|
{
|
|
|
(*(unsigned int *)var->addr)=value;
|
|
|
}
|
|
|
*(unsigned int *)var->addr = value;
|
|
|
break;
|
|
|
case ICONSOLE_VAR_INT16:
|
|
|
{
|
|
|
(*(signed short *)var->addr)=value;
|
|
|
}
|
|
|
*(signed short *)var->addr = value;
|
|
|
break;
|
|
|
case ICONSOLE_VAR_INT32:
|
|
|
{
|
|
|
(*(signed int *)var->addr)=value;
|
|
|
}
|
|
|
*(signed int *)var->addr = value;
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IConsoleVarDump(_iconsole_var * var, byte * dump_desc)
|
|
|
void IConsoleVarDump(_iconsole_var * var, const 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
|
|
@@ -683,13 +670,13 @@ void IConsoleVarDump(_iconsole_var * var
|
|
|
}
|
|
|
|
|
|
// * ************************* * //
|
|
|
// * hooking code * //
|
|
|
// * ************************* * //
|
|
|
|
|
|
void IConsoleVarHook(byte * name, byte type, void * proc)
|
|
|
void IConsoleVarHook(const 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:
|
|
@@ -703,29 +690,30 @@ void IConsoleVarHook(byte * name, byte t
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool IConsoleVarHookHandle(_iconsole_var * hook_var, byte type)
|
|
|
{
|
|
|
bool (*proc)(_iconsole_var * hook_var);
|
|
|
bool (*proc)(_iconsole_var * hook_var) = NULL;
|
|
|
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;
|
|
|
default: return true;
|
|
|
}
|
|
|
if (proc == NULL) return true;
|
|
|
|
|
|
return proc(hook_var);
|
|
|
}
|
|
|
|
|
|
void IConsoleCmdHook(byte * name, byte type, void * proc)
|
|
|
void IConsoleCmdHook(const 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:
|
|
@@ -750,12 +738,15 @@ bool IConsoleCmdHookHandle(_iconsole_cmd
|
|
|
case ICONSOLE_HOOK_BEFORE_EXEC:
|
|
|
proc = hook_cmd->hook_before_exec;
|
|
|
break;
|
|
|
case ICONSOLE_HOOK_ACCESS:
|
|
|
proc = hook_cmd->hook_access;
|
|
|
break;
|
|
|
default:
|
|
|
proc = NULL;
|
|
|
break;
|
|
|
}
|
|
|
if (proc == NULL) return true;
|
|
|
return proc(hook_cmd);
|
|
|
}
|
|
|
|
|
|
void IConsoleCmdExec(byte * cmdstr)
|
|
@@ -882,13 +873,13 @@ void IConsoleCmdExec(byte * cmdstr)
|
|
|
} 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;
|
|
@@ -1112,34 +1103,35 @@ void IConsoleCmdExec(byte * cmdstr)
|
|
|
}
|
|
|
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;
|
|
|
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];
|
|
|
// 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;
|
|
|
IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_BEFORE_EXEC);
|
|
|
result = function(c,tokens,tokentypes);
|
|
|
IConsoleCmdHookHandle(cmd,ICONSOLE_HOOK_AFTER_EXEC);
|
|
|
} else
|
|
|
execution_mode=255;
|
|
|
}
|
|
|
|
|
|
if (IConsoleVarHookHandle(var,ICONSOLE_HOOK_ACCESS)) if (result!=NULL) {
|
|
|
if (result ->type != var -> type) {
|
|
|
IConsoleError("variable type missmatch");
|
|
|
} else {
|