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

amiro-os / core / src / aos_shell.c @ a93a1019

History | View | Annotate | Download (73.613 KB)

       /*
       AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
       Copyright (C) 2016..2020  Thomas Schöpping et al.
       This program is free software: you can redistribute it and/or modify
       it under the terms of the GNU General Public License as published by
       the Free Software Foundation, either version 3 of the License, or
       (at your option) any later version.
       This program is distributed in the hope that it will be useful,
       but WITHOUT ANY WARRANTY; without even the implied warranty of
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
       GNU General Public License for more details.
       You should have received a copy of the GNU General Public License
       along with this program.  If not, see <http://www.gnu.org/licenses/>.
       */
       /**
        * @file    aos_shell.c
        * @brief   Shell code.
        * @details Shell code as well as shell related channels and streams.
+       *
        * @addtogroup aos_shell
        * @{
        */
       #include <amiroos.h>
       #include <string.h>
       #if (AMIROOS_CFG_SHELL_ENABLE == true) || defined(__DOXYGEN__)
       /******************************************************************************/
       /* LOCAL DEFINITIONS                                                          */
       /******************************************************************************/
       /**
        * @brief   Size of the escape sequence buffer.
        */
       #if !defined(AOS_SHELL_ESCSEQUENCE_LENGTH) || defined(__DOXYGEN__)
       #define AOS_SHELL_ESCSEQUENCE_LENGTH            8
       #endif
       /**
        * @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 EVENTMASK_OS                            EVENT_MASK(0)
       /**
        * @brief   Event mask to be set on a input event.
        */
       #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                                                         */
       /******************************************************************************/
       /******************************************************************************/
       /* LOCAL TYPES                                                                */
       /******************************************************************************/
       /*
        * forward declarations
        */
       static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n);
       static size_t _channelread(void *instance, uint8_t *bp, size_t n);
       static msg_t _channelput(void *instance, uint8_t b);
       static msg_t _channelget(void *instance);
       static msg_t _channelputt(void *instance, uint8_t b, sysinterval_t time);
       static msg_t _channelgett(void *instance, sysinterval_t time);
       static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, sysinterval_t time);
       static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, sysinterval_t time);
       static msg_t _channelctl(void *instance, unsigned int operation, void *arg);
       static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n);
       static size_t _stremread(void *instance, uint8_t *bp, size_t n);
       static msg_t _streamput(void *instance, uint8_t b);
       static msg_t _streamget(void *instance);
       static const struct AosShellChannelVMT _channelvmt = {
         (size_t) 0,
         _channelwrite,
         _channelread,
         _channelput,
         _channelget,
         _channelputt,
         _channelgett,
         _channelwritet,
         _channelreadt,
         _channelctl,
       };
       static const struct AosShellStreamVMT _streamvmt = {
         (size_t) 0,
         _streamwrite,
         _stremread,
         _streamput,
         _streamget,
       };
       /**
        * @brief   Enumerator of special keyboard keys.
        */
       typedef enum special_key {
         KEY_UNKNOWN,          /**< any/unknow key */
         KEY_AMBIGUOUS,        /**< key is ambiguous */
         KEY_TAB,              /**< tabulator 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_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;
       /**
        * @brief   Enumerator for case (in)sensitive character matching.
        */
       typedef enum charmatch {
         CHAR_MATCH_NOT    = 0,  /**< Characters do not match at all. */
         CHAR_MATCH_NCASE  = 1,  /**< Characters would match case insensitive. */
         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                                                            */
       /******************************************************************************/
       /******************************************************************************/
       /* LOCAL FUNCTIONS                                                            */
       /******************************************************************************/
       /**
        * @brief   Implementation of the BaseAsynchronous write() method (inherited from BaseSequentialStream).
        */
       static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
           return streamWrite(((AosShellChannel*)instance)->asyncchannel, bp, n);
         } else {
           return 0;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronous read() method (inherited from BaseSequentialStream).
        */
       static size_t _channelread(void *instance, uint8_t *bp, size_t n)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
           return streamRead(((AosShellChannel*)instance)->asyncchannel, bp, n);
         } else {
           return 0;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronous put() method (inherited from BaseSequentialStream).
        */
       static msg_t _channelput(void *instance, uint8_t b)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
           return streamPut(((AosShellChannel*)instance)->asyncchannel, b);
         } else {
           return MSG_RESET;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronous get() method (inherited from BaseSequentialStream).
        */
       static msg_t _channelget(void *instance)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
           return streamGet(((AosShellChannel*)instance)->asyncchannel);
         } else {
           return MSG_RESET;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronous putt() method.
        */
       static msg_t _channelputt(void *instance, uint8_t b, sysinterval_t time)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
           return chnPutTimeout(((AosShellChannel*)instance)->asyncchannel, b, time);
         } else {
           return MSG_RESET;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronous gett() method.
        */
       static msg_t _channelgett(void *instance, sysinterval_t time)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
           return chnGetTimeout(((AosShellChannel*)instance)->asyncchannel, time);
         } else {
           return MSG_RESET;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronous writet() method.
        */
       static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, sysinterval_t time)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
           return chnWriteTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
         } else {
           return 0;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronous readt() method.
        */
       static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, sysinterval_t time)
