diff options
Diffstat (limited to 'avr/cli.c')
-rw-r--r-- | avr/cli.c | 353 |
1 files changed, 353 insertions, 0 deletions
diff --git a/avr/cli.c b/avr/cli.c new file mode 100644 index 0000000..b310f79 --- /dev/null +++ b/avr/cli.c @@ -0,0 +1,353 @@ +#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 append_char(uint_fast8_t pass, char **p, char c) +{ + + if (pass) { + **p = c; + } + ++(*p); +} + +static +char *process_macros(char *input, char *output) +{ + char c, prev, *inp, *outp; + const char *varname = NULL; + + for(uint_fast8_t pass = 0; pass < 2; pass++) + { + uint_fast8_t state = 0; /* 0 = waiting for '$' */ + /* 1 = waiting for '{' */ + /* 2 = waiting for '}' */ + /* 3 = waiting for ''' */ + + if (pass == 0) { + outp = output; + } else { + int outputlen = outp - output; + outp = xrealloc(output, outputlen); + output = outp; + } + + inp = input; + prev = '\0'; /* previous character */ + + debug_parser("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen(inp), + inp); + + while ((c = *inp++) != '\0') { + + if (state != 3) { + /* remove one level of escape characters */ + if ((c == '\\') && (prev != '\\')) { + if (*inp == '\0') + break; + prev = c; + c = *inp++; + } + } + + switch (state) { + case 0: /* Waiting for (unescaped) $ */ + if ((c == '\'') && (prev != '\\')) { + state = 3; + break; + } + if ((c == '$') && (prev != '\\')) + state++; + else + append_char(pass, &outp, c); + break; + case 1: /* Waiting for { */ + if (c == '{') { + state++; + varname = inp; + } else { + state = 0; + append_char(pass, &outp, '$'); + append_char(pass, &outp, c); + } + break; + case 2: /* Waiting for } */ + if (c == '}') { + /* Terminate variable name */ + *(inp-1) = '\0'; + const char *envval = getenv(varname); + *(inp-1) = '}'; + /* Copy into the line if it exists */ + if (envval != NULL) + while (*envval) + append_char(pass, &outp, *(envval++)); + /* Look for another '$' */ + state = 0; + } + break; + case 3: /* Waiting for ' */ + if ((c == '\'') && (prev != '\\')) + state = 0; + else + append_char(pass, &outp, c); + break; + } + prev = c; + } + + append_char(pass, &outp, 0); + } + + debug_parser("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n", + strlen(output), output); + + return output; +} + +/** + * + * + * 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). + * + * + * @param cmd + * @param flag + * @returns + * + */ +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 = NULL; /* token after macro expansion */ + 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 = strdup(cmd); + if (!cmdbuf) + return -1; /* not enough memory */ + + 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 */ + finaltoken = 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) != CMD_RET_SUCCESS) + 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); +} + +/****************************************************************************/ + + +void cli_loop(void) +{ + char *lastcommand = NULL; + 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) { + free (lastcommand); + lastcommand = strdup(console_buffer); + } 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 */ + free(lastcommand); + lastcommand = NULL; + } + } +} + + +command_ret_t 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 CMD_RET_FAILURE; + } + + if (run_command(arg, flag) != 0) + return CMD_RET_FAILURE; + } + return CMD_RET_SUCCESS; +} + |