/core/src/aos_shell.c - Diff - AMiRo-OS - Research for Cognitive Interaction

Revision 697dba3c core/src/aos_shell.c

     /******************************************************************************/
     /**
      * @brief   The character the input buffer is initialized with.
      */
     #define INBUF_INIT_CHAR                         '\x07'
     /**
      * @brief   Event mask to be set on OS related events.
      */
     #define AOS_SHELL_EVENTMASK_OS                  EVENT_MASK(0)
     #define EVENTMASK_OS                            EVENT_MASK(0)
     /**
      * @brief   Event mask to be set on a input event.
      */
     #define AOS_SHELL_EVENTMASK_INPUT               EVENT_MASK(1)
     #define EVENTMASK_INPUT                         EVENT_MASK(1)
     /**
      * @brief   String that defines the INSERT key as specified by VT100.
      */
     #define KEYSTRING_INSERT                        "\x1B\x5B\x32\x7E"
     /**
      * @brief   String that defines the DEL key as specified by VT100.
      */
     #define KEYSTRING_DELETE                        "\x1B\x5B\x33\x7E"
     /**
      * @brief   String that defines the HOME key as specified by VT100.
      */
     #define KEYSTRING_HOME                          "\x1B\x5B\x48"
     /**
      * @brief   String that defines the END key as specified by VT100.
      */
     #define KEYSTRING_END                           "\x1B\x5B\x46"
     /**
      * @brief   String that defines the PGUP key as specified by VT100.
      */
     #define KEYSTRING_PAGEUP                        "\x1B\x5B\x35\x7E"
     /**
      * @brief   String that defines the PGUP key as specified by VT100.
      */
     #define KEYSTRING_PAGEDOWN                      "\x1B\x5B\x36\x7E"
     /**
      * @brief   String that defines the 'arrow down' key as specified by VT100.
      */
     #define KEYSTRING_ARROWUP                       "\x1B\x5B\x41"
     /**
      * @brief   String that defines the 'arrow up' key as specified by VT100.
      */
     #define KEYSTRING_ARROWDOWN                     "\x1B\x5B\x42"
     /**
      * @brief   String that defines the 'arrow left' key as specified by VT100.
      */
     #define KEYSTRING_ARROWLEFT                     "\x1B\x5B\x44"
     /**
      * @brief   String that defines the 'arrow right' key as specified by VT100.
      */
     #define KEYSTRING_ARROWRIGHT                    "\x1B\x5B\x43"
     /**
      * @brief   String that defines the CRTL + 'arrow up' key combination as specified by VT100.
      */
     #define KEYSTRING_CTRL_ARROWUP                  "\x1B\x5B\x31\x3B\x35\x41"
     /**
      * @brief   String that defines the CRTL + 'arrow down' key combination as specified by VT100.
      */
     #define KEYSTRING_CTRL_ARROWDOWN                "\x1B\x5B\x31\x3B\x35\x42"
     /**
      * @brief   String that defines the CRTL + 'arrow left' key combination as specified by VT100.
      */
     #define KEYSTRING_CTRL_ARROWLEFT                "\x1B\x5B\x31\x3B\x35\x44"
     /**
      * @brief   String that defines the CRTL + 'arrow right' key combination as specified by VT100.
      */
     #define KEYSTRING_CTRL_ARROWRIGHT               "\x1B\x5B\x31\x3B\x35\x43"
     /******************************************************************************/
     /* EXPORTED VARIABLES                                                         */
-...
       KEY_UNKNOWN,          /**< any/unknow key */
       KEY_AMBIGUOUS,        /**< key is ambiguous */
       KEY_TAB,              /**< tabulator key */
       KEY_ESCAPE,           /**< escape key */
       KEY_BACKSPACE,        /**< backspace key */
       KEY_INSERT,           /**< insert key */
       KEY_DELETE,           /**< delete key */
       KEY_ESCAPE,           /**< escape key */
       KEY_HOME,             /**< home key */
       KEY_END,              /**< end key */
       KEY_PAGE_UP,          /**< page up key */
       KEY_PAGE_DOWN,        /**< page down key */
       KEY_ARROW_UP,         /**< arrow up key */
       KEY_ARROW_DOWN,       /**< arrow down key */
       KEY_ARROW_LEFT,       /**< arrow left key */
       KEY_ARROW_RIGHT,      /**< arrow right key */
       KEY_CTRL_ARROW_UP,    /**< CTRL + arrow up key */
       KEY_CTRL_ARROW_DOWN,  /**< CTRL + arrow down key */
       KEY_CTRL_ARROW_LEFT,  /**< CTRL + arrow left key */
       KEY_CTRL_ARROW_RIGHT, /**< CTRL + arrow right key */
       KEY_PAGEUP,           /**< page up key */
       KEY_PAGEDOWN,         /**< page down key */
       KEY_ARROWUP,          /**< arrow up key */
       KEY_ARROWDOWN,        /**< arrow down key */
       KEY_ARROWLEFT,        /**< arrow left key */
       KEY_ARROWRIGHT,       /**< arrow right key */
       KEY_CTRL_ARROWUP,     /**< CTRL + arrow up key */
       KEY_CTRL_ARROWDOWN,   /**< CTRL + arrow down key */
       KEY_CTRL_ARROWLEFT,   /**< CTRL + arrow left key */
       KEY_CTRL_ARROWRIGHT,  /**< CTRL + arrow right key */
       KEY_CTRL_C,           /**< CTRL + C key */
     } special_key_t;
     /**
-...
       CHAR_MATCH_CASE   = 2,  /**< Characters do match with case. */
     } charmatch_t;
     /**
      * @brief   Enumerator to encode shell actions.
      */
     typedef enum aos_shellaction {
       ACTION_NONE,                  /**< No action at all. */
       ACTION_READCHAR,              /**< Read a printable character. */
       ACTION_AUTOCOMPLETE,          /**< Automatically comlete input by using available command. */
       ACTION_SUGGEST,               /**< Suggest matching available commands. */
       ACTION_EXECUTE,               /**< Execute input. */
       ACTION_DELETEBACKWARD,        /**< Delete a single character backwards. */
       ACTION_DELETEFORWARD,         /**< Delete a single character forwards. */
       ACTION_CLEAR,                 /**< Clear the input. */
       ACTION_RECALLPREVIOUS,        /**< Recall the previous (older) entry in the history. */
       ACTION_RECALLNEXT,            /**< Recall the next (more recent) entry in the history. */
       ACTION_RECALLOLDEST,          /**< Recall the oldest entry in the history. */
       ACTION_RECALLCURRENT,         /**< Recall the current input. */
       ACTION_CURSORLEFT,            /**< Move cursor one character to the left. */
       ACTION_CURSORRIGHT,           /**< Move cursor one character to the right. */
       ACTION_CURSORWORDLEFT,        /**< Move cursor one word to the left. */
       ACTION_CURSORWORDRIGHT,       /**< Move cursor one word to the right. */
       ACTION_CURSOR2END,            /**< Move cursor to the very right. */
       ACTION_CURSOR2START,          /**< Move cursor to the very left. */
       ACTION_RESET,                 /**< Reset the current input. */
       ACTION_INSERTTOGGLE,          /**< Toggle insertion mode. */
       ACTION_ESCSTART,              /**< Start an escape sequence (special keys). */
       ACTION_PRINTUNKNOWNSEQUENCE,  /**< Print an unknown escape sequence. */
     } action_t;
     /**
      * @brief   Struct that holds most important runtime data for the shell.
      * @details The structure is to be used by the shell thread main function as some kind of structured stack, which can be easily passed to other functions.
      */
     typedef struct runtimedata {
       /**
        * @brief   Data related to the current input.
        */
       struct {
         /**
          * @brief   Length of the input.
          */
         size_t length;
         /**
          * @brief   Current position of the cursor in the input line.
          */
         size_t cursorpos;
         /**
          * @brief   Buffer to store escape sequences, which describe special characters.
          */
         char escseq[AOS_SHELL_ESCSEQUENCE_LENGTH];
       } input;
       /**
        * @brief   Data related to the entry or history buffer.
        */
       struct {
         /**
          * @brief   Current entry to be filled and executed.
          */
         size_t current;
         /**
          * @brief   Selected entry in the 'history' as preview.
          * @details A value of 0 indicates, that the line is cleared as a preview.
          *          A value of 1 indicates, that the current entry is selected.
          *          A value of t>1 indicates, that the entry t-1 in the past is selected.
          *          The value must never be greater than the number of entries available, of course.
          */
         size_t selected;
         /**
          * @brief   Selected entry in the 'history' that has been edited by the user.
          *          A value of 0 indicates, that there was no modification by the user yet (i.e. charcters, deletions or autofill).
          *          A value of 1 indicates, that the current entry was edited.
          *          A value of t>1 indicated, that a history entry was recalled and then edited.
          */
         size_t edited;
       } buffer;
       /**
        * @brief   The last action executed by the shell.
        */
       action_t lastaction;
     } runtimedata_t;
     /******************************************************************************/
     /* LOCAL VARIABLES                                                            */
     /******************************************************************************/