+      {
         if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
           return chnReadTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
         } else {
           return 0;
+        }
+      }
       /**
        * @brief   Implementation of the BaseAsynchronousChannel ctl() method.
        */
       static msg_t _channelctl(void *instance, unsigned int operation, void *arg)
+      {
         (void) instance;
         switch (operation) {
         case CHN_CTL_NOP:
           osalDbgCheck(arg == NULL);
           break;
         case CHN_CTL_INVALID:
           osalDbgAssert(false, "invalid CTL operation");
           break;
         default:
           break;
+        }
         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);
         // local variables
         AosShellChannel* channel = ((AosShellStream*)instance)->channel;
         size_t bytes;
         size_t maxbytes = 0;
         // iterate through the list of channels
         while (channel != NULL) {
           bytes = streamWrite(channel, bp, n);
           maxbytes = (bytes > maxbytes) ? bytes : maxbytes;
           channel = channel->next;
+        }
         return maxbytes;
+      }
       /**
        * @brief   Implementation of the BaseSequentialStream read() method.
        */
       static size_t _stremread(void *instance, uint8_t *bp, size_t n)
+      {
         (void)instance;
         (void)bp;
         (void)n;
         return 0;
+      }
       /**
        * @brief   Implementation of the BaseSequentialStream put() method.
        */
       static msg_t _streamput(void *instance, uint8_t b)
+      {
         aosDbgCheck(instance != NULL);
         // local variables
         AosShellChannel* channel = ((AosShellStream*)instance)->channel;
         msg_t ret = MSG_OK;
         // iterate through the list of channels
         while (channel != NULL) {
           msg_t ret_ = streamPut(channel, b);
           ret = (ret_ < ret) ? ret_ : ret;
           channel = channel->next;
+        }
         return ret;
+      }
       /**
        * @brief   Implementation of the BaseSequentialStream get() method.
        */
       static msg_t _streamget(void *instance)
+      {
         (void)instance;
         return 0;
+      }
       /**
        * @brief   Retrieve 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 retrieved.
+       *
        * @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   Retrieve 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 retrieved.
+       *
        * @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   Retrieve 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   Retrieve 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   Retrieve 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.
+       *
        * @param[in] shell   Pointer to the shell object.
        */
       static void _printPrompt(aos_shell_t* shell)
