core: simplify gui input functions by returning immediately if condition not met

1 files changed, 391 insertions, 387 deletions

diff --git a/src/gui/gui-input.c b/src/gui/gui-input.c
index 04b6a3fca..c7784047a 100644
--- a/src/gui/gui-input.c
+++ b/src/gui/gui-input.c
@@ -248,39 +248,39 @@ gui_input_insert_string (struct t_gui_buffer *buffer, const char *string,
     int size, length;
     char *string_utf8, *ptr_start;
 
-    if (buffer->input)
-    {
-        string_utf8 = strdup (string);
-        if (!string_utf8)
-            return;
+    if (!buffer->input)
+        return;
 
-        if (pos == -1)
-            pos = buffer->input_buffer_pos;
+    string_utf8 = strdup (string);
+    if (!string_utf8)
+        return;
 
-        utf8_normalize (string_utf8, '?');
+    if (pos == -1)
+        pos = buffer->input_buffer_pos;
 
-        size = strlen (string_utf8);
-        length = utf8_strlen (string_utf8);
+    utf8_normalize (string_utf8, '?');
 
-        if (gui_input_optimize_size (buffer,
-                                     buffer->input_buffer_size + size,
-                                     buffer->input_buffer_length + length))
-        {
-            buffer->input_buffer[buffer->input_buffer_size] = '\0';
+    size = strlen (string_utf8);
+    length = utf8_strlen (string_utf8);
 
-            /* move end of string to the right */
-            ptr_start = (char *)utf8_add_offset (buffer->input_buffer, pos);
-            memmove (ptr_start + size, ptr_start, strlen (ptr_start));
+    if (gui_input_optimize_size (buffer,
+                                 buffer->input_buffer_size + size,
+                                 buffer->input_buffer_length + length))
+    {
+        buffer->input_buffer[buffer->input_buffer_size] = '\0';
 
-            /* insert new string */
-            ptr_start = (char *)utf8_add_offset (buffer->input_buffer, pos);
-            memcpy (ptr_start, string_utf8, size);
+        /* move end of string to the right */
+        ptr_start = (char *)utf8_add_offset (buffer->input_buffer, pos);
+        memmove (ptr_start + size, ptr_start, strlen (ptr_start));
 
-            buffer->input_buffer_pos += length;
-        }
+        /* insert new string */
+        ptr_start = (char *)utf8_add_offset (buffer->input_buffer, pos);
+        memcpy (ptr_start, string_utf8, size);
 
-        free (string_utf8);
+        buffer->input_buffer_pos += length;
     }
+
+    free (string_utf8);
 }
 
 /*
@@ -447,77 +447,74 @@ gui_input_complete (struct t_gui_buffer *buffer)
 {
     int i;
 
-    if (!buffer->completion)
+    if (!buffer->completion || !buffer->completion->word_found)
         return;
 
-    if (buffer->completion->word_found)
+    /* replace word with new completed word into input buffer */
+    if (buffer->completion->diff_size > 0)
     {
-        /* replace word with new completed word into input buffer */
-        if (buffer->completion->diff_size > 0)
-        {
-            if (gui_input_optimize_size (
-                    buffer,
-                    buffer->input_buffer_size + buffer->completion->diff_size,
-                    buffer->input_buffer_length + buffer->completion->diff_length))
-            {
-                buffer->input_buffer[buffer->input_buffer_size] = '\0';
-                for (i = buffer->input_buffer_size - 1;
-                     i >= buffer->completion->position_replace +
-                         (int)strlen (buffer->completion->word_found); i--)
-                {
-                    buffer->input_buffer[i] =
-                        buffer->input_buffer[i - buffer->completion->diff_size];
-                }
-            }
-        }
-        else
+        if (gui_input_optimize_size (
+                buffer,
+                buffer->input_buffer_size + buffer->completion->diff_size,
+                buffer->input_buffer_length + buffer->completion->diff_length))
         {
-            for (i = buffer->completion->position_replace +
-                     strlen (buffer->completion->word_found);
-                 i < buffer->input_buffer_size; i++)
+            buffer->input_buffer[buffer->input_buffer_size] = '\0';
+            for (i = buffer->input_buffer_size - 1;
+                 i >= buffer->completion->position_replace +
+                     (int)strlen (buffer->completion->word_found); i--)
             {
                 buffer->input_buffer[i] =
                     buffer->input_buffer[i - buffer->completion->diff_size];
             }
-            if (gui_input_optimize_size (
-                    buffer,
-                    buffer->input_buffer_size + buffer->completion->diff_size,
-                    buffer->input_buffer_length += buffer->completion->diff_length))
-            {
-                buffer->input_buffer[buffer->input_buffer_size] = '\0';
-            }
         }
+    }
+    else
+    {
+        for (i = buffer->completion->position_replace +
+                 strlen (buffer->completion->word_found);
+             i < buffer->input_buffer_size; i++)
+        {
+            buffer->input_buffer[i] =
+                buffer->input_buffer[i - buffer->completion->diff_size];
+        }
+        if (gui_input_optimize_size (
+                buffer,
+                buffer->input_buffer_size + buffer->completion->diff_size,
+                buffer->input_buffer_length += buffer->completion->diff_length))
+        {
+            buffer->input_buffer[buffer->input_buffer_size] = '\0';
+        }
+    }
 
-        strncpy (buffer->input_buffer + buffer->completion->position_replace,
-                 buffer->completion->word_found,
-                 strlen (buffer->completion->word_found));
-        buffer->input_buffer_pos =
-            utf8_pos (buffer->input_buffer,
-                      buffer->completion->position_replace) +
-            utf8_strlen (buffer->completion->word_found);
+    strncpy (buffer->input_buffer + buffer->completion->position_replace,
+             buffer->completion->word_found,
+             strlen (buffer->completion->word_found));
+    buffer->input_buffer_pos =
+        utf8_pos (buffer->input_buffer,
+                  buffer->completion->position_replace) +
+        utf8_strlen (buffer->completion->word_found);
 
-        /*
-         * position is < 0 this means only one word was found to complete,
-         * so reinit to stop completion
-         */
-        if (buffer->completion->position >= 0)
-            buffer->completion->position = utf8_real_pos (buffer->input_buffer,
-                                                          buffer->input_buffer_pos);
+    /*
+     * position is < 0 this means only one word was found to complete,
+     * so reinit to stop completion
+     */
+    if (buffer->completion->position >= 0)
+        buffer->completion->position = utf8_real_pos (buffer->input_buffer,
+                                                      buffer->input_buffer_pos);
 
-        /* add space if needed after completion */
-        if (buffer->completion->add_space)
+    /* add space if needed after completion */
+    if (buffer->completion->add_space)
+    {
+        if (buffer->input_buffer[utf8_real_pos (buffer->input_buffer,
+                                                buffer->input_buffer_pos)] != ' ')
         {
-            if (buffer->input_buffer[utf8_real_pos (buffer->input_buffer,
-                                                    buffer->input_buffer_pos)] != ' ')
-            {
-                gui_input_insert_string (buffer, " ",
-                                         buffer->input_buffer_pos);
-            }
-            else
-                buffer->input_buffer_pos++;
-            if (buffer->completion->position >= 0)
-                buffer->completion->position++;
+            gui_input_insert_string (buffer, " ",
+                                     buffer->input_buffer_pos);
         }
+        else
+            buffer->input_buffer_pos++;
+        if (buffer->completion->position >= 0)
+            buffer->completion->position++;
     }
 }
 