-...
       return MSG_OK;
+    }
     /**
      * @brief   Implementation of the BaseSequentialStream write() method.
      */
     static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n)
+    {
       aosDbgCheck(instance != NULL);
-...
       return maxbytes;
+    }
     /**
      * @brief   Implementation of the BaseSequentialStream read() method.
      */
     static size_t _stremread(void *instance, uint8_t *bp, size_t n)
+    {
       (void)instance;
-...
       return 0;
+    }
     /**
      * @brief   Implementation of the BaseSequentialStream put() method.
      */
     static msg_t _streamput(void *instance, uint8_t b)
+    {
       aosDbgCheck(instance != NULL);
-...
       return ret;
+    }
     /**
      * @brief   Implementation of the BaseSequentialStream get() method.
      */
     static msg_t _streamget(void *instance)
+    {
       (void)instance;
-...
+    }
     /**
      * @brief   Retreive a pointer to the string buffer of a specified entry in the input buffer.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] entry   Entry to be retrieved.
+     *
      * @return  Pointer to the entry in the input buffer.
      */
     static inline char* _getAbsoluteEntry(const aos_shell_t* shell, size_t entry)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(entry < shell->input.nentries);
       return &(shell->input.buffer[entry * shell->input.linewidth * sizeof(char)]);
+    }
     /**
      * @brief   Calculate absolute entry from history offset.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] rdata   Pointer to a runtime data object.
      * @param[in] offset  Relative offset of the entry to be retreived.
+     *
      * @return  Absolute index of the historic entry.
      */
     static inline size_t _historyOffset2EntryIndex(const aos_shell_t* shell, const runtimedata_t* rdata, size_t offset)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       aosDbgCheck(offset < shell->input.nentries);
       return ((shell->input.nentries + rdata->buffer.current - offset) % shell->input.nentries);
+    }
     /**
      * @brief   Retreive a pointer to the string buffer of a historic entry in the input buffer.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] rdata   Pointer to a runtime data object.
      * @param[in] offset  Relative offset of the entry to be retreived.
+     *
      * @return  Pointer to the entry in the input buffer.
      */
     static inline char* _getRelativeEntry(const aos_shell_t* shell, const runtimedata_t* rdata, size_t offset)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       aosDbgCheck(offset < shell->input.nentries);
       return _getAbsoluteEntry(shell, _historyOffset2EntryIndex(shell, rdata, offset));
+    }
     /**
      * @brief   Retreive a pointer to the current entry string in the input buffer.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] rdata   Pointer to a runtime data object.
+     *
      * @return  Pointer to the string of the current entry in the input buffer.
      */
     static inline char* _getCurrentEntry(const aos_shell_t* shell, const runtimedata_t* rdata)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       return _getAbsoluteEntry(shell, rdata->buffer.current);
