AMiRo-OS

  // move cursor right by printing line content

  while (pos < to) {

    ++pos;

  }

  size_t cnt;

  for (cnt = 0; from + cnt < to; ++cnt) {

  }

  return cnt;

  aosDbgCheck(shell != NULL);

  // check whether input line is already full

    return 0;

  } else {

    // clear old line content on first input

    if (shell->inputdata.noinput) {

      shell->inputdata.noinput = false;

    }

    // overwrite content

          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) ?

                            (cmd->name[n] != '\0') ?

                              0;

          // if an exact match was found

            cmatch = shell->inputdata.cursorpos;

            fill = cmd->name;

            // break the loop only if there are no case mismatches with the input

            }

          }

          // if a not exact match was found

            // if this is the first one

            if (fill == shell->input.line) {

              fill = cmd->name;

            }

            // if this is a worse one

            else if ((cmp < 0) || (cmp == 0 && mlvl == CHAR_MATCH_CASE)) {

            }

          }

          // non matching commands are ignored

        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

          }

          // move trailing memory further in the line

          memmove(&(shell->input.line[cmatch]), &(shell->input.line[shell->inputdata.cursorpos]), shell->inputdata.lineend - shell->inputdata.cursorpos);

            _strccmp(shell->input.line, cmd->name, true, &i, NULL);

          }

          const int cmp = (i < shell->inputdata.cursorpos) ?

                            (cmd->name[i] != '\0') ?

                              0;

          // if a match was found

          if (cmp > 0) {

        size_t nul_start = 0;

        size_t nul_end = 0;

        // search line for a NUL byte

          if (shell->input.line[nul_start] == '\0') {

            nul_end = nul_start + 1;

            // keep searcjing for a byte that is not NUL

              if (shell->input.line[nul_end] != '\0') {

                // an intermediate NUL sequence was found

                memset(&(shell->input.line[nul_start]), ' ', nul_end - nul_start);

        streamPut(&shell->stream, '\n');

        // set the number of read bytes and return

        if (!shell->inputdata.noinput) {

          // fill the remainder of the line with NUL bytes

          memset(&(shell->input.line[shell->inputdata.lineend]), '\0', *n);

          // reset static variables

/**

 * @brief   Parses the content of the input buffer (line) to separate arguments.

 *

 *

 * @return            Number of arguments found.

 */

{

  aosDbgCheck(shell != NULL);

  /*

   * States for a very small FSM.

  // local variables

  state_t state = START;

  // iterate through the line

    // terminate at first NUL byte

    if (*c == '\0') {

      state = END;

        case START:

        case SPACE:

          // ignore too many arguments

          }

          break;

        case TEXT:

        case END:

          break;

      }

      state = TEXT;

  }

  // set all remaining argument pointers to NULL

  }

}

/******************************************************************************/

 * @param[in] prompt        Prompt line to print (NULL = use default prompt).

 * @param[in] line          Pointer to the input buffer.

 * @param[in] linesize      Size of the input buffer.

 */

{

  aosDbgCheck(shell != NULL);

  aosDbgCheck(oseventsource != NULL);

  aosDbgCheck(line != NULL);

  // set parameters

  shell->thread = NULL;

  shell->execstatus.command = NULL;

  shell->execstatus.retval = 0;

  shell->input.line = line;

  shell->inputdata.lastaction = AOS_SHELL_ACTION_NONE;

  memset(shell->inputdata.escseq, '\0', sizeof(shell->inputdata.escseq)*sizeof(shell->inputdata.escseq[0]));

  shell->inputdata.cursorpos = 0;

  shell->inputdata.lineend = 0;

  shell->inputdata.noinput = true;

  shell->config = 0x00;

  // initialize buffers

  return;

}

  AosShellChannel* channel;

  aos_status_t readeval;

  size_t nchars = 0;

  size_t nargs = 0;

  aos_shellcommand_t* cmd;

  // register OS related events

  chEvtRegisterMask(((aos_shell_t*)shell)->os.eventSource, &(((aos_shell_t*)shell)->os.eventListener), AOS_SHELL_EVENTMASK_OS);

            // read input from channel

            readeval = _readChannel((aos_shell_t*)shell, channel, &nchars);

            // parse input line to argument list only if the input shall be executed

            // check number of arguments

              // 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) {

                  ((aos_shell_t*)shell)->execstatus.command = cmd;

                  chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXEC);

                  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) {

              // if no matching command was found, print an error

              if (cmd == NULL) {

              }

            }