*/
#include "cli.h"
-#include "common.h"
-
-#include <string.h>
+#include "command.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"
#define debug_parser(fmt, args...) \
debug_cond(DEBUG_PARSER, fmt, ##args)
+
+static int_least8_t exec_flags;
+#define OPT_XTRACE 1
+#define OPT_VERBOSE 2
+
+static int_least8_t command_level;
+
+static void cli_trace_cmd(int_fast8_t level, int argc, char *argv[])
+{
+ while (level-- > 0)
+ putchar('+');
+ for (int_fast8_t i = 0; i < argc; i++)
+ printf_P(PSTR(" %s"), argv[i]);
+ putchar('\n');
+}
+
+
+
+
static int cli_parse_line(char *line, char *argv[])
{
uint_fast8_t state = 0;
}
static
-char *process_macros(char *input, char *output)
+char *process_macros(char *input)
{
- char c, prev, *inp, *outp;
+ char c, prev, *inp;
+ char *output = NULL;
+ char *outp = NULL;
const char *varname = NULL;
+ debug_parser("[PROCESS_MACROS] INPUT len %d: \"%s\"\n",
+ strlen(input), input);
+
for(uint_fast8_t pass = 0; pass < 2; pass++)
{
uint_fast8_t state = 0;
/* 2 = waiting for '}' */
/* 3 = waiting for ''' */
- if (pass == 0) {
+ if (pass > 0) {
+ size_t outputlen = outp - (char *) NULL;
+ output = (char *) malloc(outputlen);
+ if (output == NULL) {
+ printf_P(PSTR("** Can't process command: Out of memory! **\n"));
+ return NULL;
+ }
outp = output;
- } else {
- int outputlen = outp - output;
- outp = xrealloc(output, outputlen);
- output = outp;
}
inp = input;
- debug_parser("[PROCESS_MACROS] INPUT len %d: \"%s\"\n",
- strlen(inp), inp);
-
for (prev = '\0'; (c = *inp++) != '\0'; prev = c) {
if (c == '}') {
/* Terminate variable name */
*(inp-1) = '\0';
- const char *envval = getenv_char(varname);
+ const char *envval = getenv_str(varname);
*(inp-1) = '}';
/* Copy into the line if it exists */
if (envval != NULL)
* WARNING:
*
* We must create a temporary copy of the command since the command we get
- * may be the result from getenv_char(), which returns a pointer directly to
+ * may be the result from getenv_str(), 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).
*
* @returns
*
*/
-static int cli_run_command(const char *cmd, int flag)
+static int cli_run_command(const char *cmd, uint_fast8_t flag)
{
- char *cmdbuf; /* working copy of cmd */
+ char cmdbuf[strlen(cmd) + 1]; /* 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 */
uint_fast8_t inquotes, repeatable = 1;
int rc = 0;
+ exec_flags = 0;
+ char *optenv = getenv_str(PSTR("cli"));
+ if (optenv) {
+ if (strstr_P(optenv, PSTR("verbose")) != NULL)
+ exec_flags |= OPT_VERBOSE;
+ if (strstr_P(optenv, PSTR("xtrace")) != NULL)
+ exec_flags |= OPT_XTRACE;
+ }
+
debug_parser("[RUN_COMMAND] cmd[%p]=\"%s\"\n",
cmd, cmd ? cmd : "NULL");
- clear_ctrlc(); /* forget any previous Control C */
+ if (exec_flags & OPT_VERBOSE)
+ printf_P(PSTR("%s\n"), cmd, cmd ? cmd : "");
if (!cmd || !*cmd)
return -1; /* empty command */
- cmdbuf = strdup(cmd);
- if (!cmdbuf)
- return -1; /* not enough memory */
+ clear_ctrlc(); /* forget any previous Control C */
- str = cmdbuf;
+ str = strcpy(cmdbuf, cmd);
+ //str = cmdbuf;
+ ++command_level;
/* Process separators and check for invalid
* repeatable commands
*/
- debug_parser("[PROCESS_SEPARATORS] %s\n", cmd);
+ debug_parser("[PROCESS_SEPARATORS] \"%s\"\n", cmd);
while (*str) {
/*
* Find separator, or string end
*/
for (inquotes = 0, sep = str; *sep; sep++) {
if ((*sep == '\'') &&
- (sep != str) && /* past string start */
- (*(sep - 1) != '\\')) /* and NOT escaped */
+ (sep != str) && /* past string start */
+ (*(sep - 1) != '\\')) /* and NOT escaped */
inquotes = !inquotes;
if (!inquotes &&
- (*sep == ';' || *sep == '\n') && /* separator */
- (sep != str) && /* past string start */
- (*(sep - 1) != '\\')) /* and NOT escaped */
+ (*sep == ';' || *sep == '\n' /* separator */
+ || *sep == '#') && /* or start of comment */
+ ((sep == str) || /* string start */
+ (*(sep - 1) != '\\'))) /* or NOT escaped */
break;
}
- /*
- * Limit the token to data between separators
- */
+ /* no more commands after unescaped '#' token */
+ if (*sep == '#')
+ *sep = '\0';
+
+ /* Limit the token to data between separators */
token = str;
if (*sep) {
- str = sep + 1; /* start of command for next pass */
+ str = sep + 1; /* start of command for next pass */
*sep = '\0';
} else {
- str = sep; /* no more commands for next pass */
+ str = sep; /* no more commands for next pass */
}
+ while (isblank(*token))
+ ++token;
+ if (*token == '\0') /* empty (comment only) */
+ continue;
debug_parser("token: \"%s\"\n", token);
/* find macros in this token and replace them */
- finaltoken = process_macros(token, finaltoken);
+ finaltoken = process_macros(token);
+ if (finaltoken == NULL) {
+ rc = -1; /* no command at all */
+ continue;
+ }
/* Extract arguments */
argc = cli_parse_line(finaltoken, argv);
if (argc == 0) {
rc = -1; /* no command at all */
+ free(finaltoken);
continue;
}
- if (cmd_process(flag, argc, argv, &repeatable) != CMD_RET_SUCCESS)
+ if (exec_flags & OPT_XTRACE)
+ cli_trace_cmd(command_level, argc, argv);
+
+ rc = cmd_process(flag, argc, argv, &repeatable);
+ free(finaltoken);
+ if (rc != CMD_RET_SUCCESS) {
+ if (exec_flags & OPT_VERBOSE)
+ printf_P(PSTR("Command failed, result=%d\n"), rc);
rc = -1;
+ }
/* Did the user stop this? */
if (had_ctrlc()) {
}
}
- free(cmdbuf);
- free(finaltoken);
+ --command_level;
return rc ? rc : repeatable;
}
* @param flag Execution flags (CMD_FLAG_...)
* @return 0 on success, or != 0 on error.
*/
-int run_command(const char *cmd, int flag)
+int run_command(const char *cmd, uint_fast8_t flag)
{
/*
* cli_run_command can return 0 or 1 for success, so clean up
* @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)
+static int run_command_repeatable(const char *cmd, uint_fast8_t flag)
{
return cli_run_command(cmd, flag);
}
{
char *lastcommand = NULL;
int len;
- int flag;
+ uint_fast8_t flag;
int rc = 1;
for (;;) {
- len = cli_readline(PSTR(CONFIG_SYS_PROMPT), 1);
+ len = cli_readline(lastcommand ? PSTR(CONFIG_SYS_PROMPT_REPEAT) : PSTR(CONFIG_SYS_PROMPT), 1);
flag = 0; /* assume no special flags for now */
if (len > 0) {
} else if (len == 0)
flag |= CMD_FLAG_REPEAT;
- if (len == -1)
- my_puts_P(PSTR("<INTERRUPT>\n"));
- else
+ if (len == -1) {
+ if (exec_flags & OPT_VERBOSE)
+ my_puts_P(PSTR("<INTERRUPT>\n"));
+ } else
rc = run_command_repeatable(lastcommand, flag);
if (rc <= 0) {
projects / z180-stamp.git / blobdiff