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

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

History | View | Annotate | Download (46.811 KB)

       /*
       AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
       Copyright (C) 2016..2018  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 <aos_shell.h>
       #if (AMIROOS_CFG_SHELL_ENABLE == true)
       #include <aos_debug.h>
       #include <aos_time.h>
       #include <aos_system.h>
       #include <string.h>
       /**
        * @brief   Event mask to be set on OS related events.
        */
       #define AOS_SHELL_EVENTMASK_OS                  EVENT_MASK(0)
       /**
        * @brief   Event mask to be set on a input event.
        */
       #define AOS_SHELL_EVENTMASK_INPUT               EVENT_MASK(1)
       /**
        * @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;
+      }
       static const struct AosShellChannelVMT _channelvmt = {
         (size_t) 0,
         _channelwrite,
         _channelread,
         _channelput,
         _channelget,
         _channelputt,
         _channelgett,
         _channelwritet,
         _channelreadt,
         _channelctl,
       };
       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;
+      }
       static size_t _stremread(void *instance, uint8_t *bp, size_t n)
+      {
         (void)instance;
         (void)bp;
         (void)n;
         return 0;
+      }
       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;
+      }
       static msg_t _streamget(void *instance)
+      {
         (void)instance;
         return 0;
+      }
       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_ESCAPE,       /**< escape key */
         KEY_BACKSPACE,    /**< backspace key */
         KEY_INSERT,       /**< insert key */
         KEY_DELETE,       /**< delete 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 */
       } 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   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));
+          }
           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);
+          }
           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
