diff options
Diffstat (limited to 'avr/cli.c')
-rw-r--r-- | avr/cli.c | 369 |
1 files changed, 369 insertions, 0 deletions
diff --git a/avr/cli.c b/avr/cli.c new file mode 100644 index 0000000..44cf5b8 --- /dev/null +++ b/avr/cli.c @@ -0,0 +1,369 @@ +#include "common.h" + +#include <string.h> +#include <ctype.h> +#include <stdlib.h> +#include <stdio.h> + +#include "config.h" +#include "command.h" +#include "xmalloc.h" +#include "debug.h" +#include "env.h" +#include "cli_readline.h" +#include "con-utils.h" +#include "cli.h" + +#define DEBUG_PARSER 0 /* set to 1 to debug */ + +#define debug_parser(fmt, args...) \ + debug_cond(DEBUG_PARSER, fmt, ##args) + +static int cli_parse_line(char *line, char *argv[]) +{ + static const FLASH char delim[] = {" \t"}; + + char *ptr; + uint_fast8_t nargs = 0; + + debug_parser("parse_line: \"%s\"\n", line); + + ptr = strtok_P(line, delim); + while(nargs < CONFIG_SYS_MAXARGS && ptr != NULL) { + argv[nargs++] = ptr; + ptr = strtok_P(NULL, delim); + } + + if (ptr != NULL) + printf_P(PSTR("** Too many args (max. %d) **\n"), CONFIG_SYS_MAXARGS); + + argv[nargs] = NULL; + debug_parser("parse_line: nargs=%d\n", nargs); + + return nargs; +} + +static void process_macros(const char *input, char *output) +{ + char c, prev; + const char *varname_start = NULL; +#if 0 && (CONFIG_SYS_CBSIZE < __UINT_FAST8_MAX__) + uint_fast8_t inputcnt = strlen(input); + uint_fast8_t outputcnt = CONFIG_SYS_CBSIZE; +#else + int inputcnt = strlen(input); + int outputcnt = CONFIG_SYS_CBSIZE; +#endif + uint_fast8_t state = 0; /* 0 = waiting for '$' */ + + /* 1 = waiting for '(' or '{' */ + /* 2 = waiting for ')' or '}' */ + /* 3 = waiting for ''' */ + char *output_start = output; + + debug_parser("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen(input), + input); + + prev = '\0'; /* previous character */ + + while (inputcnt && outputcnt) { + c = *input++; + inputcnt--; + + if (state != 3) { + /* remove one level of escape characters */ + if ((c == '\\') && (prev != '\\')) { + if (inputcnt-- == 0) + break; + prev = c; + c = *input++; + } + } + + switch (state) { + case 0: /* Waiting for (unescaped) $ */ + if ((c == '\'') && (prev != '\\')) { + state = 3; + break; + } + if ((c == '$') && (prev != '\\')) { + state++; + } else { + *(output++) = c; + outputcnt--; + } + break; + case 1: /* Waiting for ( */ + if (c == '(' || c == '{') { + state++; + varname_start = input; + } else { + state = 0; + *(output++) = '$'; + outputcnt--; + + if (outputcnt) { + *(output++) = c; + outputcnt--; + } + } + break; + case 2: /* Waiting for ) */ + if (c == ')' || c == '}') { + char envname[CONFIG_SYS_ENV_NAMELEN+1], *envval; + /* Varname # of chars */ + uint_fast8_t envcnt = input - varname_start - 1; + if (envcnt > CONFIG_SYS_ENV_NAMELEN) + envcnt = CONFIG_SYS_ENV_NAMELEN; + + memcpy(envname, varname_start, envcnt); + envname[envcnt] = '\0'; + + /* Get its value */ + envval = getenv(envname); + + /* Copy into the line if it exists */ + if (envval != NULL) + while ((*envval) && outputcnt) { + *(output++) = *(envval++); + outputcnt--; + } + /* Look for another '$' */ + state = 0; + } + break; + case 3: /* Waiting for ' */ + if ((c == '\'') && (prev != '\\')) { + state = 0; + } else { + *(output++) = c; + outputcnt--; + } + break; + } + prev = c; + } + + if (outputcnt) + *output = 0; + else + *(output - 1) = 0; + + debug_parser("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n", + strlen(output_start), output_start); +} + + /* + * WARNING: + * + * We must create a temporary copy of the command since the command we get + * may be the result from getenv(), which returns a pointer directly to + * the environment data, which may change magicly when the command we run + * creates or modifies environment variables (like "bootp" does). + */ +static int cli_run_command(const char *cmd, int flag) +{ + char *cmdbuf; /* working copy of cmd */ + char *token; /* start of token in cmdbuf */ + char *sep; /* end of token (separator) in cmdbuf */ + char *finaltoken; + char *str; + char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */ + int argc; + uint_fast8_t inquotes, repeatable = 1; + int rc = 0; + + debug_parser("[RUN_COMMAND] cmd[%p]=\"%s\"\n", + cmd, cmd ? cmd : "NULL"); + + clear_ctrlc(); /* forget any previous Control C */ + + if (!cmd || !*cmd) + return -1; /* empty command */ + + + cmdbuf = xmalloc(strlen(cmd) + 1); + finaltoken = xmalloc(CONFIG_SYS_CBSIZE); + + strcpy(cmdbuf, cmd); + str = cmdbuf; + + /* Process separators and check for invalid + * repeatable commands + */ + + debug_parser("[PROCESS_SEPARATORS] %s\n", cmd); + while (*str) { + /* + * Find separator, or string end + * Allow simple escape of ';' by writing "\;" + */ + for (inquotes = 0, sep = str; *sep; sep++) { + if ((*sep == '\'') && + (*(sep - 1) != '\\')) + inquotes = !inquotes; + + if (!inquotes && + (*sep == ';' || *sep == '\n') && /* separator */ + (sep != str) && /* past string start */ + (*(sep - 1) != '\\')) /* and NOT escaped */ + break; + } + + /* + * Limit the token to data between separators + */ + token = str; + if (*sep) { + str = sep + 1; /* start of command for next pass */ + *sep = '\0'; + } else { + str = sep; /* no more commands for next pass */ + } + debug_parser("token: \"%s\"\n", token); + + /* find macros in this token and replace them */ + process_macros(token, finaltoken); + + /* Extract arguments */ + argc = cli_parse_line(finaltoken, argv); + if (argc == 0) { + rc = -1; /* no command at all */ + continue; + } + + if (cmd_process(flag, argc, argv, &repeatable)) + rc = -1; + + /* Did the user stop this? */ + if (had_ctrlc()) { + rc = -1; /* if stopped then not repeatable */ + break; + } + } + + free(cmdbuf); + free(finaltoken); + + return rc ? rc : repeatable; +} + +static int cli_run_command_list(const char *cmd) +{ + return (cli_run_command(cmd, 0) < 0); +} + +/******************************************************************************/ + + +/* + * Run a command using the selected parser. + * + * @param cmd Command to run + * @param flag Execution flags (CMD_FLAG_...) + * @return 0 on success, or != 0 on error. + */ +int run_command(const char *cmd, int flag) +{ + /* + * cli_run_command can return 0 or 1 for success, so clean up + * its result. + */ + if (cli_run_command(cmd, flag) == -1) + return 1; + + return 0; +} + +/* + * Run a command using the selected parser, and check if it is repeatable. + * + * @param cmd Command to run + * @param flag Execution flags (CMD_FLAG_...) + * @return 0 (not repeatable) or 1 (repeatable) on success, -1 on error. + */ +static int run_command_repeatable(const char *cmd, int flag) +{ + return cli_run_command(cmd, flag); +} + +int run_command_list(const char *cmd, int len) +{ + (void) len; + + return cli_run_command_list(cmd); +} + +/****************************************************************************/ + +#define DYN_BUFFER 1 + +void cli_loop(void) +{ +#if DYN_BUFFER + char *lastcommand = NULL; +#else + static char lastcommand[CONFIG_SYS_CBSIZE]; +#endif + int len; + int flag; + int rc = 1; + + for (;;) { + len = cli_readline(PSTR(CONFIG_SYS_PROMPT)); + + flag = 0; /* assume no special flags for now */ + if (len > 0) { +#if DYN_BUFFER + lastcommand = (char *) xrealloc(lastcommand, len+1); + if (lastcommand != NULL) { + strncpy(lastcommand, console_buffer, len+1); + lastcommand[len] = '\0'; + } +#else + strcpy(lastcommand, console_buffer); +#endif + } else if (len == 0) + flag |= CMD_FLAG_REPEAT; + + if (len == -1) + my_puts_P(PSTR("<INTERRUPT>\n")); + else + rc = run_command_repeatable(lastcommand, flag); + + if (rc <= 0) { + /* invalid command or not repeatable, forget it */ +#if DYN_BUFFER + free(lastcommand); + lastcommand = NULL; +#else + lastcommand[0] = 0; +#endif + } + } +} + + +int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + int i; + (void) cmdtp; + + if (argc < 2) + return CMD_RET_USAGE; + + for (i = 1; i < argc; ++i) { + char *arg; + + arg = getenv(argv[i]); + if (arg == NULL) { + printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]); + return 1; + } + + if (run_command(arg, flag) != 0) + return 1; + } + return 0; +} + |