4 * This file is part of OpenTTD.
5 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
10 /** @file console.cpp Handling of the in-game console. */
13 #include "console_internal.h"
14 #include "network/network.h"
15 #include "network/network_func.h"
16 #include "network/network_admin.h"
18 #include "console_func.h"
19 #include "settings_type.h"
23 static const uint ICON_TOKEN_COUNT
= 20; ///< Maximum number of tokens in one command
26 IConsoleCmd
*_iconsole_cmds
; ///< list of registered commands
27 IConsoleAlias
*_iconsole_aliases
; ///< list of registered aliases
29 FILE *_iconsole_output_file
;
33 _iconsole_output_file
= NULL
;
34 #ifdef ENABLE_NETWORK /* Initialize network only variables */
35 _redirect_console_to_client
= INVALID_CLIENT_ID
;
36 _redirect_console_to_admin
= INVALID_ADMIN_ID
;
41 IConsoleStdLibRegister();
44 static void IConsoleWriteToLogFile(const char *string
)
46 if (_iconsole_output_file
!= NULL
) {
47 /* if there is an console output file ... also print it there */
48 const char *header
= GetLogPrefix();
49 if ((strlen(header
) != 0 && fwrite(header
, strlen(header
), 1, _iconsole_output_file
) != 1) ||
50 fwrite(string
, strlen(string
), 1, _iconsole_output_file
) != 1 ||
51 fwrite("\n", 1, 1, _iconsole_output_file
) != 1) {
52 fclose(_iconsole_output_file
);
53 _iconsole_output_file
= NULL
;
54 IConsolePrintF(CC_DEFAULT
, "cannot write to log file");
59 bool CloseConsoleLogIfActive()
61 if (_iconsole_output_file
!= NULL
) {
62 IConsolePrintF(CC_DEFAULT
, "file output complete");
63 fclose(_iconsole_output_file
);
64 _iconsole_output_file
= NULL
;
74 CloseConsoleLogIfActive();
78 * Handle the printing of text entered into the console or redirected there
79 * by any other means. Text can be redirected to other clients in a network game
80 * as well as to a logfile. If the network server is a dedicated server, all activities
81 * are also logged. All lines to print are added to a temporary buffer which can be
82 * used as a history to print them onscreen
83 * @param colour_code the colour of the command. Red in case of errors, etc.
84 * @param string the message entered or output on the console (notice, error, etc.)
86 void IConsolePrint(TextColour colour_code
, const char *string
)
88 assert(IsValidConsoleColour(colour_code
));
92 if (_redirect_console_to_client
!= INVALID_CLIENT_ID
) {
93 /* Redirect the string to the client */
94 NetworkServerSendRcon(_redirect_console_to_client
, colour_code
, string
);
98 if (_redirect_console_to_admin
!= INVALID_ADMIN_ID
) {
99 NetworkServerSendAdminRcon(_redirect_console_to_admin
, colour_code
, string
);
104 /* Create a copy of the string, strip if of colours and invalid
105 * characters and (when applicable) assign it to the console buffer */
106 str
= strdup(string
);
107 str_strip_colours(str
);
108 str_validate(str
, str
+ strlen(str
));
110 if (_network_dedicated
) {
111 #ifdef ENABLE_NETWORK
112 NetworkAdminConsole("console", str
);
113 #endif /* ENABLE_NETWORK */
114 fprintf(stdout
, "%s%s\n", GetLogPrefix(), str
);
116 IConsoleWriteToLogFile(str
);
117 free(str
); // free duplicated string since it's not used anymore
121 IConsoleWriteToLogFile(str
);
122 IConsoleGUIPrint(colour_code
, str
);
126 * Handle the printing of text entered into the console or redirected there
127 * by any other means. Uses printf() style format, for more information look
130 void CDECL
IConsolePrintF(TextColour colour_code
, const char *format
, ...)
132 assert(IsValidConsoleColour(colour_code
));
135 char buf
[ICON_MAX_STREAMSIZE
];
137 va_start(va
, format
);
138 vsnprintf(buf
, sizeof(buf
), format
, va
);
141 IConsolePrint(colour_code
, buf
);
145 * It is possible to print debugging information to the console,
146 * which is achieved by using this function. Can only be used by
147 * debug() in debug.cpp. You need at least a level 2 (developer) for debugging
148 * messages to show up
149 * @param dbg debugging category
150 * @param string debugging message
152 void IConsoleDebug(const char *dbg
, const char *string
)
154 if (_settings_client
.gui
.developer
<= 1) return;
155 IConsolePrintF(CC_DEBUG
, "dbg: [%s] %s", dbg
, string
);
159 * It is possible to print warnings to the console. These are mostly
160 * errors or mishaps, but non-fatal. You need at least a level 1 (developer) for
161 * debugging messages to show up
163 void IConsoleWarning(const char *string
)
165 if (_settings_client
.gui
.developer
== 0) return;
166 IConsolePrintF(CC_WARNING
, "WARNING: %s", string
);
170 * It is possible to print error information to the console. This can include
171 * game errors, or errors in general you would want the user to notice
173 void IConsoleError(const char *string
)
175 IConsolePrintF(CC_ERROR
, "ERROR: %s", string
);
179 * Change a string into its number representation. Supports
180 * decimal and hexadecimal numbers as well as 'on'/'off' 'true'/'false'
181 * @param *value the variable a successful conversion will be put in
182 * @param *arg the string to be converted
183 * @return Return true on success or false on failure
185 bool GetArgumentInteger(uint32
*value
, const char *arg
)
189 if (strcmp(arg
, "on") == 0 || strcmp(arg
, "true") == 0) {
193 if (strcmp(arg
, "off") == 0 || strcmp(arg
, "false") == 0) {
198 *value
= strtoul(arg
, &endptr
, 0);
199 return arg
!= endptr
;
203 * Add an item to an alphabetically sorted list.
204 * @param base first item of the list
205 * @param item_new the item to add
208 void IConsoleAddSorted(T
**base
, T
*item_new
)
215 T
*item_before
= NULL
;
217 /* The list is alphabetically sorted, insert the new item at the correct location */
218 while (item
!= NULL
) {
219 if (strcmp(item
->name
, item_new
->name
) > 0) break; // insert here
225 if (item_before
== NULL
) {
228 item_before
->next
= item_new
;
231 item_new
->next
= item
;
235 * Remove underscores from a string; the string will be modified!
236 * @param name The string to remove the underscores from.
239 char *RemoveUnderscores(char *name
)
242 for (const char *p
= name
; *p
!= '\0'; p
++) {
243 if (*p
!= '_') *q
++ = *p
;
250 * Register a new command to be used in the console
251 * @param name name of the command that will be used
252 * @param proc function that will be called upon execution of command
254 void IConsoleCmdRegister(const char *name
, IConsoleCmdProc
*proc
, IConsoleHook
*hook
)
256 IConsoleCmd
*item_new
= MallocT
<IConsoleCmd
>(1);
257 item_new
->name
= RemoveUnderscores(strdup(name
));
258 item_new
->next
= NULL
;
259 item_new
->proc
= proc
;
260 item_new
->hook
= hook
;
262 IConsoleAddSorted(&_iconsole_cmds
, item_new
);
266 * Find the command pointed to by its string
267 * @param name command to be found
268 * @return return Cmdstruct of the found command, or NULL on failure
270 IConsoleCmd
*IConsoleCmdGet(const char *name
)
274 for (item
= _iconsole_cmds
; item
!= NULL
; item
= item
->next
) {
275 if (strcmp(item
->name
, name
) == 0) return item
;
281 * Register a an alias for an already existing command in the console
282 * @param name name of the alias that will be used
283 * @param cmd name of the command that 'name' will be alias of
285 void IConsoleAliasRegister(const char *name
, const char *cmd
)
287 if (IConsoleAliasGet(name
) != NULL
) {
288 IConsoleError("an alias with this name already exists; insertion aborted");
292 char *new_alias
= RemoveUnderscores(strdup(name
));
293 char *cmd_aliased
= strdup(cmd
);
294 IConsoleAlias
*item_new
= MallocT
<IConsoleAlias
>(1);
296 item_new
->next
= NULL
;
297 item_new
->cmdline
= cmd_aliased
;
298 item_new
->name
= new_alias
;
300 IConsoleAddSorted(&_iconsole_aliases
, item_new
);
304 * Find the alias pointed to by its string
305 * @param name alias to be found
306 * @return return Aliasstruct of the found alias, or NULL on failure
308 IConsoleAlias
*IConsoleAliasGet(const char *name
)
312 for (item
= _iconsole_aliases
; item
!= NULL
; item
= item
->next
) {
313 if (strcmp(item
->name
, name
) == 0) return item
;
319 * An alias is just another name for a command, or for more commands
320 * Execute it as well.
321 * @param *alias is the alias of the command
322 * @param tokencount the number of parameters passed
323 * @param *tokens are the parameters given to the original command (0 is the first param)
325 static void IConsoleAliasExec(const IConsoleAlias
*alias
, byte tokencount
, char *tokens
[ICON_TOKEN_COUNT
])
327 char alias_buffer
[ICON_MAX_STREAMSIZE
] = { '\0' };
328 char *alias_stream
= alias_buffer
;
330 DEBUG(console
, 6, "Requested command is an alias; parsing...");
332 for (const char *cmdptr
= alias
->cmdline
; *cmdptr
!= '\0'; cmdptr
++) {
334 case '\'': // ' will double for ""
335 alias_stream
= strecpy(alias_stream
, "\"", lastof(alias_buffer
));
338 case ';': // Cmd separator; execute previous and start new command
339 IConsoleCmdExec(alias_buffer
);
341 alias_stream
= alias_buffer
;
342 *alias_stream
= '\0'; // Make sure the new command is terminated.
347 case '%': // Some or all parameters
350 case '+': { // All parameters separated: "[param 1]" "[param 2]"
351 for (uint i
= 0; i
!= tokencount
; i
++) {
352 if (i
!= 0) alias_stream
= strecpy(alias_stream
, " ", lastof(alias_buffer
));
353 alias_stream
= strecpy(alias_stream
, "\"", lastof(alias_buffer
));
354 alias_stream
= strecpy(alias_stream
, tokens
[i
], lastof(alias_buffer
));
355 alias_stream
= strecpy(alias_stream
, "\"", lastof(alias_buffer
));
360 case '!': { // Merge the parameters to one: "[param 1] [param 2] [param 3...]"
361 alias_stream
= strecpy(alias_stream
, "\"", lastof(alias_buffer
));
362 for (uint i
= 0; i
!= tokencount
; i
++) {
363 if (i
!= 0) alias_stream
= strecpy(alias_stream
, " ", lastof(alias_buffer
));
364 alias_stream
= strecpy(alias_stream
, tokens
[i
], lastof(alias_buffer
));
366 alias_stream
= strecpy(alias_stream
, "\"", lastof(alias_buffer
));
370 default: { // One specific parameter: %A = [param 1] %B = [param 2] ...
371 int param
= *cmdptr
- 'A';
373 if (param
< 0 || param
>= tokencount
) {
374 IConsoleError("too many or wrong amount of parameters passed to alias, aborting");
375 IConsolePrintF(CC_WARNING
, "Usage of alias '%s': %s", alias
->name
, alias
->cmdline
);
379 alias_stream
= strecpy(alias_stream
, "\"", lastof(alias_buffer
));
380 alias_stream
= strecpy(alias_stream
, tokens
[param
], lastof(alias_buffer
));
381 alias_stream
= strecpy(alias_stream
, "\"", lastof(alias_buffer
));
388 *alias_stream
++ = *cmdptr
;
389 *alias_stream
= '\0';
393 if (alias_stream
>= lastof(alias_buffer
) - 1) {
394 IConsoleError("Requested alias execution would overflow execution buffer");
399 IConsoleCmdExec(alias_buffer
);
403 * Execute a given command passed to us. First chop it up into
404 * individual tokens (separated by spaces), then execute it if possible
405 * @param cmdstr string to be parsed and executed
407 void IConsoleCmdExec(const char *cmdstr
)
410 char *tokens
[ICON_TOKEN_COUNT
], tokenstream
[ICON_MAX_STREAMSIZE
];
411 uint t_index
, tstream_i
;
413 bool longtoken
= false;
414 bool foundtoken
= false;
416 if (cmdstr
[0] == '#') return; // comments
418 for (cmdptr
= cmdstr
; *cmdptr
!= '\0'; cmdptr
++) {
419 if (!IsValidChar(*cmdptr
, CS_ALPHANUMERAL
)) {
420 IConsoleError("command contains malformed characters, aborting");
421 IConsolePrintF(CC_ERROR
, "ERROR: command was: '%s'", cmdstr
);
426 DEBUG(console
, 4, "Executing cmdline: '%s'", cmdstr
);
428 memset(&tokens
, 0, sizeof(tokens
));
429 memset(&tokenstream
, 0, sizeof(tokenstream
));
431 /* 1. Split up commandline into tokens, separated by spaces, commands
432 * enclosed in "" are taken as one token. We can only go as far as the amount
433 * of characters in our stream or the max amount of tokens we can handle */
434 for (cmdptr
= cmdstr
, t_index
= 0, tstream_i
= 0; *cmdptr
!= '\0'; cmdptr
++) {
435 if (t_index
>= lengthof(tokens
) || tstream_i
>= lengthof(tokenstream
)) break;
438 case ' ': // Token separator
439 if (!foundtoken
) break;
442 tokenstream
[tstream_i
] = *cmdptr
;
444 tokenstream
[tstream_i
] = '\0';
450 case '"': // Tokens enclosed in "" are one token
451 longtoken
= !longtoken
;
453 tokens
[t_index
++] = &tokenstream
[tstream_i
];
457 case '\\': // Escape character for ""
458 if (cmdptr
[1] == '"' && tstream_i
+ 1 < lengthof(tokenstream
)) {
459 tokenstream
[tstream_i
++] = *++cmdptr
;
463 default: // Normal character
464 tokenstream
[tstream_i
++] = *cmdptr
;
467 tokens
[t_index
++] = &tokenstream
[tstream_i
- 1];
474 for (uint i
= 0; tokens
[i
] != NULL
; i
++) {
475 DEBUG(console
, 8, "Token %d is: '%s'", i
, tokens
[i
]);
478 if (StrEmpty(tokens
[0])) return; // don't execute empty commands
479 /* 2. Determine type of command (cmd or alias) and execute
480 * First try commands, then aliases. Execute
481 * the found action taking into account its hooking code
483 RemoveUnderscores(tokens
[0]);
484 IConsoleCmd
*cmd
= IConsoleCmdGet(tokens
[0]);
486 ConsoleHookResult chr
= (cmd
->hook
== NULL
? CHR_ALLOW
: cmd
->hook(true));
489 if (!cmd
->proc(t_index
, tokens
)) { // index started with 0
490 cmd
->proc(0, NULL
); // if command failed, give help
494 case CHR_DISALLOW
: return;
495 case CHR_HIDE
: break;
500 IConsoleAlias
*alias
= IConsoleAliasGet(tokens
[0]);
502 IConsoleAliasExec(alias
, t_index
, &tokens
[1]);
506 IConsoleError("command not found");