Added sources to manage input data (from user input to weechat or plugin)

2 files changed, 434 insertions, 0 deletions

diff --git a/src/core/wee-input.c b/src/core/wee-input.c
new file mode 100644
index 000000000..18671cc90
--- /dev/null
+++ b/src/core/wee-input.c
@@ -0,0 +1,407 @@
+/*
+ * 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, *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';
+    }
+    
+    pos = strchr (command, ' ');
+    if (pos)
+    {
+        pos[0] = '\0';
+        pos++;
+        while (pos[0] == ' ')
+            pos++;
+        ptr_args = pos;
+        if (!ptr_args[0])
+            ptr_args = NULL;
+    }
+
+    rc = -1;
+    if (!only_builtin)
+    {
+        rc = hook_command_exec (buffer->plugin, command + 1, ptr_args);
+        /*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);*/
+    }
+    
+    switch (rc)
+    {
+        case 0: /* plugin handler KO */
+            gui_chat_printf (NULL,
+                             _("%s%s command \"%s\" failed"),
+                             gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
+                             WEECHAT_ERROR, command + 1);
+            break;
+        case 1: /* plugin handler OK, executed */
+            break;
+        default: /* plugin handler not found */
+            argv = string_explode (ptr_args, " ", 0, &argc);
+            
+            /* 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,
+                                             _("%s%s circular reference when "
+                                               "calling alias \"/%s\""),
+                                             gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
+                                             WEECHAT_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);
+                        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_("%s%s 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],
+                                             WEECHAT_ERROR, PACKAGE_NAME,
+                                             command + 1,
+                                             weechat_commands[i].max_arg);
+                        }
+                        else
+                        {
+                            gui_chat_printf (NULL,
+                                             NG_("%s%s 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],
+                                             WEECHAT_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, ptr_args, argc, argv);
+                        if (return_code < 0)
+                        {
+                            gui_chat_printf (NULL,
+                                             _("%s%s command \"%s\" failed"),
+                                             gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
+                                             WEECHAT_ERROR, command + 1);
+                        }
+                    }
+                    string_free_exploded (argv);
+                    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,
+                                       _("%s unknown command \"%s\" (type /help for help). "
+                                         "To send unknown commands to IRC server, enable option "
+                                         "irc_send_unknown_commands."),
+                                       WEECHAT_ERROR,
+                                       command + 1);
+            }*/
+
+            gui_chat_printf (NULL,
+                             _("%s%s unknown command \"%s\" (type /help "
+                               "for help)."),
+                             gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
+                             WEECHAT_ERROR,
+                             command + 1);
+            
+            string_free_exploded (argv);
+    }
+    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 protocol command */
+                (void) input_exec_command (buffer, ptr_data,
+                                           only_builtin);
+            }
+            else
+            {
+                if ((ptr_data[0] == '/') && (ptr_data[1] == '/'))
+                    ptr_data++;
+
+                hook_command_exec (buffer->plugin, "", 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;
+        }
+    }
+}
diff --git a/src/core/wee-input.h b/src/core/wee-input.h
new file mode 100644
index 000000000..b2bef04c9
--- /dev/null
+++ b/src/core/wee-input.h
@@ -0,0 +1,27 @@
+/*
+ * 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/>.
+ */
+
+
+#ifndef __WEECHAT_INPUT_H
+#define __WEECHAT_INPUT_H 1
+
+#include "../gui/gui-buffer.h"
+
+extern void input_data (struct t_gui_buffer *, char *, int);
+
+#endif /* wee-input.h */