+    }
     /**
      * @brief   Retreive a pointer to the currently selected entry.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] rdata   Pointer to a runtime data object.
+     *
      * @return  Pointer to the currently selected entry or NULL if no entry is selected (cleared preview).
      */
     static inline char* _getSelectedEntry(const aos_shell_t* shell, const runtimedata_t* rdata)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       if (rdata->buffer.selected > 0) {
         return _getRelativeEntry(shell, rdata, rdata->buffer.selected - 1);
       } else {
         return NULL;
+      }
+    }
     /**
      * @brief   Retreive the currently visualized entry.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] rdata   Pointer to a runtime data object.
+     *
      * @return  Pointer to the currently visualized entry or NULL if the input has been cleared (cleared preview).
      */
     static inline char* _getVisualisedEntry(const aos_shell_t* shell, const runtimedata_t* rdata)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       if (rdata->buffer.selected == 0) {
         // cleared preview, nothing visualized
         return NULL;
       } else {
         if (rdata->buffer.selected == 1 || rdata->buffer.selected == rdata->buffer.edited) {
           // the current or a modified entry is selected
           return _getCurrentEntry(shell, rdata);
         } else {
           // a historic, unmodified entry is selected
           return _getRelativeEntry(shell, rdata, rdata->buffer.selected - 1);
+        }
+      }
+    }
     /**
      * @brief   Print the shell prompt
      * @details Depending on the configuration flags, the system uptime is printed before the prompt string.
+     *
-...
     static special_key_t _interpreteEscapeSequence(const char seq[])
+    {
       // local variables
       char str[AOS_SHELL_ESCSEQUENCE_LENGTH];
       unsigned long strl = 0;
       const unsigned long seql = strlen(seq);
       bool ambiguous = false;
       // TAB
       /* not supported yet; use "\x09" instead */
       /* not supported yet; use '\x09' instead */
       // BACKSPACE
       /* not supported yet; use "\x08" instead */
       /* not supported yet; use '\x08' instead */
       // ESCAPE
       strncpy(str, "\x1B", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_ESCAPE;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
+      }
       /* not supported yes; use '\x1B' instead */
       // CTRL + C
       /* not defined yet; use '\x03' instead */
       // INSERT
       strncpy(str, "\x1B\x5B\x32\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_INSERT;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_INSERT, seql) == 0) {
         strl = strlen(KEYSTRING_INSERT);
         if (seql == strl) {
           return KEY_INSERT;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // DELETE
       strncpy(str, "\x1B\x5B\x33\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_DELETE;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_DELETE, seql) == 0) {
         strl = strlen(KEYSTRING_DELETE);
         if (seql == strl) {
           return KEY_DELETE;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // HOME
       strncpy(str, "\x1B\x5B\x48", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_HOME;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_HOME, seql) == 0) {
         strl = strlen(KEYSTRING_HOME);
         if (seql == strl) {
           return KEY_HOME;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // END
       strncpy(str, "\x1B\x5B\x46", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_END;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_END, seql) == 0) {
         strl = strlen(KEYSTRING_END);
         if (seql == strl) {
           return KEY_END;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // PAGE UP
       strncpy(str, "\x1B\x5B\x35\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_PAGE_UP;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_PAGEUP, seql) == 0) {
         strl = strlen(KEYSTRING_PAGEUP);
         if (seql == strl) {
           return KEY_PAGEUP;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // PAGE DOWN
       strncpy(str, "\x1B\x5B\x36\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_PAGE_DOWN;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_PAGEDOWN, seql) == 0) {
         strl = strlen(KEYSTRING_PAGEDOWN);
         if (seql == strl) {
           return KEY_PAGEDOWN;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // ARROW UP
       strncpy(str, "\x1B\x5B\x41", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_ARROW_UP;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_ARROWUP, seql) == 0) {
         strl = strlen(KEYSTRING_ARROWUP);
         if (seql == strl) {
           return KEY_ARROWUP;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // ARROW DOWN
       strncpy(str, "\x1B\x5B\x42", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_ARROW_DOWN;
       } else if (seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_ARROWDOWN, seql) == 0) {
         strl = strlen(KEYSTRING_ARROWDOWN);
         if (seql == strl) {
           return KEY_ARROWDOWN;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // ARROW LEFT
       strncpy(str, "\x1B\x5B\x44", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_ARROW_LEFT;
       } else if (seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_ARROWLEFT, seql) == 0) {
         strl = strlen(KEYSTRING_ARROWLEFT);
         if (seql == strl) {
           return KEY_ARROWLEFT;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // ARROW RIGHT
       strncpy(str, "\x1B\x5B\x43", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_ARROW_RIGHT;
       } else if (seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_ARROWRIGHT, seql) == 0) {
         strl = strlen(KEYSTRING_ARROWRIGHT);
         if (seql == strl) {
           return KEY_ARROWRIGHT;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // CTRL + ARROW UP
       strncpy(str, "\x1B\x5B\x31\x3B\x35\x41", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_CTRL_ARROW_UP;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_CTRL_ARROWUP, seql) == 0) {
         strl = strlen(KEYSTRING_CTRL_ARROWUP);
         if (seql == strl) {
           return KEY_CTRL_ARROWUP;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // CTRL + ARROW DOWN
       strncpy(str, "\x1B\x5B\x31\x3B\x35\x42", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_CTRL_ARROW_DOWN;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_CTRL_ARROWDOWN, seql) == 0) {
         strl = strlen(KEYSTRING_CTRL_ARROWDOWN);
         if (seql == strl) {
           return KEY_CTRL_ARROWDOWN;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // CTRL + ARROW LEFT
       strncpy(str, "\x1B\x5B\x31\x3B\x35\x44", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_CTRL_ARROW_LEFT;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_CTRL_ARROWLEFT, seql) == 0) {
         strl = strlen(KEYSTRING_CTRL_ARROWLEFT);
         if (seql == strl) {
           return KEY_CTRL_ARROWLEFT;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       // CTRL + ARROW RIGHT
       strncpy(str, "\x1B\x5B\x31\x3B\x35\x43", AOS_SHELL_ESCSEQUENCE_LENGTH);
       strl = strlen(str);
       if (seql == strl && strncmp(seq, str, seql) == 0) {
         return KEY_CTRL_ARROW_RIGHT;
       } else if(seql < strl && strncmp(seq, str, seql) == 0) {
         ambiguous = true;
       if (strncmp(seq, KEYSTRING_CTRL_ARROWRIGHT, seql) == 0) {
         strl = strlen(KEYSTRING_CTRL_ARROWRIGHT);
         if (seql == strl) {
           return KEY_CTRL_ARROWRIGHT;
         } else if (seql < strl) {
           ambiguous = true;
+        }
+      }
       return ambiguous ? KEY_AMBIGUOUS : KEY_UNKNOWN;
+    }
     /**
      * @brief   Move the cursor in the terminal
      * @brief   Move the cursor in the terminal.
+     *
      * @param[in] shell   Pointer to the shell object.
      * @param[in] line    Pointer to the current content of the line.
      * @param[in] from    Starting position of the cursor.
      * @param[in] to      Target position to move the cursor to.
+     *
      * @return            The number of positions moved.
      */
     static int _moveCursor(aos_shell_t* shell, const size_t from, const size_t to)
     static int _moveCursor(aos_shell_t* shell, const char* line, size_t from, size_t to)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(line !=  NULL || from >= to);
       aosDbgCheck(from <= shell->input.linewidth);
       aosDbgCheck(to <= shell->input.linewidth);
       // local variables
       size_t pos = from;
-...
       // move cursor right by printing line content
       while (pos < to) {
         streamPut(&shell->stream, (uint8_t)shell->input.line[pos]);
         streamPut(&shell->stream, (uint8_t)line[pos]);
         ++pos;
+      }
-...
+    }
     /**
      * @brief   Print content of the shell line
      * @brief   Print content of a given string to the shell output stream.
+     *
      * @param[in] shell   Pointer to the shell object.
      * @param[in] line    Pointer to the line to be printed.
      * @param[in] from    First position to start printing from.
      * @param[in] to      Position after the last character to print.
+     *
      * @return            Number of characters printed.
      */
     static inline size_t _printLine(aos_shell_t* shell, const size_t from, const size_t to)
     static size_t _printString(aos_shell_t* shell, const char* line, size_t from, size_t to)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(line != NULL || from >= to);
       aosDbgCheck(from < shell->input.linewidth);
       aosDbgCheck(to <= shell->input.linewidth);
       // local variables
       size_t cnt;
       for (cnt = 0; from + cnt < to; ++cnt) {
         streamPut(&shell->stream, (uint8_t)shell->input.line[from + cnt]);
         streamPut(&shell->stream, (uint8_t)line[from + cnt]);
+      }
       return cnt;
+    }
     static int _readChar(aos_shell_t* shell, const char c) {
     /**
      * @brief   Print a single character to the input buffer and to the output stream.
+     *
      * @param[in] shell   Pointer to the shell object.
      * @param[in] rdata   Pointer to the runtim data object.
      * @param[in] c       Character to print.
+     *
      * @return  Number of successfully handled characters.
      *          The return value can be interpreted as boolean (1 = sucess; 0 = error).
      */
     static int _printChar(aos_shell_t* shell, runtimedata_t* rdata, char c)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       // check whether input line is already full
       if (shell->inputdata.lineend + 1 >= shell->input.size) {
       if (rdata->input.length + 1 >= shell->input.linewidth) {
         return 0;
       } else {
         // clear old line content on first input
         if (shell->inputdata.noinput) {
           memset(shell->input.line, '\0', shell->input.size);
           shell->inputdata.noinput = false;
+        }
         // overwrite content
         if (shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE) {
           shell->input.line[shell->inputdata.cursorpos] = c;
           ++shell->inputdata.cursorpos;
           shell->inputdata.lineend = (shell->inputdata.cursorpos > shell->inputdata.lineend) ? shell->inputdata.cursorpos : shell->inputdata.lineend;
           streamPut(&shell->stream, (uint8_t)c);
+        }
         // insert character
         else {
           memmove(&(shell->input.line[shell->inputdata.cursorpos+1]), &(shell->input.line[shell->inputdata.cursorpos]), shell->inputdata.lineend - shell->inputdata.cursorpos);
           shell->input.line[shell->inputdata.cursorpos] = c;
           ++shell->inputdata.lineend;
           _printLine(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
           ++shell->inputdata.cursorpos;
           _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
+        }
+      }
       // retreive entry in the input buffer
       char* line = _getCurrentEntry(shell, rdata);
       // overwrite content
       if (shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE) {
         line[rdata->input.cursorpos] = c;
         ++rdata->input.cursorpos;
         rdata->input.length = (rdata->input.cursorpos > rdata->input.length) ? rdata->input.cursorpos : rdata->input.length;
         streamPut(&shell->stream, (uint8_t)c);
         return 1;
+      }
       // insert character
       else {
         memmove(&line[rdata->input.cursorpos + 1], &line[rdata->input.cursorpos], rdata->input.length - rdata->input.cursorpos);
         line[rdata->input.cursorpos] = c;
         ++rdata->input.length;
         _printString(shell, line, rdata->input.cursorpos, rdata->input.length);
         ++rdata->input.cursorpos;
         _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
         return 1;
+      }
+    }
     /**
      * @brief   Overwrite the current output with a given line.
      * @details If the current output is longer than the string, the additional characters are cleared.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] rdata   Pointer to a runtime data object.
      * @param[in] line    The line to be printed.
      */
     static void _overwriteOutput(aos_shell_t* shell, runtimedata_t* rdata, const char* line)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       aosDbgCheck(line != NULL);
       // local variables
       const size_t oldlength = rdata->input.length;
       // print line (overwrite current output)
       _moveCursor(shell, line, rdata->input.cursorpos, 0);
       rdata->input.length = strlen(line);
       _printString(shell, line, 0, rdata->input.length);
       // clear any remaining symbols
       if (oldlength > rdata->input.length) {
         for (rdata->input.cursorpos = rdata->input.length; rdata->input.cursorpos < oldlength; ++rdata->input.cursorpos) {
           streamPut(&shell->stream, ' ');
+        }
         _moveCursor(shell, line, oldlength, rdata->input.length);
+      }
       rdata->input.cursorpos = rdata->input.length;
       return;
+    }
     /**
      * @brief   Compare two characters.
+     *
      * @param[in] lhs       First character to compare.
-...
+     *
      * @return    The customly encoded character.
      */
     static inline char _mapAscii2Custom(const char c)
     static inline char _mapAscii2Custom(char c)
+    {
       if (c >= 'A' && c <= 'Z') {
         return ((c - 'A') * 2) + 'A' + 1;
-...
+    }
     /**
      * @brief   Alters all intermediate NUL bytes in a string to spaces.
+     *
      * @param[in] string  The string to be handled.
      * @param[in] length  Length of the string.
+     *
      * @return  Detected Length of the actual content of the string.
      */
     static size_t _restoreWhitespace(char* string, size_t length)
+    {
       aosDbgCheck(string != NULL || length == 0);
       // local variables
       size_t c = length;
       // seach for first non-NUL byte from the back
       while (c > 0) {
         --c;
         if (string[c] != '\0') {
           // store the detected length of the content
           length = ++c;
           break;
+        }
+      }
       // iterate further and replace all encountered NUL bytes by spaces
       while (c > 0) {
         --c;
         if (string[c] == '\0') {
           string[c] = ' ';
+        }
+      }
       return length;
+    }
     /**
      * @brief   Performs required actions before an imminent modiifcation (character input, deletion or autofill).
      * @details This functions checks the current status and clears or copies entries in the input buffer as required.
      *          Status information (runtime data) is altered accordingly as well.
+     *
      * @param[in] shell   Pointer to a shell object.
      * @param[in] rdata   Pointer to a runtime data object.
+     *
      * @return    Pointer to the current entry in the input buffer.
      */
     static char* _prepare4Modification(aos_shell_t* shell, runtimedata_t* rdata)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       char* line = _getCurrentEntry(shell, rdata);
       // cleared preview
       if (rdata->buffer.selected == 0) {
         // reset the current entry if required
         if (rdata->buffer.edited != 0) {
           memset(line, '\0', shell->input.linewidth * sizeof(char));
+        }
         // set the current entry as the selected one and mark it as edited
         rdata->buffer.selected = 1;
         rdata->buffer.edited = 1;
+      }
       // current entry
       else if (rdata->buffer.selected == 1) {
         // mark current entry as edited
         rdata->buffer.edited = 1;
+      }
       // preview of historic entry
       else if (rdata->buffer.selected > 1) {
         // copy the selected entry before modification if required
         if (rdata->buffer.selected!= rdata->buffer.edited) {
           memcpy(line, _getSelectedEntry(shell, rdata), shell->input.linewidth * sizeof(char));
+        }
         // mark the selected entry as edited
         rdata->buffer.edited = rdata->buffer.selected;
+      }
       return line;
+    }
     /**
      * @brief   Read input from a channel as long as there is data available.
+     *
      * @param[in]   shell     Pointer to the shell object.
      * @param[in]   channel   The channel to read from.
      * @param[out]  exec      Optional pointer to a flag, which indicates, whether a command shall be executed.
      * @param[in]     shell     Pointer to the shell object.
      * @param[in,out] rdata     Pointer to a runtime data object.
      * @param[in]     channel   The channel to read from.
+     *
      * @return  Number of read characters.
      * @return  Number of characters read.
      */
     static int _readChannel(aos_shell_t* shell, AosShellChannel* channel, bool* execute)
     static size_t _readChannel(aos_shell_t* shell, runtimedata_t* rdata, AosShellChannel* channel)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(rdata != NULL);
       aosDbgCheck(channel != NULL);
       // local variables
       aos_shellaction_t action = AOS_SHELL_ACTION_NONE;
       size_t bytes = 0;
       char c;
       special_key_t key;
       int nchars = 0;
       bool exec = false;
       action_t action;
       // read character by character from the channel
       while (chnReadTimeout(channel, (uint8_t*)&c, 1, TIME_IMMEDIATE)) {
         key = KEY_UNKNOWN;
         // increment byte counter
         ++bytes;
         // drop any input after an execution request was detected
         if (exec) {
         // drop any further input after an execution request was detected
         if (rdata->lastaction == ACTION_EXECUTE && bytes > 1) {
           continue;
+        }
         // incremet character counter
         ++nchars;
         // parse escape sequence
         if (strlen(shell->inputdata.escseq) > 0) {
           shell->inputdata.escseq[strlen(shell->inputdata.escseq)] = c;
           key = _interpreteEscapeSequence(shell->inputdata.escseq);
           switch (key) {
             case KEY_AMBIGUOUS:
               // read next byte to resolve ambiguity
               continue;
             case KEY_UNKNOWN:
               // do nothing here, but handle the unknown sequence below
               break;
             default:
               // reset the sequence variable and buffer
               memset(shell->inputdata.escseq, '\0', sizeof(shell->inputdata.escseq)*sizeof(shell->inputdata.escseq[0]));
               break;
         // try to interprete escape sequence
+        {
           // set default
           key = KEY_UNKNOWN;
           // only interprete, if there is an escape sequence at all
           const size_t escl = strlen(rdata->input.escseq);
           if (escl > 0) {
             // append and 'consume' character
             rdata->input.escseq[escl] = c;
             c = '\0';
             // try to interprete sequence
             key = _interpreteEscapeSequence(rdata->input.escseq);
             switch (key) {
               // ambiguous key due to incomplete sequence
               case KEY_AMBIGUOUS:
                 // read next byte to resolve ambiguity
                 continue;
               // an unknown sequence has been encountered
               case KEY_UNKNOWN:
                 // increment number of inputs but handle this unknown sequence below
                 break;
               // a key was identified successfully
               default:
                 // reset the sequence buffer
                 memset(rdata->input.escseq, '\0', AOS_SHELL_ESCSEQUENCE_LENGTH * sizeof(char));
                 break;
+            }
+          }
+        }
         /* interprete keys or character */
+        {
           // default
           action = AOS_SHELL_ACTION_NONE;
         /*
          * Derive action to be executed from keypress.
          * This step handles all sanity checks, so any required prerequisites for the selected action are fulfilled.
          */
         // set default
         action = ACTION_NONE;
         // if there is no escape sequence pending
         if (rdata->input.escseq[0] == '\0') {
           // printable character
           if (key == KEY_UNKNOWN && strlen(shell->inputdata.escseq) == 0 && c >= '\x20' && c <= '\x7E') {
             action = AOS_SHELL_ACTION_READCHAR;
           if (c >= '\x20' && c <= '\x7E') {
             action = ACTION_READCHAR;
+          }
           // tab key or character
           else if (key == KEY_TAB || c == '\x09') {
           else if (c == '\x09' || key == KEY_TAB) {
             /*
              * pressing tab once applies auto fill
              * pressing tab a second time prints suggestions
              * pressing tab a second time (or more) prints suggestions
              */
             if (shell->inputdata.lastaction == AOS_SHELL_ACTION_AUTOFILL || shell->inputdata.lastaction == AOS_SHELL_ACTION_SUGGEST) {
               action = AOS_SHELL_ACTION_SUGGEST;
             if (rdata->lastaction == ACTION_AUTOCOMPLETE || rdata->lastaction == ACTION_SUGGEST) {
               action = ACTION_SUGGEST;
             } else {
               action = AOS_SHELL_ACTION_AUTOFILL;
               action = ACTION_AUTOCOMPLETE;
+            }
+          }
           // INS key
           else if (key == KEY_INSERT) {
             action = AOS_SHELL_ACTION_INSERTTOGGLE;
+          }
           // DEL key or character
           else if (key == KEY_DELETE || c == '\x7F') {
             // ignore if cursor is at very right
             if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
               action = AOS_SHELL_ACTION_DELETEFORWARD;
+            }
           // carriage return ('\r') or line feed ('\n') character
           else if (c == '\x0D' || c == '\x0A') {
             action = ACTION_EXECUTE;
+          }
           // backspace key or character
           else if (key == KEY_BACKSPACE || c == '\x08') {
           else if (c == '\x08' || key == KEY_BACKSPACE) {
             // ignore if cursor is at very left
             if (shell->inputdata.cursorpos > 0) {
               action = AOS_SHELL_ACTION_DELETEBACKWARD;
             if (rdata->input.cursorpos > 0) {
               action = ACTION_DELETEBACKWARD;
+            }
+          }
           // 'page up', 'arrow up', or key or CTRL + 'arrow up' key combination
           else if (key == KEY_PAGE_UP || key == KEY_ARROW_UP || key == KEY_CTRL_ARROW_UP) {
             // ignore if there was some input
             if (shell->inputdata.noinput) {
               action = AOS_SHELL_ACTION_RECALLLAST;
           // DEL key or character
           else if (c == '\x7F' || key == KEY_DELETE) {
             // ignore if cursor is at very right
             if (rdata->input.cursorpos < rdata->input.length) {
               action = ACTION_DELETEFORWARD;
+            }
+          }
           // 'page down' key, 'arrow down' key, 'end of test' character or 'end of transmission' character, or CTRL + 'arrow down' key combination
           else if (key == KEY_PAGE_DOWN || key == KEY_ARROW_DOWN || c == '\x03' || c == '\x03' || key == KEY_CTRL_ARROW_DOWN) {
             // ignore if line is empty
             if (shell->inputdata.lineend > 0) {
               action = AOS_SHELL_ACTION_CLEAR;
           // 'arrow up' key
           else if (key == KEY_ARROWUP) {
             // recall previous input from history only if
             // not the oldest entry is already selected and
             // the previous entry has been set.
             if (rdata->buffer.selected < shell->input.nentries &&
                 (_getRelativeEntry(shell, rdata, rdata->buffer.selected))[0] != INBUF_INIT_CHAR) {
               action = ACTION_RECALLPREVIOUS;
+            }
+          }
           // 'home' key
           else if (key == KEY_HOME) {
             // ignore if cursor is very left
             if (shell->inputdata.cursorpos > 0) {
               action = AOS_SHELL_ACTION_CURSOR2START;
           // 'arrow down' key
           else if (key == KEY_ARROWDOWN) {
             // clear the line if
             // no historic entry is selected or
             // the most recent entry is selected, but the current one is occupied by a moodfied version of a historic entry
             if ((rdata->buffer.selected == 1) ||
                 (rdata->buffer.selected == 2 && rdata->buffer.edited > 1)) {
               action = ACTION_CLEAR;
+            }
+          }
           // 'end' key
           else if (key == KEY_END) {
             // ignore if cursos is very right
             if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
               action = AOS_SHELL_ACTION_CURSOR2END;
             // if a historic entry is selected, recall the next input from history
             else if (rdata->buffer.selected > 1) {
               action = ACTION_RECALLNEXT;
+            }
+          }
           // 'arrow left' key
           else if (key == KEY_ARROW_LEFT) {
           else if (key == KEY_ARROWLEFT) {
             // ignore if cursor is very left
             if (shell->inputdata.cursorpos > 0) {
               action = AOS_SHELL_ACTION_CURSORLEFT;
             if (rdata->input.cursorpos > 0) {
               action = ACTION_CURSORLEFT;
+            }
+          }
           // 'arrow right' key
           else if (key == KEY_ARROW_RIGHT) {
           else if (key == KEY_ARROWRIGHT) {
             // ignore if cursor is very right
             if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
               action = AOS_SHELL_ACTION_CURSORRIGHT;
             if (rdata->input.cursorpos < rdata->input.length) {
               action = ACTION_CURSORRIGHT;
+            }
+          }
           // CTRL + 'arrow up' key combination or 'page up' key
           else if (key == KEY_CTRL_ARROWUP || key == KEY_PAGEUP) {
             // recall oldest input from history only if
             // not the oldest entry is already selected and
             // there is at least one history entry set
             if (rdata->buffer.selected < shell->input.nentries &&
                 (_getRelativeEntry(shell, rdata, (rdata->buffer.selected > 0) ? 1 : 0))[0] != INBUF_INIT_CHAR) {
               action = ACTION_RECALLOLDEST;
+            }
+          }
           // CTRL + 'arrow down' key combination or 'page down' key
           else if (key == KEY_CTRL_ARROWDOWN || key == KEY_PAGEDOWN) {
             // clear the line if
             // no historic entry is selected or
             // the most recent entry is selected, but the current one is occupied by a moodfied version of a historic entry
             if ((rdata->buffer.selected == 1) ||
                 (rdata->buffer.selected > 1 && rdata->buffer.edited > 1)) {
               action = ACTION_CLEAR;
+            }
             // if a historic entry is selected, reset to the current input
             else if (rdata->buffer.selected > 1) {
               action = ACTION_RECALLCURRENT;
+            }
+          }
           // CTRL + 'arrow left' key combination
           else if (key == KEY_CTRL_ARROW_LEFT) {
           else if (key == KEY_CTRL_ARROWLEFT) {
             // ignore if cursor is very left
             if (shell->inputdata.cursorpos > 0) {
               action = AOS_SHELL_ACTION_CURSORWORDLEFT;
             if (rdata->input.cursorpos > 0) {
               action = ACTION_CURSORWORDLEFT;
+            }
+          }
           // CTRL + 'arrow right' key combination
           else if (key == KEY_CTRL_ARROW_RIGHT) {
           else if (key == KEY_CTRL_ARROWRIGHT) {
             // ignore if cursor is very right
             if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
               action = AOS_SHELL_ACTION_CURSORWORDRIGHT;
             if (rdata->input.cursorpos < rdata->input.length) {
               action = ACTION_CURSORWORDRIGHT;
+            }
+          }
           // carriage return ('\r') or line feed ('\n') character
           else if (c == '\x0D' || c == '\x0A') {
             action = AOS_SHELL_ACTION_EXECUTE;
           // 'end' key
           else if (key == KEY_END) {
             // ignore if cursos is very right
             if (rdata->input.cursorpos < rdata->input.length) {
               action = ACTION_CURSOR2END;
+            }
+          }
           // ESC key or [ESCAPE] character
           else if (key == KEY_ESCAPE || c == '\x1B') {
             action = AOS_SHELL_ACTION_ESCSTART;
           // 'home' key
           else if (key == KEY_HOME) {
             // ignore if cursor is very left
             if (rdata->input.cursorpos > 0) {
               action = ACTION_CURSOR2START;
+            }
+          }
           // unknown escape sequence
           else if (key == KEY_UNKNOWN && strlen(shell->inputdata.escseq) > 0) {
             action = AOS_SHELL_ACTION_PRINTUNKNOWNSEQUENCE;
           // CTRL + C key combination
           else if (c == '\x03' || key == KEY_CTRL_C) {
             action = ACTION_RESET;
+          }
           // INS key
           else if (key == KEY_INSERT) {
             action = ACTION_INSERTTOGGLE;
+          }
           // ESC key or [ESCAPE] character
           else if (c == '\x1B' || key == KEY_ESCAPE) {
             action = ACTION_ESCSTART;
+          }
+        }
         // ongoing escape sequence or interpretation failed
         else /* if (rdata->input.escseq[0] != '\0') */ {
           // unknown escape sequence (interpretation failed)
           if (key == KEY_UNKNOWN) {
             action = ACTION_PRINTUNKNOWNSEQUENCE;
+          }
         } /* end of action selection */
         /* handle function */
         /*
          * execute action
          */
         switch (action) {
           case AOS_SHELL_ACTION_READCHAR:
           case ACTION_NONE:
+          {
             // do nothing (ignore input) and read next byte
             break;
+          }
           case ACTION_READCHAR:
+          {
             if (_readChar(shell, c) == 0) {
             char* line = _prepare4Modification(shell, rdata);
             if (_printChar(shell, rdata, c) == 0) {
               // line is full
               _moveCursor(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
               _moveCursor(shell, line, rdata->input.cursorpos, rdata->input.length);
               chprintf((BaseSequentialStream*)&shell->stream, "\n\tmaximum line width reached\n");
               _printPrompt(shell);
               _printLine(shell, 0, shell->inputdata.lineend);
               _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
               _printString(shell, line, 0, rdata->input.length);
               _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
+            }
             break;
+          }
           case AOS_SHELL_ACTION_AUTOFILL:
           case ACTION_AUTOCOMPLETE:
+          {
             const char* fill = shell->input.line;
             size_t cmatch = shell->inputdata.cursorpos;
             // local variables
             char* line = _getVisualisedEntry(shell, rdata);
             const char* fill = line;
             size_t cmatch = rdata->input.cursorpos;
             charmatch_t matchlevel = CHAR_MATCH_NOT;
             size_t n;
             // iterate through command list
             for (aos_shellcommand_t* cmd = shell->commands; cmd != NULL; cmd = cmd->next) {
               // compare current match with command
               n = cmatch;
               charmatch_t mlvl = CHAR_MATCH_NOT;
               _strccmp(fill, cmd->name, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, (n == 0) ? NULL : &n, &mlvl);
               const int cmp = (n < cmatch) ?
                                 ((int)n - (int)cmatch) :
                                 (cmd->name[n] != '\0') ?
                                   (int)strlen(cmd->name) - (int)n :
 ;
               // if an exact match was found
               if ((size_t)((int)cmatch + cmp) == shell->inputdata.cursorpos) {
                 cmatch = shell->inputdata.cursorpos;
                 fill = cmd->name;
                 // break the loop only if there are no case mismatches with the input
                 n = shell->inputdata.cursorpos;
                 _strccmp(fill, shell->input.line, false, &n, &mlvl);
                 if (mlvl == CHAR_MATCH_CASE) {
                   break;
+                }
+              }
               // if a not exact match was found
               else if ((size_t)((int)cmatch + cmp) > shell->inputdata.cursorpos) {
                 // if this is the first one
                 if (fill == shell->input.line) {
                   cmatch = (size_t)((int)cmatch + cmp);
             // only execute autofill if the line is valid
             if (line) {
               _prepare4Modification(shell, rdata);
               // iterate through command list
               for (aos_shellcommand_t* cmd = shell->commands; cmd != NULL; cmd = cmd->next) {
                 // compare current match with command
                 n = cmatch;
                 charmatch_t mlvl = CHAR_MATCH_NOT;
                 _strccmp(fill, cmd->name, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, (n == 0) ? NULL : &n, &mlvl);
                 const int cmp = (n < cmatch) ?
                       ((int)n - (int)cmatch) :
                       (cmd->name[n] != '\0') ?
                         (int)strlen(cmd->name) - (int)n :
 ;
                 // if an exact match was found
                 if ((size_t)((int)cmatch + cmp) == rdata->input.cursorpos) {
                   cmatch = rdata->input.cursorpos;
                   fill = cmd->name;
                   // break the loop only if there are no case mismatches with the input
                   n = rdata->input.cursorpos;
                   _strccmp(fill, line, false, &n, &mlvl);
                   if (mlvl == CHAR_MATCH_CASE) {
                     break;
+                  }
+                }
                 // if this is a worse one
                 else if ((cmp < 0) || (cmp == 0 && mlvl == CHAR_MATCH_CASE)) {
                   cmatch = (size_t)((int)cmatch + cmp);
                 // if a not exact match was found
                 else if ((size_t)((int)cmatch + cmp) > rdata->input.cursorpos) {
                   // if this is the first one
                   if (fill == line) {
                     cmatch = (size_t)((int)cmatch + cmp);
                     fill = cmd->name;
+                  }
                   // if this is a worse one
                   else if ((cmp < 0) || (cmp == 0 && mlvl == CHAR_MATCH_CASE)) {
                     cmatch = (size_t)((int)cmatch + cmp);
+                  }
+                }
                 // non matching commands are ignored
                 else {}
+              }
               // non matching commands are ignored
               else {}
+            }
             // evaluate if there are case mismatches
             n = cmatch;
             _strccmp(shell->input.line, fill, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, &n, &matchlevel);
             // print the auto fill if any
             if (cmatch > shell->inputdata.cursorpos || (cmatch == shell->inputdata.cursorpos && matchlevel == CHAR_MATCH_NCASE)) {
               shell->inputdata.noinput = false;
               // limit auto fill so it will not overflow the line width
               if (shell->inputdata.lineend + (cmatch - shell->inputdata.cursorpos) > shell->input.size) {
                 cmatch = shell->input.size - shell->inputdata.lineend + shell->inputdata.cursorpos;
+              }
               // move trailing memory further in the line
               memmove(&(shell->input.line[cmatch]), &(shell->input.line[shell->inputdata.cursorpos]), shell->inputdata.lineend - shell->inputdata.cursorpos);
               shell->inputdata.lineend += cmatch - shell->inputdata.cursorpos;
               // if there was no incorrect case when matching
               if (matchlevel == CHAR_MATCH_CASE) {
                 // insert fill command name to line
                 memcpy(&(shell->input.line[shell->inputdata.cursorpos]), &(fill[shell->inputdata.cursorpos]), cmatch - shell->inputdata.cursorpos);
                 // print the output
                 _printLine(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
               } else {
                 // overwrite line with fill command name
                 memcpy(shell->input.line, fill, cmatch);
                 // reprint the whole line
                 _moveCursor(shell, shell->inputdata.cursorpos, 0);
                 _printLine(shell, 0, shell->inputdata.lineend);
               // evaluate if there are case mismatches
               n = cmatch;
               _strccmp(line, fill, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, &n, &matchlevel);
               // print the auto fill if any
               if (cmatch > rdata->input.cursorpos || (cmatch == rdata->input.cursorpos && matchlevel == CHAR_MATCH_NCASE)) {
                 // limit auto fill so it will not overflow the line width
                 if (rdata->input.length + (cmatch - rdata->input.cursorpos) > shell->input.linewidth) {
                   cmatch = shell->input.linewidth - rdata->input.length + rdata->input.cursorpos;
+                }
                 // move trailing memory further in the line
                 memmove(&line[cmatch], &line[rdata->input.cursorpos], (rdata->input.length - rdata->input.cursorpos) * sizeof(char));
                 rdata->input.length += cmatch - rdata->input.cursorpos;
                 // if there was no incorrect case when matching
                 if (matchlevel == CHAR_MATCH_CASE) {
                   // insert fill command name to line
                   memcpy(&line[rdata->input.cursorpos], &fill[rdata->input.cursorpos], (cmatch - rdata->input.cursorpos) * sizeof(char));
                   // print the output
                   _printString(shell, line, rdata->input.cursorpos, rdata->input.length);
                 } else {
                   // overwrite line with fill command name
                   memcpy(line, fill, cmatch * sizeof(char));
                   // reprint the whole line
                   _moveCursor(shell, line, rdata->input.cursorpos, 0);
                   _printString(shell, line, 0, rdata->input.length);
+                }
                 // move cursor to the end of the matching sequence
                 rdata->input.cursorpos = cmatch;
                 _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
+              }
               // move cursor to the end of the matching sequence
               shell->inputdata.cursorpos = cmatch;
               _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
+            }
             break;
+          }
           case AOS_SHELL_ACTION_SUGGEST:
           case ACTION_SUGGEST:
+          {
             // local variables
             const char* line = _getVisualisedEntry(shell, rdata);
             unsigned int matches = 0;
             // iterate through command list
             for (aos_shellcommand_t* cmd = shell->commands; cmd != NULL; cmd = cmd->next) {
               // compare line content with command, excpet if cursorpos=0
               size_t i = shell->inputdata.cursorpos;
               if (shell->inputdata.cursorpos > 0) {
                 _strccmp(shell->input.line, cmd->name, true, &i, NULL);
               // compare line content with command, except if cursorpos is 0
               size_t i = rdata->input.cursorpos;
               if (rdata->input.cursorpos > 0) {
                 _strccmp(line, cmd->name, true, &i, NULL);
+              }
               const int cmp = (i < shell->inputdata.cursorpos) ?
                                 (int)(i - shell->inputdata.cursorpos) :
                                 (cmd->name[i] != '\0') ?
                                   (int)strlen(cmd->name) - (int)i :
 ;
               const int cmp = (i < rdata->input.cursorpos) ?
                     ((int)i - (int)rdata->input.cursorpos) :
                     (cmd->name[i] != '\0') ?
                       (int)strlen(cmd->name) - (int)i :
 ;
               // if a match was found
               if (cmp > 0) {
                 // if this is the first one
                 if (matches == 0) {
                   _moveCursor(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
                   _moveCursor(shell, line, rdata->input.cursorpos, rdata->input.length);
                   streamPut(&shell->stream, '\n');
+                }
                 // print the command
-...
             // reprint the prompt and line if any matches have been found
             if (matches > 0) {
               _printPrompt(shell);
               _printLine(shell, 0, shell->inputdata.lineend);
               _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
               shell->inputdata.noinput = false;
               _printString(shell, line, 0, rdata->input.length);
               _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
+            }
             break;
+          }
           case AOS_SHELL_ACTION_INSERTTOGGLE:
           case ACTION_EXECUTE:
+          {
             if (shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE) {
               shell->config &= ~AOS_SHELL_CONFIG_INPUT_OVERWRITE;
             } else {
               shell->config |= AOS_SHELL_CONFIG_INPUT_OVERWRITE;
             // if the input buffer can hold historic entries
             if (shell->input.nentries > 1) {
               _prepare4Modification(shell, rdata);
+            }
             break;
+          }
           case AOS_SHELL_ACTION_DELETEFORWARD:
           case ACTION_DELETEBACKWARD:
+          {
             --shell->inputdata.lineend;
             memmove(&(shell->input.line[shell->inputdata.cursorpos]), &(shell->input.line[shell->inputdata.cursorpos+1]), shell->inputdata.lineend - shell->inputdata.cursorpos);
             _printLine(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
             char* line = _prepare4Modification(shell, rdata);
             --rdata->input.cursorpos;
             memmove(&line[rdata->input.cursorpos], &line[rdata->input.cursorpos + 1], (rdata->input.length - rdata->input.cursorpos) * sizeof(char));
             --rdata->input.length;
             line[rdata->input.length] = '\0';
             _moveCursor(shell, line, rdata->input.cursorpos + 1, rdata->input.cursorpos);
             _printString(shell, line, rdata->input.cursorpos, rdata->input.length);
             streamPut(&shell->stream, ' ');
             _moveCursor(shell, shell->inputdata.lineend + 1, shell->inputdata.cursorpos);
             _moveCursor(shell, line, rdata->input.length + 1, rdata->input.cursorpos);
             break;
+          }

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff