mirror of
https://github.com/weechat/weechat.git
synced 2026-06-27 21:36:37 +02:00
Sebastien Helleu
410 lines
18 KiB
C
410 lines
18 KiB
C
/*
|
|
* Copyright (c) 2003-2007 by FlashCode <flashcode@flashtux.org>
|
|
* See README for License detail, AUTHORS for developers list.
|
|
*
|
|
* This program 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; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* wee-input.c: default callback function to read user input */
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "weechat.h"
|
|
#include "wee-input.h"
|
|
#include "wee-alias.h"
|
|
#include "wee-command.h"
|
|
#include "wee-config.h"
|
|
#include "wee-hook.h"
|
|
#include "wee-string.h"
|
|
#include "../plugins/plugin.h"
|
|
|
|
|
|
/*
|
|
* input_exec_command: executes a command (WeeChat internal or a
|
|
* plugin command)
|
|
* if only_builtin == 1, then try only
|
|
* WeeChat commands (not plugins neither aliases)
|
|
* returns: 1 if command was executed succesfully
|
|
* 0 if error (command not executed)
|
|
*/
|
|
|
|
int
|
|
input_exec_command (struct t_gui_buffer *buffer, char *string,
|
|
int only_builtin)
|
|
{
|
|
int i, rc, argc, return_code, length1, length2;
|
|
char *command, *pos, *ptr_args;
|
|
char **argv, **argv_eol, *alias_command;
|
|
char **commands, **ptr_cmd, **ptr_next_cmd;
|
|
char *args_replaced, *vars_replaced, *new_ptr_cmd;
|
|
int some_args_replaced;
|
|
struct alias *ptr_alias;
|
|
|
|
if ((!string) || (!string[0]) || (string[0] != '/'))
|
|
return 0;
|
|
|
|
command = strdup (string);
|
|
|
|
/* look for end of command */
|
|
ptr_args = NULL;
|
|
|
|
pos = &command[strlen (command) - 1];
|
|
if (pos[0] == ' ')
|
|
{
|
|
while ((pos > command) && (pos[0] == ' '))
|
|
pos--;
|
|
pos[1] = '\0';
|
|
}
|
|
|
|
rc = -1;
|
|
if (!only_builtin)
|
|
{
|
|
rc = hook_command_exec (buffer, command);
|
|
/*vars_replaced = alias_replace_vars (window, ptr_args);
|
|
rc = plugin_cmd_handler_exec (window->buffer->protocol, command + 1,
|
|
(vars_replaced) ? vars_replaced : ptr_args);
|
|
if (vars_replaced)
|
|
free (vars_replaced);*/
|
|
}
|
|
|
|
pos = strchr (command, ' ');
|
|
if (pos)
|
|
{
|
|
pos[0] = '\0';
|
|
pos++;
|
|
while (pos[0] == ' ')
|
|
pos++;
|
|
ptr_args = pos;
|
|
if (!ptr_args[0])
|
|
ptr_args = NULL;
|
|
}
|
|
|
|
switch (rc)
|
|
{
|
|
case 0: /* command hooked, KO */
|
|
gui_chat_printf (NULL,
|
|
_("%sError: command \"%s\" failed"),
|
|
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
|
|
command + 1);
|
|
break;
|
|
case 1: /* command hooked, OK (executed) */
|
|
break;
|
|
default: /* no command hooked */
|
|
argv = string_explode (ptr_args, " ", 0, 0, &argc);
|
|
argv_eol = string_explode (ptr_args, " ", 1, 0, NULL);
|
|
|
|
/* look for alias */
|
|
if (!only_builtin)
|
|
{
|
|
for (ptr_alias = weechat_alias; ptr_alias;
|
|
ptr_alias = ptr_alias->next_alias)
|
|
{
|
|
if (string_strcasecmp (ptr_alias->name, command + 1) == 0)
|
|
{
|
|
if (ptr_alias->running == 1)
|
|
{
|
|
gui_chat_printf (NULL,
|
|
_("%sError: circular reference when "
|
|
"calling alias \"/%s\""),
|
|
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
|
|
ptr_alias->name);
|
|
}
|
|
else
|
|
{
|
|
/* an alias can contain many commands separated by ';' */
|
|
commands = string_split_multi_command (ptr_alias->command,
|
|
';');
|
|
if (commands)
|
|
{
|
|
some_args_replaced = 0;
|
|
ptr_alias->running = 1;
|
|
for (ptr_cmd=commands; *ptr_cmd; ptr_cmd++)
|
|
{
|
|
ptr_next_cmd = ptr_cmd;
|
|
ptr_next_cmd++;
|
|
|
|
vars_replaced = alias_replace_vars (buffer,
|
|
*ptr_cmd);
|
|
new_ptr_cmd = (vars_replaced) ? vars_replaced : *ptr_cmd;
|
|
args_replaced = alias_replace_args (new_ptr_cmd,
|
|
ptr_args);
|
|
if (args_replaced)
|
|
{
|
|
some_args_replaced = 1;
|
|
if (*ptr_cmd[0] == '/')
|
|
(void) input_exec_command (buffer,
|
|
args_replaced,
|
|
only_builtin);
|
|
else
|
|
{
|
|
alias_command = (char *) malloc (1 + strlen(args_replaced) + 1);
|
|
if (alias_command)
|
|
{
|
|
strcpy (alias_command, "/");
|
|
strcat (alias_command, args_replaced);
|
|
(void) input_exec_command (buffer,
|
|
alias_command,
|
|
only_builtin);
|
|
free (alias_command);
|
|
}
|
|
}
|
|
free (args_replaced);
|
|
}
|
|
else
|
|
{
|
|
/* if alias has arguments, they are now
|
|
arguments of the last command in the list (if no $1,$2,..$*) was found */
|
|
if ((*ptr_next_cmd == NULL) && ptr_args && (!some_args_replaced))
|
|
{
|
|
length1 = strlen (new_ptr_cmd);
|
|
length2 = strlen (ptr_args);
|
|
|
|
alias_command = (char *) malloc ( 1 + length1 + 1 + length2 + 1);
|
|
if (alias_command)
|
|
{
|
|
if (*ptr_cmd[0] != '/')
|
|
strcpy (alias_command, "/");
|
|
else
|
|
strcpy (alias_command, "");
|
|
|
|
strcat (alias_command, new_ptr_cmd);
|
|
strcat (alias_command, " ");
|
|
strcat (alias_command, ptr_args);
|
|
|
|
(void) input_exec_command (buffer,
|
|
alias_command,
|
|
only_builtin);
|
|
free (alias_command);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (*ptr_cmd[0] == '/')
|
|
(void) input_exec_command (buffer,
|
|
new_ptr_cmd,
|
|
only_builtin);
|
|
else
|
|
{
|
|
alias_command = (char *) malloc (1 + strlen (new_ptr_cmd) + 1);
|
|
if (alias_command)
|
|
{
|
|
strcpy (alias_command, "/");
|
|
strcat (alias_command, new_ptr_cmd);
|
|
(void) input_exec_command (buffer,
|
|
alias_command,
|
|
only_builtin);
|
|
free (alias_command);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (vars_replaced)
|
|
free (vars_replaced);
|
|
}
|
|
ptr_alias->running = 0;
|
|
string_free_multi_command (commands);
|
|
}
|
|
}
|
|
string_free_exploded (argv);
|
|
string_free_exploded (argv_eol);
|
|
free (command);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* look for WeeChat command */
|
|
for (i = 0; weechat_commands[i].name; i++)
|
|
{
|
|
if (string_strcasecmp (weechat_commands[i].name, command + 1) == 0)
|
|
{
|
|
if ((argc < weechat_commands[i].min_arg)
|
|
|| (argc > weechat_commands[i].max_arg))
|
|
{
|
|
if (weechat_commands[i].min_arg ==
|
|
weechat_commands[i].max_arg)
|
|
{
|
|
gui_chat_printf (NULL,
|
|
NG_("%sError: wrong argument count "
|
|
"for %s command \"%s\" "
|
|
"(expected: %d arg)",
|
|
"%s%s wrong argument count "
|
|
"for %s command \"%s\" "
|
|
"(expected: %d args)",
|
|
weechat_commands[i].max_arg),
|
|
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
|
|
PACKAGE_NAME,
|
|
command + 1,
|
|
weechat_commands[i].max_arg);
|
|
}
|
|
else
|
|
{
|
|
gui_chat_printf (NULL,
|
|
NG_("%sError: wrong argument count "
|
|
"for %s command \"%s\" "
|
|
"(expected: between %d and "
|
|
"%d arg)",
|
|
"%s%s wrong argument count "
|
|
"for %s command \"%s\" "
|
|
"(expected: between %d and "
|
|
"%d args)",
|
|
weechat_commands[i].max_arg),
|
|
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
|
|
PACKAGE_NAME,
|
|
command + 1,
|
|
weechat_commands[i].min_arg,
|
|
weechat_commands[i].max_arg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*ptr_args2 = (ptr_args) ? (char *)gui_color_encode ((unsigned char *)ptr_args,
|
|
(weechat_commands[i].conversion
|
|
&& cfg_irc_colors_send)) : NULL;*/
|
|
return_code = (int) (weechat_commands[i].cmd_function)
|
|
(buffer, argc, argv, argv_eol);
|
|
if (return_code < 0)
|
|
{
|
|
gui_chat_printf (NULL,
|
|
_("%sError: command \"%s\" failed"),
|
|
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
|
|
command + 1);
|
|
}
|
|
}
|
|
string_free_exploded (argv);
|
|
string_free_exploded (argv_eol);
|
|
free (command);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* should we send unknown command to IRC server? */
|
|
/*if (cfg_irc_send_unknown_commands)
|
|
{
|
|
if (ptr_args)
|
|
unknown_command = (char *)malloc (strlen (command + 1) + 1 + strlen (ptr_args) + 1);
|
|
else
|
|
unknown_command = (char *)malloc (strlen (command + 1) + 1);
|
|
|
|
if (unknown_command)
|
|
{
|
|
strcpy (unknown_command, command + 1);
|
|
if (ptr_args)
|
|
{
|
|
strcat (unknown_command, " ");
|
|
strcat (unknown_command, ptr_args);
|
|
}
|
|
irc_send_cmd_quote (server, channel, unknown_command);
|
|
free (unknown_command);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gui_chat_printf_error (NULL,
|
|
_("Error: unknown command \"%s\" (type /help for help). "
|
|
"To send unknown commands to IRC server, enable option "
|
|
"irc_send_unknown_commands."),
|
|
command + 1);
|
|
}*/
|
|
|
|
gui_chat_printf (NULL,
|
|
_("%sError: unknown command \"%s\" (type /help "
|
|
"for help)."),
|
|
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
|
|
command + 1);
|
|
|
|
string_free_exploded (argv);
|
|
string_free_exploded (argv_eol);
|
|
}
|
|
free (command);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* input_data: read user input and send data to protocol
|
|
*/
|
|
|
|
void
|
|
input_data (struct t_gui_buffer *buffer, char *data, int only_builtin)
|
|
{
|
|
char *new_data, *ptr_data, *pos;
|
|
|
|
if (!buffer || !data || !data[0] || (data[0] == '\r') || (data[0] == '\n'))
|
|
return;
|
|
|
|
/* TODO: modifier for input */
|
|
/*new_data = plugin_modifier_exec (PLUGIN_MODIFIER_IRC_USER,
|
|
"", data);*/
|
|
new_data = strdup (data);
|
|
|
|
/* no changes in new data */
|
|
if (new_data && (strcmp (data, new_data) == 0))
|
|
{
|
|
free (new_data);
|
|
new_data = NULL;
|
|
}
|
|
|
|
/* message not dropped? */
|
|
if (!new_data || new_data[0])
|
|
{
|
|
/* use new data (returned by plugin) */
|
|
ptr_data = (new_data) ? new_data : data;
|
|
|
|
while (ptr_data && ptr_data[0])
|
|
{
|
|
pos = strchr (ptr_data, '\n');
|
|
if (pos)
|
|
pos[0] = '\0';
|
|
|
|
if (command_is_command (ptr_data))
|
|
{
|
|
/* WeeChat or plugin command */
|
|
(void) input_exec_command (buffer, ptr_data,
|
|
only_builtin);
|
|
}
|
|
else
|
|
{
|
|
if ((ptr_data[0] == '/') && (ptr_data[1] == '/'))
|
|
ptr_data++;
|
|
|
|
hook_command_exec (buffer, ptr_data);
|
|
|
|
if (buffer->input_data_cb)
|
|
{
|
|
(void)(buffer->input_data_cb) (buffer, ptr_data);
|
|
}
|
|
else
|
|
gui_chat_printf (buffer,
|
|
_("%sYou can not write text in this "
|
|
"buffer!"),
|
|
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR]);
|
|
}
|
|
|
|
if (pos)
|
|
{
|
|
pos[0] = '\n';
|
|
ptr_data = pos + 1;
|
|
}
|
|
else
|
|
ptr_data = NULL;
|
|
}
|
|
}
|
|
}
|