/ - Diff - AMiRo-OS - Research for Cognitive Interaction

Revision c18a848e

       aosDbgCheck(shell != NULL);
       // check whether input line is already full
       if (shell->inputdata.lineend + 1 >= shell->input.length) {
       if (shell->inputdata.lineend + 1 >= shell->input.size) {
         return 0;
       } else {
         // clear old line content on first input
         if (shell->inputdata.noinput) {
           memset(shell->input.line, '\0', shell->input.length);
           memset(shell->input.line, '\0', shell->input.size);
           shell->inputdata.noinput = false;
+        }
         // overwrite content
-...
+     *
      * @param[in]   shell     Pointer to the shell object.
      * @param[in]   channel   The channel to read from.
      * @param[out]  n         Optional pointer to a variable to store the number of read characters to.
      * @param[out]  exec      Optional pointer to a flag, which indicates, whether a command shall be executed.
+     *
      * @return  Indicator, whether the read character(s) indicated, that a command shall be executed.
      * @return  Number of read characters.
      */
     static bool _readChannel(aos_shell_t* shell, AosShellChannel* channel, size_t* n)
     static int _readChannel(aos_shell_t* shell, AosShellChannel* channel, bool* execute)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(channel != NULL);
-...
       aos_shellaction_t action = AOS_SHELL_ACTION_NONE;
       char c;
       special_key_t key;
       // initialize output variables
       if (n) {
         *n = 0;
+      }
       int nchars = 0;
       bool exec = false;
       // read character by character from the channel
       while (chnReadTimeout(channel, (uint8_t*)&c, 1, TIME_IMMEDIATE)) {
         key = KEY_UNKNOWN;
         // drop any input after an execution request was detected
         if (exec) {
           continue;
+        }
         // incremet character counter
         ++nchars;
         // parse escape sequence
         if (strlen(shell->inputdata.escseq) > 0) {
           shell->inputdata.escseq[strlen(shell->inputdata.escseq)] = c;
-...
             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.length) {
                 cmatch = shell->input.length - shell->inputdata.lineend + shell->inputdata.cursorpos;
               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);
-...
             size_t nul_start = 0;
             size_t nul_end = 0;
             // search line for a NUL byte
             while (nul_start < shell->input.length) {
             while (nul_start < shell->input.size) {
               if (shell->input.line[nul_start] == '\0') {
                 nul_end = nul_start + 1;
                 // keep searcjing for a byte that is not NUL
                 while (nul_end < shell->input.length) {
                 while (nul_end < shell->input.size) {
                   if (shell->input.line[nul_end] != '\0') {
                     // an intermediate NUL sequence was found
                     memset(&(shell->input.line[nul_start]), ' ', nul_end - nul_start);
-...
           case AOS_SHELL_ACTION_EXECUTE:
+          {
             streamPut(&shell->stream, '\n');
             // set the number of read bytes and return
             // if there was some input
             if (!shell->inputdata.noinput) {
               if (n) {
                 *n = shell->input.length - shell->inputdata.lineend;
+              }
               // fill the remainder of the line with NUL bytes
               memset(&(shell->input.line[shell->inputdata.lineend]), '\0', (shell->input.length - shell->inputdata.lineend));
               memset(&(shell->input.line[shell->inputdata.lineend]), '\0', shell->input.size - shell->inputdata.lineend);
+            }
             return true;
             // set the execution flag
             exec = true;
             break;
+          }
           case AOS_SHELL_ACTION_ESCSTART:
-...
         shell->inputdata.lastaction = action;
       } /* end of while */
       // no more data could be read from the channel
       return false;
       // set the execution output flag
       if (execute) {
         *execute = exec;
+      }
       return nchars;
+    }
     /**
-...
       size_t nargs = 0;
       // iterate through the line
       for (char* c = shell->input.line; c < shell->input.line + shell->input.length; ++c) {
       for (char* c = shell->input.line; c < shell->input.line + shell->input.size; ++c) {
         // terminate at first NUL byte
         if (*c == '\0') {
           state = END;
-...
       eventmask_t eventmask;
       eventflags_t eventflags;
       AosShellChannel* channel;
       aos_status_t readeval;
       bool execute;
       char* args[((aos_shell_t*)shell)->input.nargs];
       size_t nargs = 0;
       aos_shellcommand_t* cmd;
-...
             while (channel != NULL) {
               eventflags = chEvtGetAndClearFlags(&channel->listener);
               // if there is new input and a command shall be executed
               if ((eventflags & CHN_INPUT_AVAILABLE) && _readChannel((aos_shell_t*)shell, channel, NULL)) {
                 // parse input line to argument list
                 nargs = _parseArguments((aos_shell_t*)shell, args);
                 // check number of arguments
                 if (nargs > ((aos_shell_t*)shell)->input.nargs) {
                   // error too many arguments
                   chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\ttoo many arguments\n");
                 } else if (nargs > 0) {
                   // search command list for arg[0] and execute callback
                   cmd = ((aos_shell_t*)shell)->commands;
                   while (cmd != NULL) {
                     if (strcmp(args[0], cmd->name) == 0) {
                       ((aos_shell_t*)shell)->execstatus.command = cmd;
                       chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXEC);
                       ((aos_shell_t*)shell)->execstatus.retval = cmd->callback((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, (int)nargs, args);
                       chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_DONE);
                       // notify if the command was not successful
                       if (((aos_shell_t*)shell)->execstatus.retval != 0) {
                         chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "command returned exit status %d\n", ((aos_shell_t*)shell)->execstatus.retval);
               if (eventflags & CHN_INPUT_AVAILABLE) {
                 _readChannel((aos_shell_t*)shell, channel, &execute);
                 // an execution request was detected
                 if (execute && !((aos_shell_t*)shell)->inputdata.noinput) {
                   // parse input line to argument list
                   nargs = _parseArguments((aos_shell_t*)shell, args);
                   // check number of arguments
                   if (nargs > ((aos_shell_t*)shell)->input.nargs) {
                     // error too many arguments
                     chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\ttoo many arguments\n");
                   } else if (nargs > 0) {
                     // search command list for arg[0] and execute callback
                     cmd = ((aos_shell_t*)shell)->commands;
                     while (cmd != NULL) {
                       if (strcmp(args[0], cmd->name) == 0) {
                         ((aos_shell_t*)shell)->execstatus.command = cmd;
                         chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXEC);
                         ((aos_shell_t*)shell)->execstatus.retval = cmd->callback((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, (int)nargs, args);
                         chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_DONE);
                         // notify if the command was not successful
                         if (((aos_shell_t*)shell)->execstatus.retval != 0) {
                           chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "command returned exit status %d\n", ((aos_shell_t*)shell)->execstatus.retval);
+                        }
                         break;
+                      }
                       break;
+                    }
                     cmd = cmd->next;
                   } /* end of while */
                       cmd = cmd->next;
                     } /* end of while */
                   // if no matching command was found, print an error
                   if (cmd == NULL) {
                     chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\tcommand '%s' not found\n", args[0]);
                     // if no matching command was found, print an error
                     if (cmd == NULL) {
                       chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\tcommand '%s' not found\n", args[0]);
+                    }
+                  }
+                }
                 // reset some internal variables and eprint a new prompt
                 if (readeval == AOS_SUCCESS && !chThdShouldTerminateX()) {
                 // reset some internal variables and print a new prompt
                 if (execute && !chThdShouldTerminateX()) {
                   ((aos_shell_t*)shell)->inputdata.cursorpos = 0;
                   ((aos_shell_t*)shell)->inputdata.lineend = 0;
                   ((aos_shell_t*)shell)->inputdata.noinput = true;

Also available in: Unified diff