@MaJerle - I can do a pull request for the below issue, but want to know your preference first.

when the input buffer is full, we get an overflow while parsing the args:

            } else {
                lw->argv[lw->argc++] = str;     /* Set start of argument directly on character */
                while (*str != ' ' && *str != '\0') {
                    if (*str == '"') {          /* Quote should not be here... */
                        *str = '\0';            /* ...add NULL termination to end token */
                    }
                    ++str;
                }
                *str = '\0';
                ++str;   /* <<<==== here str increment over the input buff when the above while stop on the last byte of the buff */
            }

Since this is a light shell, I assume you want to keep performance as good as possible:

• the first option is less intuitive, but it just adds one byte to the memory usage :)
• the second option adds more execution code :(

1. add 2 extra bytes (instead of +1) to the input buffer and change the ADD macro. this way we guarantee an extra NULL at the end:

char buff[LWSHELL_CFG_MAX_INPUT_LEN + 2]; /*!< Shell command input buffer */

 /* Add character to instance */
#define LWSHELL_ADD_CH(lw, ch)      do {            \
    if ((lw)->buff_ptr < (LWSHELL_ARRAYSIZE(lw->buff) - 2)) {   \
        (lw)->buff[(lw)->buff_ptr] = ch;            \
        (lw)->buff[++(lw)->buff_ptr] = '\0';        \
    }                                               \
} while (0)

2. Stop the loop with some pointer calculation:

            /* Check for number of arguments */
            if (lw->argc == LWSHELL_ARRAYSIZE(lw->argv)) {
                break;
            }

            /* Consume all input buffer... */
            if (str - lw->buff >= sizeof((lw)->buff)) {
                break;
            }
        }

Hi,

Really great simple shell but for me there is one handling really bad. So if as an example the user inputs some command (calc) using a terminal which gives /r/n at the end of the command then the input string looks like this

calc 1 2/r/n

So then in the handle function of calc i do some printing to the terminal. But after that /r and /n will be printed also i think that is not a behavior for everyone.

So a quick fix for me was change parse input. And if the parser found some command i will ignore the output of CR or LF but maybe there is a better solution.

best regards, mathias

    /* Must be more than `1` character since we have to include end of line */
    if (lw->buff_ptr > 0) {
        /* Set default values */
        lw->argc = 0;
        lw->argv[0] = lw->buff;

        /* Process complete input */
        str = lw->buff;

        /* Process complete string */
        lw->argc = 0;
        while (*str != '\0') {

Line 112 in lwshell.c

You clear argc, then clear it again before anything could have changed.

buff_ptr point to the end of the input buffer which is NULL, so it should be decreased before deleting the last character. I added a test option to test it by using a non-canonical input mode

Moving the struct to the header file would allow the application writer to declare their commands with it.

Here I declared my own struct: https://github.com/Ballen7/money-printer/blob/dev/apps/tempo/src/console.c

As topic.

I have a primary shell I use for on-module CLI access, as well as another shell that allows access to a bootloader CLI of off-board module. This latter terminal has different inputs and a tokenizer.

It would be nice to set both shells up differently and use this framework to address either.