@@ -528,21 +525,20 @@ gui_input_complete (struct t_gui_buffer *buffer)
 void
 gui_input_complete_next (struct t_gui_buffer *buffer)
 {
-    if (buffer->input
-        && (buffer->text_search == GUI_TEXT_SEARCH_DISABLED))
+    if (!buffer->input ||(buffer->text_search != GUI_TEXT_SEARCH_DISABLED))
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    if (gui_completion_search (buffer->completion,
+                               buffer->input_buffer,
+                               buffer->input_buffer_pos,
+                               1))
     {
-        gui_buffer_undo_snap (buffer);
-        if (gui_completion_search (buffer->completion,
-                                   buffer->input_buffer,
-                                   buffer->input_buffer_pos,
-                                   1))
-        {
-            gui_input_complete (buffer);
-            gui_input_text_changed_modifier_and_signal (
-                buffer,
-                1, /* save undo */
-                0); /* stop completion */
-        }
+        gui_input_complete (buffer);
+        gui_input_text_changed_modifier_and_signal (
+            buffer,
+            1, /* save undo */
+            0); /* stop completion */
     }
 }
 
@@ -553,21 +549,20 @@ gui_input_complete_next (struct t_gui_buffer *buffer)
 void
 gui_input_complete_previous (struct t_gui_buffer *buffer)
 {
-    if (buffer->input
-        && (buffer->text_search == GUI_TEXT_SEARCH_DISABLED))
+    if (!buffer->input || (buffer->text_search != GUI_TEXT_SEARCH_DISABLED))
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    if (gui_completion_search (buffer->completion,
+                               buffer->input_buffer,
+                               buffer->input_buffer_pos,
+                               -1))
     {
-        gui_buffer_undo_snap (buffer);
-        if (gui_completion_search (buffer->completion,
-                                   buffer->input_buffer,
-                                   buffer->input_buffer_pos,
-                                   -1))
-        {
-            gui_input_complete (buffer);
-            gui_input_text_changed_modifier_and_signal (
-                buffer,
-                1, /* save undo */
-                0); /* stop completion */
-        }
+        gui_input_complete (buffer);
+        gui_input_text_changed_modifier_and_signal (
+            buffer,
+            1, /* save undo */
+            0); /* stop completion */
     }
 }
 
