bool CloseConsoleLogIfActive()
{
if (_iconsole_output_file != NULL) {
IConsolePrintF(CC_DEFAULT, "file output complete");
fclose(_iconsole_output_file);
_iconsole_output_file = NULL;
return true;
}
return false;
}
/**
* Print all the clients to the console
*/
void NetworkPrintClients()
{
NetworkClientInfo *ci;
FOR_ALL_CLIENT_INFOS(ci) {
IConsolePrintF(CC_INFO, "Client #%1d name: '%s' company: %1d IP: %s",
ci->client_id,
ci->client_name,
ci->client_playas + (Company::IsValidID(ci->client_playas) ? 1 : 0),
GetClientIP(ci));
}
}
void IConsoleGUIInit()
{
IConsoleResetHistoryPos();
_iconsole_mode = ICONSOLE_CLOSED;
IConsoleLine::Reset();
memset(_iconsole_history, 0, sizeof(_iconsole_history));
IConsolePrintF(CC_WARNING, "OpenTTD Game Console Revision 7 - %s", _openttd_revision);
IConsolePrint(CC_WHITE, "------------------------------------");
IConsolePrint(CC_WHITE, "use \"help\" for more information");
IConsolePrint(CC_WHITE, "");
IConsoleClearCommand();
}
static void IConsoleWriteToLogFile(const char *string)
{
if (_iconsole_output_file != NULL) {
/* if there is an console output file ... also print it there */
const char *header = GetLogPrefix();
if ((strlen(header) != 0 && fwrite(header, strlen(header), 1, _iconsole_output_file) != 1) ||
fwrite(string, strlen(string), 1, _iconsole_output_file) != 1 ||
fwrite("\n", 1, 1, _iconsole_output_file) != 1) {
fclose(_iconsole_output_file);
_iconsole_output_file = NULL;
IConsolePrintF(CC_DEFAULT, "cannot write to log file");
}
}
}
void IConsoleGUIInit()
{
_iconsole_historypos = ICON_HISTORY_SIZE - 1;
_iconsole_mode = ICONSOLE_CLOSED;
IConsoleLine::Reset();
memset(_iconsole_history, 0, sizeof(_iconsole_history));
_iconsole_cmdline.buf = CallocT<char>(ICON_CMDLN_SIZE); // create buffer and zero it
_iconsole_cmdline.max_bytes = ICON_CMDLN_SIZE;
_iconsole_cmdline.max_chars = ICON_CMDLN_SIZE;
IConsolePrintF(CC_WARNING, "OpenTTD Game Console Revision 7 - %s", _openttd_revision);
IConsolePrint(CC_WHITE, "------------------------------------");
IConsolePrint(CC_WHITE, "use \"help\" for more information");
IConsolePrint(CC_WHITE, "");
IConsoleClearCommand();
}
DEF_GAME_RECEIVE_COMMAND(Client, PACKET_SERVER_COMMAND)
{
if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
CommandPacket cp;
const char *err = this->ReceiveCommand(p, &cp);
cp.frame = p->Recv_uint32();
cp.my_cmd = p->Recv_bool();
if (err != NULL) {
IConsolePrintF(CC_ERROR, "WARNING: %s from server, dropping...", err);
return NETWORK_RECV_STATUS_MALFORMED_PACKET;
}
this->incoming_queue.Append(&cp);
return NETWORK_RECV_STATUS_OKAY;
}
virtual EventState OnKeyPress(uint16 key, uint16 keycode)
{
if (_focused_window != this) return ES_NOT_HANDLED;
const int scroll_height = (this->height / this->line_height) - 1;
switch (keycode) {
case WKC_UP:
IConsoleHistoryNavigate(1);
this->SetDirty();
break;
case WKC_DOWN:
IConsoleHistoryNavigate(-1);
this->SetDirty();
break;
case WKC_SHIFT | WKC_PAGEDOWN:
this->Scroll(-scroll_height);
break;
case WKC_SHIFT | WKC_PAGEUP:
this->Scroll(scroll_height);
break;
case WKC_SHIFT | WKC_DOWN:
this->Scroll(-1);
break;
case WKC_SHIFT | WKC_UP:
this->Scroll(1);
break;
case WKC_BACKQUOTE:
IConsoleSwitch();
break;
case WKC_RETURN: case WKC_NUM_ENTER: {
/* We always want the ] at the left side; we always force these strings to be left
* aligned anyway. So enforce this in all cases by addding a left-to-right marker,
* otherwise it will be drawn at the wrong side with right-to-left texts. */
IConsolePrintF(CC_COMMAND, LRM "] %s", _iconsole_cmdline.buf);
const char *cmd = IConsoleHistoryAdd(_iconsole_cmdline.buf);
IConsoleClearCommand();
if (cmd != NULL) IConsoleCmdExec(cmd);
break;
}
case WKC_CTRL | WKC_RETURN:
_iconsole_mode = (_iconsole_mode == ICONSOLE_FULL) ? ICONSOLE_OPENED : ICONSOLE_FULL;
IConsoleResize(this);
MarkWholeScreenDirty();
break;
#ifdef WITH_COCOA
case (WKC_META | 'V'):
#endif
case (WKC_CTRL | 'V'):
if (InsertTextBufferClipboard(&_iconsole_cmdline)) {
IConsoleResetHistoryPos();
this->SetDirty();
}
break;
case (WKC_CTRL | 'L'):
IConsoleCmdExec("clear");
break;
#ifdef WITH_COCOA
case (WKC_META | 'U'):
#endif
case (WKC_CTRL | 'U'):
DeleteTextBufferAll(&_iconsole_cmdline);
this->SetDirty();
break;
case WKC_BACKSPACE: case WKC_DELETE:
if (DeleteTextBufferChar(&_iconsole_cmdline, keycode)) {
IConsoleResetHistoryPos();
this->SetDirty();
}
break;
case WKC_LEFT: case WKC_RIGHT: case WKC_END: case WKC_HOME:
if (MoveTextBufferPos(&_iconsole_cmdline, keycode)) {
IConsoleResetHistoryPos();
this->SetDirty();
}
break;
default:
if (IsValidChar(key, CS_ALPHANUMERAL)) {
IConsoleWindow::scroll = 0;
InsertTextBufferChar(&_iconsole_cmdline, key);
IConsoleResetHistoryPos();
this->SetDirty();
} else {
return ES_NOT_HANDLED;
}
break;
}
return ES_HANDLED;
}
virtual EventState OnKeyPress(WChar key, uint16 keycode)
{
if (_focused_window != this) return ES_NOT_HANDLED;
const int scroll_height = (this->height / this->line_height) - 1;
switch (keycode) {
case WKC_UP:
IConsoleHistoryNavigate(1);
this->SetDirty();
break;
case WKC_DOWN:
IConsoleHistoryNavigate(-1);
this->SetDirty();
break;
case WKC_SHIFT | WKC_PAGEDOWN:
this->Scroll(-scroll_height);
break;
case WKC_SHIFT | WKC_PAGEUP:
this->Scroll(scroll_height);
break;
case WKC_SHIFT | WKC_DOWN:
this->Scroll(-1);
break;
case WKC_SHIFT | WKC_UP:
this->Scroll(1);
break;
case WKC_BACKQUOTE:
IConsoleSwitch();
break;
case WKC_RETURN: case WKC_NUM_ENTER: {
/* We always want the ] at the left side; we always force these strings to be left
* aligned anyway. So enforce this in all cases by addding a left-to-right marker,
* otherwise it will be drawn at the wrong side with right-to-left texts. */
IConsolePrintF(CC_COMMAND, LRM "] %s", _iconsole_cmdline.buf);
const char *cmd = IConsoleHistoryAdd(_iconsole_cmdline.buf);
IConsoleClearCommand();
if (cmd != NULL) IConsoleCmdExec(cmd);
break;
}
case WKC_CTRL | WKC_RETURN:
_iconsole_mode = (_iconsole_mode == ICONSOLE_FULL) ? ICONSOLE_OPENED : ICONSOLE_FULL;
IConsoleResize(this);
MarkWholeScreenDirty();
break;
case (WKC_CTRL | 'L'):
IConsoleCmdExec("clear");
break;
default:
if (_iconsole_cmdline.HandleKeyPress(key, keycode) != HKPR_NOT_HANDLED) {
IConsoleWindow::scroll = 0;
IConsoleResetHistoryPos();
this->SetDirty();
} else {
return ES_NOT_HANDLED;
}
break;
}
return ES_HANDLED;
}
/**
* Execute a given command passed to us. First chop it up into
* individual tokens (separated by spaces), then execute it if possible
* @param cmdstr string to be parsed and executed
*/
void IConsoleCmdExec(const char *cmdstr)
{
const char *cmdptr;
char *tokens[ICON_TOKEN_COUNT], tokenstream[ICON_MAX_STREAMSIZE];
uint t_index, tstream_i;
bool longtoken = false;
bool foundtoken = false;
if (cmdstr[0] == '#') return; // comments
for (cmdptr = cmdstr; *cmdptr != '\0'; cmdptr++) {
if (!IsValidChar(*cmdptr, CS_ALPHANUMERAL)) {
IConsoleError("command contains malformed characters, aborting");
IConsolePrintF(CC_ERROR, "ERROR: command was: '%s'", cmdstr);
return;
}
}
DEBUG(console, 4, "Executing cmdline: '%s'", cmdstr);
memset(&tokens, 0, sizeof(tokens));
memset(&tokenstream, 0, sizeof(tokenstream));
/* 1. Split up commandline into tokens, separated by spaces, commands
* enclosed in "" are taken as one token. We can only go as far as the amount
* of characters in our stream or the max amount of tokens we can handle */
for (cmdptr = cmdstr, t_index = 0, tstream_i = 0; *cmdptr != '\0'; cmdptr++) {
if (t_index >= lengthof(tokens) || tstream_i >= lengthof(tokenstream)) break;
switch (*cmdptr) {
case ' ': // Token separator
if (!foundtoken) break;
if (longtoken) {
tokenstream[tstream_i] = *cmdptr;
} else {
tokenstream[tstream_i] = '\0';
foundtoken = false;
}
tstream_i++;
break;
case '"': // Tokens enclosed in "" are one token
longtoken = !longtoken;
if (!foundtoken) {
tokens[t_index++] = &tokenstream[tstream_i];
foundtoken = true;
}
break;
case '\\': // Escape character for ""
if (cmdptr[1] == '"' && tstream_i + 1 < lengthof(tokenstream)) {
tokenstream[tstream_i++] = *++cmdptr;
break;
}
/* FALL THROUGH */
default: // Normal character
tokenstream[tstream_i++] = *cmdptr;
if (!foundtoken) {
tokens[t_index++] = &tokenstream[tstream_i - 1];
foundtoken = true;
}
break;
}
}
for (uint i = 0; tokens[i] != NULL; i++) {
DEBUG(console, 8, "Token %d is: '%s'", i, tokens[i]);
}
if (StrEmpty(tokens[0])) return; // don't execute empty commands
/* 2. Determine type of command (cmd or alias) and execute
* First try commands, then aliases. Execute
* the found action taking into account its hooking code
*/
RemoveUnderscores(tokens[0]);
IConsoleCmd *cmd = IConsoleCmdGet(tokens[0]);
if (cmd != NULL) {
ConsoleHookResult chr = (cmd->hook == NULL ? CHR_ALLOW : cmd->hook(true));
switch (chr) {
case CHR_ALLOW:
if (!cmd->proc(t_index, tokens)) { // index started with 0
cmd->proc(0, NULL); // if command failed, give help
}
return;
case CHR_DISALLOW: return;
case CHR_HIDE: break;
}
}
t_index--;
IConsoleAlias *alias = IConsoleAliasGet(tokens[0]);
if (alias != NULL) {
IConsoleAliasExec(alias, t_index, &tokens[1]);
return;
}
IConsoleError("command not found");
}
/**
* An alias is just another name for a command, or for more commands
* Execute it as well.
* @param *alias is the alias of the command
* @param tokencount the number of parameters passed
* @param *tokens are the parameters given to the original command (0 is the first param)
*/
static void IConsoleAliasExec(const IConsoleAlias *alias, byte tokencount, char *tokens[ICON_TOKEN_COUNT])
{
char alias_buffer[ICON_MAX_STREAMSIZE] = { '\0' };
char *alias_stream = alias_buffer;
DEBUG(console, 6, "Requested command is an alias; parsing...");
for (const char *cmdptr = alias->cmdline; *cmdptr != '\0'; cmdptr++) {
switch (*cmdptr) {
case '\'': // ' will double for ""
alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
break;
case ';': // Cmd separator; execute previous and start new command
IConsoleCmdExec(alias_buffer);
alias_stream = alias_buffer;
*alias_stream = '\0'; // Make sure the new command is terminated.
cmdptr++;
break;
case '%': // Some or all parameters
cmdptr++;
switch (*cmdptr) {
case '+': { // All parameters separated: "[param 1]" "[param 2]"
for (uint i = 0; i != tokencount; i++) {
if (i != 0) alias_stream = strecpy(alias_stream, " ", lastof(alias_buffer));
alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
alias_stream = strecpy(alias_stream, tokens[i], lastof(alias_buffer));
alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
}
break;
}
case '!': { // Merge the parameters to one: "[param 1] [param 2] [param 3...]"
alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
for (uint i = 0; i != tokencount; i++) {
if (i != 0) alias_stream = strecpy(alias_stream, " ", lastof(alias_buffer));
alias_stream = strecpy(alias_stream, tokens[i], lastof(alias_buffer));
}
alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
break;
}
default: { // One specific parameter: %A = [param 1] %B = [param 2] ...
int param = *cmdptr - 'A';
if (param < 0 || param >= tokencount) {
IConsoleError("too many or wrong amount of parameters passed to alias, aborting");
IConsolePrintF(CC_WARNING, "Usage of alias '%s': %s", alias->name, alias->cmdline);
return;
}
alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
alias_stream = strecpy(alias_stream, tokens[param], lastof(alias_buffer));
alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
break;
}
}
break;
default:
*alias_stream++ = *cmdptr;
*alias_stream = '\0';
break;
}
if (alias_stream >= lastof(alias_buffer) - 1) {
IConsoleError("Requested alias execution would overflow execution buffer");
return;
}
}
IConsoleCmdExec(alias_buffer);
}
/**
* It is possible to print error information to the console. This can include
* game errors, or errors in general you would want the user to notice
*/
void IConsoleError(const char *string)
{
IConsolePrintF(CC_ERROR, "ERROR: %s", string);
}
/**
* It is possible to print warnings to the console. These are mostly
* errors or mishaps, but non-fatal. You need at least a level 1 (developer) for
* debugging messages to show up
*/
void IConsoleWarning(const char *string)
{
if (_settings_client.gui.developer == 0) return;
IConsolePrintF(CC_WARNING, "WARNING: %s", string);
}
/**
* It is possible to print debugging information to the console,
* which is achieved by using this function. Can only be used by
* debug() in debug.cpp. You need at least a level 2 (developer) for debugging
* messages to show up
* @param dbg debugging category
* @param string debugging message
*/
void IConsoleDebug(const char *dbg, const char *string)
{
if (_settings_client.gui.developer <= 1) return;
IConsolePrintF(CC_DEBUG, "dbg: [%s] %s", dbg, string);
}
/**
* An alias is just another name for a command, or for more commands
* Execute it as well.
* @param *alias is the alias of the command
* @param tokencount the number of parameters passed
* @param *tokens are the parameters given to the original command (0 is the first param)
*/
static void IConsoleAliasExec(const IConsoleAlias *alias, byte tokencount, char *tokens[ICON_TOKEN_COUNT])
{
const char *cmdptr;
char *aliases[ICON_MAX_ALIAS_LINES], aliasstream[ICON_MAX_STREAMSIZE];
uint i;
uint a_index, astream_i;
memset(&aliases, 0, sizeof(aliases));
memset(&aliasstream, 0, sizeof(aliasstream));
DEBUG(console, 6, "Requested command is an alias; parsing...");
aliases[0] = aliasstream;
for (cmdptr = alias->cmdline, a_index = 0, astream_i = 0; *cmdptr != '\0'; cmdptr++) {
if (a_index >= lengthof(aliases) || astream_i >= lengthof(aliasstream)) break;
switch (*cmdptr) {
case '\'': // ' will double for ""
aliasstream[astream_i++] = '"';
break;
case ';': // Cmd seperator, start new command
aliasstream[astream_i] = '\0';
aliases[++a_index] = &aliasstream[++astream_i];
cmdptr++;
break;
case '%': // Some or all parameters
cmdptr++;
switch (*cmdptr) {
case '+': { // All parameters seperated: "[param 1]" "[param 2]"
for (i = 0; i != tokencount; i++) {
aliasstream[astream_i++] = '"';
astream_i += IConsoleCopyInParams(&aliasstream[astream_i], tokens[i], astream_i);
aliasstream[astream_i++] = '"';
aliasstream[astream_i++] = ' ';
}
} break;
case '!': { // Merge the parameters to one: "[param 1] [param 2] [param 3...]"
aliasstream[astream_i++] = '"';
for (i = 0; i != tokencount; i++) {
astream_i += IConsoleCopyInParams(&aliasstream[astream_i], tokens[i], astream_i);
aliasstream[astream_i++] = ' ';
}
aliasstream[astream_i++] = '"';
} break;
default: { // One specific parameter: %A = [param 1] %B = [param 2] ...
int param = *cmdptr - 'A';
if (param < 0 || param >= tokencount) {
IConsoleError("too many or wrong amount of parameters passed to alias, aborting");
IConsolePrintF(CC_WARNING, "Usage of alias '%s': %s", alias->name, alias->cmdline);
return;
}
aliasstream[astream_i++] = '"';
astream_i += IConsoleCopyInParams(&aliasstream[astream_i], tokens[param], astream_i);
aliasstream[astream_i++] = '"';
} break;
} break;
default:
aliasstream[astream_i++] = *cmdptr;
break;
}
}
for (i = 0; i <= a_index; i++) IConsoleCmdExec(aliases[i]); // execute each alias in turn
}