+      {
         aosDbgCheck(shell != NULL);
         // print some time informattion before prompt if configured
         if (shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) {
           // printf the system uptime
           if ((shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) == AOS_SHELL_CONFIG_PROMPT_UPTIME) {
             // get current system uptime
             aos_timestamp_t uptime;
             aosSysGetUptime(&uptime);
             chprintf((BaseSequentialStream*)&shell->stream, "[%01u:%02u:%02u:%02u:%03u:%03u] ",
                      (uint32_t)(uptime / MICROSECONDS_PER_DAY),
                      (uint8_t)(uptime % MICROSECONDS_PER_DAY / MICROSECONDS_PER_HOUR),
                      (uint8_t)(uptime % MICROSECONDS_PER_HOUR / MICROSECONDS_PER_MINUTE),
                      (uint8_t)(uptime % MICROSECONDS_PER_MINUTE / MICROSECONDS_PER_SECOND),
                      (uint16_t)(uptime % MICROSECONDS_PER_SECOND / MICROSECONDS_PER_MILLISECOND),
                      (uint16_t)(uptime % MICROSECONDS_PER_MILLISECOND / MICROSECONDS_PER_MICROSECOND));
+          }
       #if (HAL_USE_RTC == TRUE)
           else if ((shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) == AOS_SHELL_CONFIG_PROMPT_DATETIME) {
             // get current RTC time
             struct tm dt;
             aosSysGetDateTime(&dt);
             chprintf((BaseSequentialStream*)&shell->stream, "[%02u-%02u-%04u|%02u:%02u:%02u] ",
                      dt.tm_mday,
                      dt.tm_mon + 1,
                      dt.tm_year + 1900,
                      dt.tm_hour,
                      dt.tm_min,
                      dt.tm_sec);
+          }
       #endif /* (HAL_USE_RTC == TRUE) */
           else {
             aosDbgAssert(false);
+          }
+        }
         // print the actual prompt string
         if (shell->prompt && !(shell->config & AOS_SHELL_CONFIG_PROMPT_MINIMAL)) {
           chprintf((BaseSequentialStream*)&shell->stream, "%s$ ", shell->prompt);
         } else {
           chprintf((BaseSequentialStream*)&shell->stream, "%>$ ");
+        }
         return;
+      }
       /**
        * @brief   Interprete a escape sequence
        * @details This function interpretes escape sequences (starting with ASCII
        *          "Escape" character 0x1B) according to the VT100 / VT52 ANSI escape
        *          sequence definitions.
        * @note    Only the most important escape sequences are implemented yet.
+       *
        * @param[in] seq   Character sequence to interprete.
        *                  Must be terminated by NUL byte.
+       *
        * @return          A @p special_key value.
        */
       static special_key_t _interpreteEscapeSequence(const char seq[])
+      {
         // local variables
         unsigned long strl = 0;
         const unsigned long seql = strlen(seq);
         bool ambiguous = false;
         // TAB
         /* not supported yet; use '\x09' instead */
         // BACKSPACE
         /* not supported yet; use '\x08' instead */
         // ESCAPE
         /* not supported yes; use '\x1B' instead */
         // CTRL + C
         /* not defined yet; use '\x03' instead */
         // INSERT
         if (strncmp(seq, KEYSTRING_INSERT, seql) == 0) {
           strl = strlen(KEYSTRING_INSERT);
           if (seql == strl) {
             return KEY_INSERT;
           } else if (seql < strl) {
             ambiguous = true;
+          }
+        }
         // DELETE
         if (strncmp(seq, KEYSTRING_DELETE, seql) == 0) {
           strl = strlen(KEYSTRING_DELETE);
           if (seql == strl) {
             return KEY_DELETE;
           } else if (seql < strl) {
             ambiguous = true;
+          }
+        }
         // HOME
         if (strncmp(seq, KEYSTRING_HOME, seql) == 0) {
           strl = strlen(KEYSTRING_HOME);
           if (seql == strl) {
             return KEY_HOME;
           } else if (seql < strl) {
             ambiguous = true;
+          }
+        }
         // END
         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
         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
         if (strncmp(seq, KEYSTRING_PAGEDOWN, seql) == 0) {
           strl = strlen(KEYSTRING_PAGEDOWN);
           if (seql == strl) {
             return KEY_PAGEDOWN;
           } else if (seql < strl) {
             ambiguous = true;
+          }
+        }