@@ -783,26 +778,26 @@ gui_input_delete_previous_char (struct t_gui_buffer *buffer)
     char *pos, *pos_last;
     int char_size, size_to_move;
 
-    if (buffer->input && (buffer->input_buffer_pos > 0))
+    if (!buffer->input || (buffer->input_buffer_pos <= 0))
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    pos = (char *)utf8_add_offset (buffer->input_buffer,
+                                   buffer->input_buffer_pos);
+    pos_last = (char *)utf8_prev_char (buffer->input_buffer, pos);
+    char_size = pos - pos_last;
+    size_to_move = strlen (pos);
+    memmove (pos_last, pos, size_to_move);
+    if (gui_input_optimize_size (buffer,
+                                 buffer->input_buffer_size - char_size,
+                                 buffer->input_buffer_length - 1))
     {
-        gui_buffer_undo_snap (buffer);
-        pos = (char *)utf8_add_offset (buffer->input_buffer,
-                                       buffer->input_buffer_pos);
-        pos_last = (char *)utf8_prev_char (buffer->input_buffer, pos);
-        char_size = pos - pos_last;
-        size_to_move = strlen (pos);
-        memmove (pos_last, pos, size_to_move);
-        if (gui_input_optimize_size (buffer,
-                                     buffer->input_buffer_size - char_size,
-                                     buffer->input_buffer_length - 1))
-        {
-            buffer->input_buffer_pos--;
-            buffer->input_buffer[buffer->input_buffer_size] = '\0';
-        }
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
+        buffer->input_buffer_pos--;
+        buffer->input_buffer[buffer->input_buffer_size] = '\0';
     }
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
 }
 
 /*
@@ -815,26 +810,28 @@ gui_input_delete_next_char (struct t_gui_buffer *buffer)
     char *pos, *pos_next;
     int char_size, size_to_move;
 
-    if (buffer->input
-        && (buffer->input_buffer_pos < buffer->input_buffer_length))
+    if (!buffer->input
+        || (buffer->input_buffer_pos >= buffer->input_buffer_length))
     {
-        gui_buffer_undo_snap (buffer);
-        pos = (char *)utf8_add_offset (buffer->input_buffer,
-                                       buffer->input_buffer_pos);
-        pos_next = (char *)utf8_next_char (pos);
-        char_size = pos_next - pos;
-        size_to_move = strlen (pos_next);
-        memmove (pos, pos_next, size_to_move);
-        if (gui_input_optimize_size (buffer,
-                                     buffer->input_buffer_size - char_size,
-                                     buffer->input_buffer_length - 1))
-        {
-            buffer->input_buffer[buffer->input_buffer_size] = '\0';
-        }
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
+        return;
+    }
+
+    gui_buffer_undo_snap (buffer);
+    pos = (char *)utf8_add_offset (buffer->input_buffer,
+                                   buffer->input_buffer_pos);
+    pos_next = (char *)utf8_next_char (pos);
+    char_size = pos_next - pos;
+    size_to_move = strlen (pos_next);
+    memmove (pos, pos_next, size_to_move);
+    if (gui_input_optimize_size (buffer,
+                                 buffer->input_buffer_size - char_size,
+                                 buffer->input_buffer_length - 1))
+    {
+        buffer->input_buffer[buffer->input_buffer_size] = '\0';
     }
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
 }
 
 /*
@@ -878,33 +875,33 @@ gui_input_delete_previous_word (struct t_gui_buffer *buffer)
 {
     char *start, *string;
 
-    if (buffer->input && (buffer->input_buffer_pos > 0))
+    if (!buffer->input || (buffer->input_buffer_pos <= 0))
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    start = (char *)utf8_add_offset (buffer->input_buffer,
+                                     buffer->input_buffer_pos - 1);
+    string = start;
+    /* move to the left until we reach a word char */
+    while (string && !string_is_word_char_input (string))
     {
-        gui_buffer_undo_snap (buffer);
-        start = (char *)utf8_add_offset (buffer->input_buffer,
-                                         buffer->input_buffer_pos - 1);
-        string = start;
-        /* move to the left until we reach a word char */
-        while (string && !string_is_word_char_input (string))
+        string = (char *)utf8_prev_char (buffer->input_buffer, string);
+    }
+    /* move to the left to skip the whole word */
+    if (string)
+    {
+        while (string && string_is_word_char_input (string))
         {
             string = (char *)utf8_prev_char (buffer->input_buffer, string);
         }
-        /* move to the left to skip the whole word */
-        if (string)
-        {
-            while (string && string_is_word_char_input (string))
-            {
-                string = (char *)utf8_prev_char (buffer->input_buffer, string);
-            }
-        }
+    }
 
-        if (string)
-            string = (char *)utf8_next_char (string);
-        else
-            string = buffer->input_buffer;
+    if (string)
+        string = (char *)utf8_next_char (string);
+    else
+        string = buffer->input_buffer;
 
-        gui_input_delete_range (buffer, string, start);
-    }
+    gui_input_delete_range (buffer, string, start);
 }
 
 /*
@@ -916,33 +913,33 @@ gui_input_delete_previous_word_whitespace (struct t_gui_buffer *buffer)
 {
     char *start, *string;
 
-    if (buffer->input && (buffer->input_buffer_pos > 0))
+    if (!buffer->input || (buffer->input_buffer_pos <= 0))
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    start = (char *)utf8_add_offset (buffer->input_buffer,
+                                     buffer->input_buffer_pos - 1);
+    string = start;
+    /* move to the left, skipping whitespace */
+    while (string && string_is_whitespace_char (string))
     {
-        gui_buffer_undo_snap (buffer);
-        start = (char *)utf8_add_offset (buffer->input_buffer,
-                                         buffer->input_buffer_pos - 1);
-        string = start;
-        /* move to the left, skipping whitespace */
-        while (string && string_is_whitespace_char (string))
+        string = (char *)utf8_prev_char (buffer->input_buffer, string);
+    }
+    /* move to the left until we reach a char which is not whitespace */
+    if (string)
+    {
+        while (string && !string_is_whitespace_char (string))
         {
             string = (char *)utf8_prev_char (buffer->input_buffer, string);
         }
-        /* move to the left until we reach a char which is not whitespace */
-        if (string)
-        {
-            while (string && !string_is_whitespace_char (string))
-            {
-                string = (char *)utf8_prev_char (buffer->input_buffer, string);
-            }
-        }
+    }
 
-        if (string)
-            string = (char *)utf8_next_char (string);
-        else
-            string = buffer->input_buffer;
+    if (string)
+        string = (char *)utf8_next_char (string);
+    else
+        string = buffer->input_buffer;
 
-        gui_input_delete_range (buffer, string, start);
-    }
+    gui_input_delete_range (buffer, string, start);
 }
 
 /*
@@ -955,42 +952,42 @@ gui_input_delete_next_word (struct t_gui_buffer *buffer)
     int size_deleted, length_deleted;
     char *start, *string;
 
-    if (buffer->input)
+    if (!buffer->input)
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    start = (char *)utf8_add_offset (buffer->input_buffer,
+                                     buffer->input_buffer_pos);
+    string = start;
+    length_deleted = 0;
+    /* move to the right until we reach a word char */
+    while (string[0] && !string_is_word_char_input (string))
     {
-        gui_buffer_undo_snap (buffer);
-        start = (char *)utf8_add_offset (buffer->input_buffer,
-                                         buffer->input_buffer_pos);
-        string = start;
-        length_deleted = 0;
-        /* move to the right until we reach a word char */
-        while (string[0] && !string_is_word_char_input (string))
-        {
-            string = (char *)utf8_next_char (string);
-            length_deleted++;
-        }
-        /* move to the right to skip the whole word */
-        while (string[0] && string_is_word_char_input (string))
-        {
-            string = (char *)utf8_next_char (string);
-            length_deleted++;
-        }
-        size_deleted = string - start;
+        string = (char *)utf8_next_char (string);
+        length_deleted++;
+    }
+    /* move to the right to skip the whole word */
+    while (string[0] && string_is_word_char_input (string))
+    {
+        string = (char *)utf8_next_char (string);
+        length_deleted++;
+    }
+    size_deleted = string - start;
 
-        gui_input_clipboard_copy (start, size_deleted);
+    gui_input_clipboard_copy (start, size_deleted);
 
-        memmove (start, string, strlen (string));
+    memmove (start, string, strlen (string));
 
-        if (gui_input_optimize_size (
-                buffer,
-                buffer->input_buffer_size - size_deleted,
-                buffer->input_buffer_length - length_deleted))
-        {
-            buffer->input_buffer[buffer->input_buffer_size] = '\0';
-        }
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
+    if (gui_input_optimize_size (
+            buffer,
+            buffer->input_buffer_size - size_deleted,
+            buffer->input_buffer_length - length_deleted))
+    {
+        buffer->input_buffer[buffer->input_buffer_size] = '\0';
     }
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
 }
 
 
@@ -1004,30 +1001,30 @@ gui_input_delete_beginning_of_line (struct t_gui_buffer *buffer)
     int length_deleted, size_deleted;
     char *start;
 
-    if (buffer->input && (buffer->input_buffer_pos > 0))
-    {
-        gui_buffer_undo_snap (buffer);
-        start = (char *)utf8_add_offset (buffer->input_buffer,
-                                         buffer->input_buffer_pos);
-        size_deleted = start - buffer->input_buffer;
-        length_deleted = utf8_strnlen (buffer->input_buffer, size_deleted);
-        gui_input_clipboard_copy (buffer->input_buffer,
-                                  start - buffer->input_buffer);
+    if (!buffer->input || (buffer->input_buffer_pos <= 0))
+        return;
 
-        memmove (buffer->input_buffer, start, strlen (start));
+    gui_buffer_undo_snap (buffer);
+    start = (char *)utf8_add_offset (buffer->input_buffer,
+                                     buffer->input_buffer_pos);
+    size_deleted = start - buffer->input_buffer;
+    length_deleted = utf8_strnlen (buffer->input_buffer, size_deleted);
+    gui_input_clipboard_copy (buffer->input_buffer,
+                              start - buffer->input_buffer);
 
-        if (gui_input_optimize_size (
-                buffer,
-                buffer->input_buffer_size - size_deleted,
-                buffer->input_buffer_length - length_deleted))
-        {
-            buffer->input_buffer[buffer->input_buffer_size] = '\0';
-            buffer->input_buffer_pos = 0;
-        }
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
+    memmove (buffer->input_buffer, start, strlen (start));
+
+    if (gui_input_optimize_size (
+            buffer,
+            buffer->input_buffer_size - size_deleted,
+            buffer->input_buffer_length - length_deleted))
+    {
+        buffer->input_buffer[buffer->input_buffer_size] = '\0';
+        buffer->input_buffer_pos = 0;
     }
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
 }
 
 /*
@@ -1040,21 +1037,21 @@ gui_input_delete_end_of_line (struct t_gui_buffer *buffer)
     char *start;
     int size_deleted;
 
-    if (buffer->input)
-    {
-        gui_buffer_undo_snap (buffer);
-        start = (char *)utf8_add_offset (buffer->input_buffer,
-                                         buffer->input_buffer_pos);
-        size_deleted = strlen (start);
-        gui_input_clipboard_copy (start, size_deleted);
-        start[0] = '\0';
-        (void) gui_input_optimize_size (buffer,
-                                        strlen (buffer->input_buffer),
-                                        utf8_strlen (buffer->input_buffer));
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
-    }
+    if (!buffer->input)
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    start = (char *)utf8_add_offset (buffer->input_buffer,
+                                     buffer->input_buffer_pos);
+    size_deleted = strlen (start);
+    gui_input_clipboard_copy (start, size_deleted);
+    start[0] = '\0';
+    (void) gui_input_optimize_size (buffer,
+                                    strlen (buffer->input_buffer),
+                                    utf8_strlen (buffer->input_buffer));
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
 }
 
 /*
@@ -1064,18 +1061,18 @@ gui_input_delete_end_of_line (struct t_gui_buffer *buffer)
 void
 gui_input_delete_line (struct t_gui_buffer *buffer)
 {
-    if (buffer->input)
+    if (!buffer->input)
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    if (gui_input_optimize_size (buffer, 0, 0))
     {
-        gui_buffer_undo_snap (buffer);
-        if (gui_input_optimize_size (buffer, 0, 0))
-        {
-            buffer->input_buffer[0] = '\0';
-            buffer->input_buffer_pos = 0;
-        }
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
+        buffer->input_buffer[0] = '\0';
+        buffer->input_buffer_pos = 0;
     }
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
 }
 
 /*
@@ -1088,30 +1085,33 @@ gui_input_transpose_chars (struct t_gui_buffer *buffer)
     char *start, *prev_char, saved_char[5];
     int size_prev_char, size_start_char;
 
-    if (buffer->input && (buffer->input_buffer_pos > 0)
-        && (buffer->input_buffer_length > 1))
+    if (!buffer->input
+        || (buffer->input_buffer_pos <= 0)
+        || (buffer->input_buffer_length <= 1))
     {
-        gui_buffer_undo_snap (buffer);
+        return;
+    }
 
-        if (buffer->input_buffer_pos == buffer->input_buffer_length)
-            buffer->input_buffer_pos--;
+    gui_buffer_undo_snap (buffer);
 
-        start = (char *)utf8_add_offset (buffer->input_buffer,
-                                         buffer->input_buffer_pos);
-        prev_char = (char *)utf8_prev_char (buffer->input_buffer, start);
-        size_prev_char = start - prev_char;
-        size_start_char = utf8_char_size (start);
+    if (buffer->input_buffer_pos == buffer->input_buffer_length)
+        buffer->input_buffer_pos--;
 
-        memcpy (saved_char, prev_char, size_prev_char);
-        memcpy (prev_char, start, size_start_char);
-        memcpy (prev_char + size_start_char, saved_char, size_prev_char);
+    start = (char *)utf8_add_offset (buffer->input_buffer,
+                                     buffer->input_buffer_pos);
+    prev_char = (char *)utf8_prev_char (buffer->input_buffer, start);
+    size_prev_char = start - prev_char;
+    size_start_char = utf8_char_size (start);
 
-        buffer->input_buffer_pos++;
+    memcpy (saved_char, prev_char, size_prev_char);
+    memcpy (prev_char, start, size_start_char);
+    memcpy (prev_char + size_start_char, saved_char, size_prev_char);
 
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
-    }
+    buffer->input_buffer_pos++;
+
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
 }
 
 /*
@@ -1121,11 +1121,11 @@ gui_input_transpose_chars (struct t_gui_buffer *buffer)
 void
 gui_input_move_beginning_of_line (struct t_gui_buffer *buffer)
 {
-    if (buffer->input && (buffer->input_buffer_pos > 0))
-    {
-        buffer->input_buffer_pos = 0;
-        gui_input_text_cursor_moved_signal (buffer);
-    }
+    if (!buffer->input || (buffer->input_buffer_pos <= 0))
+        return;
+
+    buffer->input_buffer_pos = 0;
+    gui_input_text_cursor_moved_signal (buffer);
 }
 
 /*
@@ -1135,12 +1135,14 @@ gui_input_move_beginning_of_line (struct t_gui_buffer *buffer)
 void
 gui_input_move_end_of_line (struct t_gui_buffer *buffer)
 {
-    if (buffer->input
-        && (buffer->input_buffer_pos < buffer->input_buffer_length))
+    if (!buffer->input
+        || (buffer->input_buffer_pos >= buffer->input_buffer_length))
     {
-        buffer->input_buffer_pos = buffer->input_buffer_length;
-        gui_input_text_cursor_moved_signal (buffer);
+        return;
     }
+
+    buffer->input_buffer_pos = buffer->input_buffer_length;
+    gui_input_text_cursor_moved_signal (buffer);
 }
 
 /*
@@ -1150,11 +1152,11 @@ gui_input_move_end_of_line (struct t_gui_buffer *buffer)
 void
 gui_input_move_previous_char (struct t_gui_buffer *buffer)
 {
-    if (buffer->input && (buffer->input_buffer_pos > 0))
-    {
-        buffer->input_buffer_pos--;
-        gui_input_text_cursor_moved_signal (buffer);
-    }
+    if (!buffer->input || (buffer->input_buffer_pos <= 0))
+        return;
+
+    buffer->input_buffer_pos--;
+    gui_input_text_cursor_moved_signal (buffer);
 }
 
 /*
@@ -1164,12 +1166,14 @@ gui_input_move_previous_char (struct t_gui_buffer *buffer)
 void
 gui_input_move_next_char (struct t_gui_buffer *buffer)
 {
-    if (buffer->input
-        && (buffer->input_buffer_pos < buffer->input_buffer_length))
+    if (!buffer->input
+        || (buffer->input_buffer_pos >= buffer->input_buffer_length))
     {
-        buffer->input_buffer_pos++;
-        gui_input_text_cursor_moved_signal (buffer);
+        return;
     }
+
+    buffer->input_buffer_pos++;
+    gui_input_text_cursor_moved_signal (buffer);
 }
 
 /*
@@ -1182,33 +1186,32 @@ gui_input_move_previous_word (struct t_gui_buffer *buffer)
 {
     char *pos;
 
-    if (buffer->input
-        && (buffer->input_buffer_pos > 0))
+    if (!buffer->input || (buffer->input_buffer_pos <= 0))
+        return;
+
+    pos = (char *)utf8_add_offset (buffer->input_buffer,
+                                   buffer->input_buffer_pos - 1);
+    while (pos && !string_is_word_char_input (pos))
+    {
+        pos = (char *)utf8_prev_char (buffer->input_buffer, pos);
+    }
+    if (pos)
     {
-        pos = (char *)utf8_add_offset (buffer->input_buffer,
-                                       buffer->input_buffer_pos - 1);
-        while (pos && !string_is_word_char_input (pos))
+        while (pos && string_is_word_char_input (pos))
         {
             pos = (char *)utf8_prev_char (buffer->input_buffer, pos);
         }
         if (pos)
-        {
-            while (pos && string_is_word_char_input (pos))
-            {
-                pos = (char *)utf8_prev_char (buffer->input_buffer, pos);
-            }
-            if (pos)
-                pos = (char *)utf8_next_char (pos);
-            else
-                pos = buffer->input_buffer;
-            buffer->input_buffer_pos = utf8_pos (buffer->input_buffer,
-                                                 pos - buffer->input_buffer);
-        }
+            pos = (char *)utf8_next_char (pos);
         else
-            buffer->input_buffer_pos = 0;
-
-        gui_input_text_cursor_moved_signal (buffer);
+            pos = buffer->input_buffer;
+        buffer->input_buffer_pos = utf8_pos (buffer->input_buffer,
+                                             pos - buffer->input_buffer);
     }
+    else
+        buffer->input_buffer_pos = 0;
+
+    gui_input_text_cursor_moved_signal (buffer);
 }
 
 /*
@@ -1221,39 +1224,41 @@ gui_input_move_next_word (struct t_gui_buffer *buffer)
 {
     char *pos;
 
-    if (buffer->input
-        && (buffer->input_buffer_pos < buffer->input_buffer_length))
+    if (!buffer->input
+        || (buffer->input_buffer_pos >= buffer->input_buffer_length))
+    {
+        return;
+    }
+
+    pos = (char *)utf8_add_offset (buffer->input_buffer,
+                                   buffer->input_buffer_pos);
+    while (pos[0] && !string_is_word_char_input (pos))
+    {
+        pos = (char *)utf8_next_char (pos);
+    }
+    if (pos[0])
     {
-        pos = (char *)utf8_add_offset (buffer->input_buffer,
-                                       buffer->input_buffer_pos);
-        while (pos[0] && !string_is_word_char_input (pos))
+        while (pos[0] && string_is_word_char_input (pos))
         {
             pos = (char *)utf8_next_char (pos);
         }
         if (pos[0])
         {
-            while (pos[0] && string_is_word_char_input (pos))
-            {
-                pos = (char *)utf8_next_char (pos);
-            }
-            if (pos[0])
-            {
-                buffer->input_buffer_pos =
-                    utf8_pos (buffer->input_buffer,
-                              pos - buffer->input_buffer);
-            }
-            else
-                buffer->input_buffer_pos = buffer->input_buffer_length;
-        }
-        else
-        {
             buffer->input_buffer_pos =
                 utf8_pos (buffer->input_buffer,
-                          utf8_prev_char (buffer->input_buffer, pos) - buffer->input_buffer);
+                          pos - buffer->input_buffer);
         }
-
-        gui_input_text_cursor_moved_signal (buffer);
+        else
+            buffer->input_buffer_pos = buffer->input_buffer_length;
+    }
+    else
+    {
+        buffer->input_buffer_pos =
+            utf8_pos (buffer->input_buffer,
+                      utf8_prev_char (buffer->input_buffer, pos) - buffer->input_buffer);
     }
+
+    gui_input_text_cursor_moved_signal (buffer);
 }
 
 /*
@@ -1883,17 +1888,17 @@ gui_input_insert (struct t_gui_buffer *buffer, const char *args)
 {
     char *args2;
 
-    if (args)
-    {
-        gui_buffer_undo_snap (buffer);
-        args2 = string_convert_escaped_chars (args);
-        gui_input_insert_string (buffer, (args2) ? args2 : args, -1);
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    1, /* save undo */
-                                                    1); /* stop completion */
-        if (args2)
-            free (args2);
-    }
+    if (!args)
+        return;
+
+    gui_buffer_undo_snap (buffer);
+    args2 = string_convert_escaped_chars (args);
+    gui_input_insert_string (buffer, (args2) ? args2 : args, -1);
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                1, /* save undo */
+                                                1); /* stop completion */
+    if (args2)
+        free (args2);
 }
 
 /*
@@ -1903,14 +1908,14 @@ gui_input_insert (struct t_gui_buffer *buffer, const char *args)
 void
 gui_input_undo_use (struct t_gui_buffer *buffer, struct t_gui_input_undo *undo)
 {
-    if ((undo->data) && (strcmp (undo->data, buffer->input_buffer) != 0))
-    {
-        gui_input_replace_input (buffer, undo->data);
-        gui_input_set_pos (buffer, undo->pos);
-        gui_input_text_changed_modifier_and_signal (buffer,
-                                                    0, /* save undo */
-                                                    1); /* stop completion */
-    }
+    if ((!undo->data) || (strcmp (undo->data, buffer->input_buffer) == 0))
+        return;
+
+    gui_input_replace_input (buffer, undo->data);
+    gui_input_set_pos (buffer, undo->pos);
+    gui_input_text_changed_modifier_and_signal (buffer,
+                                                0, /* save undo */
+                                                1); /* stop completion */
 }
 
 /*
@@ -1920,27 +1925,27 @@ gui_input_undo_use (struct t_gui_buffer *buffer, struct t_gui_input_undo *undo)
 void
 gui_input_undo (struct t_gui_buffer *buffer)
 {
-    if (buffer->ptr_input_undo)
+    if (!buffer->ptr_input_undo)
+        return;
+
+    /*
+     * if we are doing undo and that undo pointer is to the end of list
+     * (for example first time undo is used), then save current input
+     * content in undo list
+     */
+    if ((buffer->ptr_input_undo == buffer->last_input_undo)
+        && (buffer->ptr_input_undo)->data
+        && (strcmp (buffer->input_buffer, (buffer->ptr_input_undo)->data) != 0))
     {
-        /*
-         * if we are doing undo and that undo pointer is to the end of list
-         * (for example first time undo is used), then save current input
-         * content in undo list
-         */
-        if ((buffer->ptr_input_undo == buffer->last_input_undo)
-            && (buffer->ptr_input_undo)->data
-            && (strcmp (buffer->input_buffer, (buffer->ptr_input_undo)->data) != 0))
-        {
-            gui_buffer_undo_snap_free (buffer);
-            gui_buffer_undo_add (buffer);
-        }
+        gui_buffer_undo_snap_free (buffer);
+        gui_buffer_undo_add (buffer);
+    }
 
-        if (buffer->ptr_input_undo
-            && (buffer->ptr_input_undo)->prev_undo)
-        {
-            buffer->ptr_input_undo = (buffer->ptr_input_undo)->prev_undo;
-            gui_input_undo_use (buffer, buffer->ptr_input_undo);
-        }
+    if (buffer->ptr_input_undo
+        && (buffer->ptr_input_undo)->prev_undo)
+    {
+        buffer->ptr_input_undo = (buffer->ptr_input_undo)->prev_undo;
+        gui_input_undo_use (buffer, buffer->ptr_input_undo);
     }
 }
 
@@ -1951,10 +1956,9 @@ gui_input_undo (struct t_gui_buffer *buffer)
 void
 gui_input_redo (struct t_gui_buffer *buffer)
 {
-    if (buffer->ptr_input_undo
-        && (buffer->ptr_input_undo)->next_undo)
-    {
-        buffer->ptr_input_undo = (buffer->ptr_input_undo)->next_undo;
-        gui_input_undo_use (buffer, buffer->ptr_input_undo);
-    }
+    if (!buffer->ptr_input_undo || !(buffer->ptr_input_undo)->next_undo)
+        return;
+
+    buffer->ptr_input_undo = (buffer->ptr_input_undo)->next_undo;
+    gui_input_undo_use (buffer, buffer->ptr_input_undo);
 }