+       *
        * @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
         bool ambiguous = false;
         int cmp = 0;
         // TAB
         /* not supported yet; use "\x09" instead */
         // BACKSPACE
         /* not supported yet; use "\x08" instead */
         // ESCAPE
         cmp = strcmp(seq, "\x1B");
         if (cmp == 0) {
           return KEY_ESCAPE;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // INSERT
         cmp = strcmp(seq, "\x1B\x5B\x32\x7E");
         if (cmp == 0) {
           return KEY_INSERT;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // DELETE
         cmp = strcmp(seq, "\x1B\x5B\x33\x7E");
         if (cmp == 0) {
           return KEY_DELETE;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // HOME
         cmp = strcmp(seq, "\x1B\x4F\x48");
         if (cmp == 0) {
           return KEY_HOME;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // END
         cmp = strcmp(seq, "\x1B\x4F\x46");
         if (cmp == 0) {
           return KEY_END;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // PAGE UP
         cmp = strcmp(seq, "\x1B\x5B\x35\x7E");
         if (cmp == 0) {
           return KEY_PAGE_UP;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // PAGE DOWN
         cmp = strcmp(seq, "\x1B\x5B\x36\x7E");
         if (cmp == 0) {
           return KEY_PAGE_DOWN;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // ARROW UP
         cmp = strcmp(seq, "\x1B\x5B\x41");
         if (cmp == 0) {
           return KEY_ARROW_UP;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // ARROW DOWN
         cmp = strcmp(seq, "\x1B\x5B\x42");
         if (cmp == 0) {
           return KEY_ARROW_DOWN;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // ARROW LEFT
         cmp = strcmp(seq, "\x1B\x5B\x44");
         if (cmp == 0) {
           return KEY_ARROW_LEFT;
         } else {
           ambiguous |= (cmp < 0);
+        }
         // ARROW RIGHT
         cmp = strcmp(seq, "\x1B\x5B\x43");
         if (cmp == 0) {
           return KEY_ARROW_RIGHT;
         } else {
           ambiguous |= (cmp < 0);
+        }
         return ambiguous ? KEY_AMBIGUOUS : KEY_UNKNOWN;
+      }
       /**
        * @brief   Move the cursor in the terminal
+       *
        * @param[in] shell   Pointer to the shell object.
        * @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)
+      {
         aosDbgCheck(shell != NULL);
         // local variables
         size_t pos = from;
         // move cursor left by printing backspaces
         while (pos > to) {
           streamPut(&shell->stream, '\b');
           --pos;
+        }
         // move cursor right by printing line content
         while (pos < to) {
           streamPut(&shell->stream, shell->line[pos]);
           ++pos;
+        }
         return (int)pos - (int)from;
+      }
       /**
        * @brief   Print content of the shell line
+       *
        * @param[in] shell   Pointer to the shell object.
        * @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)
+      {
         aosDbgCheck(shell != NULL);
         // local variables
         size_t cnt;
         for (cnt = 0; from + cnt < to; ++cnt) {
           streamPut(&shell->stream, shell->line[from + cnt]);
+        }
         return cnt;
+      }
       /**
        * @brief   Compare two characters.
+       *
        * @param[in] lhs       First character to compare.
        * @param[in] rhs       Second character to compare.
+       *
        * @return              How well the characters match.
        */
       static inline charmatch_t _charcmp(char lhs, char rhs)
+      {
         // if lhs is a upper case letter and rhs is a lower case letter
         if (lhs >= 'A' && lhs <= 'Z' && rhs >= 'a' && rhs <= 'z') {
           return (lhs == (rhs - 'a' + 'A')) ? CHAR_MATCH_NCASE : CHAR_MATCH_NOT;
+        }
         // if lhs is a lower case letter and rhs is a upper case letter
         else if (lhs >= 'a' && lhs <= 'z' && rhs >= 'A' && rhs <= 'Z') {
           return ((lhs - 'a' + 'A') == rhs) ? CHAR_MATCH_NCASE : CHAR_MATCH_NOT;
+        }
         // default
         else {
           return (lhs == rhs) ? CHAR_MATCH_CASE : CHAR_MATCH_NOT;
+        }
+      }
       /**
        * @brief   Maps an character from ASCII to a modified custom encoding.
        * @details The custom character encoding is very similar to ASCII and has the following structure:
        *          0x00=NULL ... 0x40='@' (identically to ASCII)
        *          0x4A='a'; 0x4B='A'; 0x4C='b'; 0x4D='B' ... 0x73='z'; 0x74='Z' (custom letter order)
        *          0x75='[' ... 0x7A='`' (0x5B..0x60 is ASCII)
        *          0x7B='{' ... 0x7F=DEL (identically to ASCII)
+       *
        * @param[in] c   Character to map to the custom encoding.
+       *
        * @return    The customly encoded character.
        */
       static inline char _mapAscii2Custom(const char c)
+      {
         if (c >= 'A' && c <= 'Z') {
           return ((c - 'A') * 2) + 'A' + 1;
         } else if (c > 'Z' && c < 'a') {
           return c + ('z' - 'a') + 1;
         } else if (c >= 'a' && c <= 'z') {
           return ((c - 'a') * 2) + 'A';
         } else {
           return c;
+        }
+      }
       /**
        * @brief   Compares two strings wrt letter case.
        * @details Comparisson uses a custom character encoding or mapping.
        *          See @p _mapAscii2Custom for details.
+       *
        * @param[in] str1    First string to compare.
        * @param[in] str2    Second string to compare.
        * @param[in] cs      Flag indicating whether comparison shall be case sensitive.
        * @param[in,out] n   Maximum number of character to compare (in) and number of matching characters (out).
        *                    If a null pointer is specified, this parameter is ignored.
        *                    If the value pointed to is zero, comarison will not be limited.
        * @param[out] m      Optional indicator whether there was at least one case mismatch.
+       *
        * @return      Integer value indicating the relationship between the strings.
        * @retval <0   The first character that does not match has a lower value in str1 than in str2.
        * @retval  0   The contents of both strings are equal.
        * @retval >0   The first character that does not match has a greater value in str1 than in str2.
        */
       static int _strccmp(const char *str1, const char *str2, bool cs, size_t* n, charmatch_t* m)
+      {
         aosDbgCheck(str1 != NULL);
         aosDbgCheck(str2 != NULL);
         // initialize variables
         if (m) {
           *m = CHAR_MATCH_NOT;
+        }
         size_t i = 0;
         // iterate through the strings
         while ((n == NULL) || (*n == 0) || (*n > 0 && i < *n)) {
           // break on NUL
           if (str1[i] == '\0' || str2[i] == '\0') {
             if (n) {
               *n = i;
+            }
             break;
+          }
           // compare character
           const charmatch_t match = _charcmp(str1[i], str2[i]);
           if ((match == CHAR_MATCH_CASE) || (!cs && match == CHAR_MATCH_NCASE)) {
             if (m != NULL && *m != CHAR_MATCH_NCASE) {
               *m = match;
+            }
             ++i;
           } else {
             if (n) {
               *n = i;
+            }
             break;
+          }
+        }
         return _mapAscii2Custom(str1[i]) - _mapAscii2Custom(str2[i]);
+      }
       static aos_status_t _readChannel(aos_shell_t* shell, AosShellChannel* channel, size_t* n)
+      {
         aosDbgCheck(shell != NULL);
         aosDbgCheck(channel != NULL);
         aosDbgCheck(n != NULL);
         // local variables
         aos_shellaction_t action = AOS_SHELL_ACTION_NONE;
         char c;
         special_key_t key;
         // initialize output variables
         *n = 0;
         // read character by character from the channel
         while (chnReadTimeout(channel, (uint8_t*)&c, 1, TIME_IMMEDIATE)) {
           key = KEY_UNKNOWN;
           // parse escape sequence
           if (shell->inputdata.escp > 0) {
             shell->inputdata.escseq[shell->inputdata.escp] = c;
             ++shell->inputdata.escp;
             key = _interpreteEscapeSequence(shell->inputdata.escseq);
             if (key == KEY_AMBIGUOUS) {
               // read next byte to resolve ambiguity
               continue;
             } else {
               /*
                * If the escape sequence could either be parsed sucessfully
                * or there is no match (KEY_UNKNOWN),
                * reset the sequence variable and interprete key/character
                */
               shell->inputdata.escp = 0;
               memset(shell->inputdata.escseq, '\0', sizeof(shell->inputdata.escseq)*sizeof(shell->inputdata.escseq[0]));
+            }
+          }
           /* interprete keys or character */
+          {
             // default
             action = AOS_SHELL_ACTION_NONE;
             // printable character
             if (key == KEY_UNKNOWN && c >= '\x20' && c <= '\x7E') {
               action = AOS_SHELL_ACTION_READCHAR;
+            }
             // tab key or character
             else if (key == KEY_TAB || c == '\x09') {
               /*
                * pressing tab once applies auto fill
                * pressing tab a second time prints suggestions
                */
               if (shell->inputdata.lastaction == AOS_SHELL_ACTION_AUTOFILL || shell->inputdata.lastaction == AOS_SHELL_ACTION_SUGGEST) {
                 action = AOS_SHELL_ACTION_SUGGEST;
               } else {
                 action = AOS_SHELL_ACTION_AUTOFILL;
+              }
+            }
             // 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;
+              }
+            }
             // backspace key or character
             else if (key == KEY_BACKSPACE || c == '\x08') {
               // ignore if cursor is at very left
               if (shell->inputdata.cursorpos > 0) {
                 action = AOS_SHELL_ACTION_DELETEBACKWARD;
+              }
+            }
             // 'page up' of 'arrow up' key
             else if (key == KEY_PAGE_UP || key == KEY_ARROW_UP) {
               // ignore if there was some input
               if (shell->inputdata.noinput) {
                 action = AOS_SHELL_ACTION_RECALLLAST;
+              }
+            }
             // 'page down' key, 'arrow done' key, 'end of test' character or 'end of transmission' character
             else if (key == KEY_PAGE_DOWN || key == KEY_ARROW_DOWN || c == '\x03' || c == '\x03') {
               // ignore if line is empty
               if (shell->inputdata.lineend > 0) {
                 action = AOS_SHELL_ACTION_CLEAR;
+              }
+            }
             // 'home' key
             else if (key == KEY_HOME) {
               // ignore if cursor is very left
               if (shell->inputdata.cursorpos > 0) {
                 action = AOS_SHELL_ACTION_CURSOR2START;
+              }
+            }
             // '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;
+              }
+            }
             // 'arrow left' key
             else if (key == KEY_ARROW_LEFT) {
               // ignore if cursor is very left
               if (shell->inputdata.cursorpos > 0) {
                 action = AOS_SHELL_ACTION_CURSORLEFT;
+              }
+            }
             // 'arrow right' key
             else if (key == KEY_ARROW_RIGHT) {
               // irgnore if cursor is very right
               if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
                 action = AOS_SHELL_ACTION_CURSORRIGHT;
+              }
+            }
             // carriage return ('\r') or line feed ('\n') character
             else if (c == '\x0D' || c == '\x0A') {
               action = AOS_SHELL_ACTION_EXECUTE;
+            }
             // ESC key or [ESCAPE] character
             else if (key == KEY_ESCAPE || c == '\x1B') {
               action = AOS_SHELL_ACTION_ESCSTART;
+            }
+          }