CFLAGS += -std=gnu99
CFLAGS += -Wall -Wextra
CFLAGS += -Wredundant-decls
-#CFLAGS += -fno-common -ffunction-sections -fdata-sections
+CFLAGS += -mrelax
+CFLAGS += -fno-common
+CFLAGS += -ffunction-sections
+CFLAGS += -fdata-sections
+CFLAGS += -fno-tree-loop-optimize
+CFLAGS += -fno-move-loop-invariants
+#CFLAGS += -flto
+CFLAGS += -fshort-enums
+
+#CFLAGS += -save-temps
+
+
#CFLAGS += -I $(INCLUDES)
CPPFLAGS += $(DEFS)
continue;
}
- if (cmd_process(flag, argc, argv, &repeatable))
+ if (cmd_process(flag, argc, argv, &repeatable) != CMD_RET_SUCCESS)
rc = -1;
/* Did the user stop this? */
}
-int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i;
(void) cmdtp;
arg = getenv(argv[i]);
if (arg == NULL) {
printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
- return 1;
+ return CMD_RET_FAILURE;
}
if (run_command(arg, flag) != 0)
- return 1;
+ return CMD_RET_FAILURE;
}
- return 0;
+ return CMD_RET_SUCCESS;
}
}
}
-int do_loadf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_loadf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
(void) cmdtp; (void) flag; (void) argc; (void) argv;
if (z80_bus_state() & ZST_RUNNING) {
printf_P(PSTR("## Can't load while CPU is running!\n"));
- return 1;
+ return CMD_RET_FAILURE;
}
z80_load_mem();
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_busreq_pulse(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_busreq_pulse(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint16_t count=1;
if (!(z80_bus_state() & ZST_RUNNING)) {
printf_P(PSTR("## CPU is not running!\n"));
- return 1;
+ return CMD_RET_FAILURE;
}
if (argc > 1)
while (count--)
z80_bus_cmd(M_Cycle);
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint32_t addr;
printf_P(PSTR("## Startaddress 0x%05lx too high.\n"
" (Out of logical address space (0x00000-0x0ffff))\n"),
addr);
- return 1;
+ return CMD_RET_FAILURE;
}
if (z80_bus_state() & ZST_RUNNING) {
printf_P(PSTR("## CPU allready running!\n"));
- return 1;
+ return CMD_RET_FAILURE;
}
printf_P(PSTR("## Starting application at 0x%04lx ...\n"), addr);
z80_bus_cmd(Release);
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
(void) cmdtp; (void) flag; (void) argc; (void) argv;
printf_P(PSTR("## CPU now in reset state.\n"));
z80_bus_cmd(Reset);
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_restart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_restart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
(void) cmdtp; (void) flag; (void) argc; (void) argv;
z80_bus_cmd(Restart);
- return 0;
+ return CMD_RET_SUCCESS;
}
#include "command.h"
-int do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint_fast8_t putnl = 1;
if (putnl)
putchar('\n');
- return 0;
+ return CMD_RET_SUCCESS;
}
#if 0
#include "common.h"
#include "command.h"
-int do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
const int len = cmd_tbl_item_count();
return _do_help(cmd_tbl, len, cmdtp, flag, argc, argv);
#define CONFIG_SYS_MEMTEST_SCRATCH 0
#endif
-static int mod_mem(cmd_tbl_t *, int, int, int, char * const []);
-
/* Display values from last command.
* Memory modify remembered values are different from display memory.
*/
* Syntax:
* md {addr} {len}
*/
-int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint32_t addr, length;
dp_last_addr = addr + length;
dp_last_length = length;
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+/* Modify memory.
+ *
+ * Syntax:
+ * mm {addr}
+ * nm {addr}
+ */
+static command_ret_t
+mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
+{
+ uint32_t addr;
+ uint8_t data;
+ int nbytes;
+
+ (void) cmdtp;
+
+ if (argc != 2)
+ return CMD_RET_USAGE;
+
+ /* We use the last specified parameters, unless new ones are
+ * entered.
+ */
+ addr = mm_last_addr;
+
+ if ((flag & CMD_FLAG_REPEAT) == 0) {
+ /* New command specified.
+ */
+
+ /* Address is specified since argc > 1
+ */
+ addr = strtoul(argv[1], NULL, 16);
+ addr += base_address;
+ }
+
+ /* Print the address, followed by value. Then accept input for
+ * the next value. A non-converted value exits.
+ */
+ do {
+ z80_bus_cmd(Request);
+ data = z80_read(addr);
+ printf("%05lx: %02x", addr, data);
+ z80_bus_cmd(Release);
+
+ nbytes = cli_readline(PSTR(" ? "));
+ if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
+ /* <CR> pressed as only input, don't modify current
+ * location and move to next. "-" pressed will go back.
+ */
+ if (incrflag)
+ addr += nbytes ? -1 : 1;
+ nbytes = 1;
+ }
+ else {
+ char *endp;
+ data = strtoul(console_buffer, &endp, 16);
+ nbytes = endp - console_buffer;
+ if (nbytes) {
+ z80_bus_cmd(Request);
+ z80_write(addr, data);
+ z80_bus_cmd(Release);
+ if (incrflag)
+ addr++;
+ }
+ }
+ } while (nbytes);
+
+ mm_last_addr = addr;
+ return CMD_RET_SUCCESS;
+}
+
+
+command_ret_t do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return mod_mem (cmdtp, 1, flag, argc, argv);
}
-int do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return mod_mem (cmdtp, 0, flag, argc, argv);
}
-int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint8_t writeval;
uint32_t addr, count;
}
z80_bus_cmd(Release);
- return 0;
+ return CMD_RET_SUCCESS;
}
#ifdef CONFIG_MX_CYCLIC
-int do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i;
uint32_t count;
/* check for ctrl-c to abort... */
if (ctrlc()) {
my_puts("Abort\n");
- return 0;
+ return CMD_RET_SUCCESS;
}
}
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i;
uint32_t count;
/* check for ctrl-c to abort... */
if (ctrlc()) {
my_puts("Abort\n");
- return 0;
+ return CMD_RET_SUCCESS;
}
}
- return 0;
+ return CMD_RET_SUCCESS;
}
#endif /* CONFIG_MX_CYCLIC */
-int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint32_t addr1, addr2, count, ngood;
- int rcode = 0;
+ command_ret_t rcode = CMD_RET_SUCCESS;
uint8_t byte1, byte2;
(void) cmdtp;
printf( "byte at 0x%05lx (%#02x) != "
"byte at 0x%05lx (%#02x)\n",
addr1, byte1, addr2, byte2);
- rcode = 1;
+ rcode = CMD_RET_FAILURE;
break;
}
addr1++;
/* check for ctrl-c to abort... */
if (ctrlc()) {
my_puts("Abort\n");
- return 0;
+ return CMD_RET_SUCCESS;
}
}
return rcode;
}
-int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint32_t src, dest, count;
int_fast8_t step;
if (count == 0) {
my_puts ("Zero length ???\n");
- return 1;
+ return CMD_RET_FAILURE;
}
if (dest > src) {
/* check for ctrl-c to abort... */
if (ctrlc()) {
my_puts("Abort\n");
- return 0;
+ return CMD_RET_SUCCESS;
}
}
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
+command_ret_t do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
(void) cmdtp;
}
/* Print the current base address. */
printf("Base Address: 0x%05lx\n", base_address);
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
+command_ret_t do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
uint32_t addr, length;
}
z80_bus_cmd(Release);
- return 0;
+ return CMD_RET_SUCCESS;
}
#ifdef CONFIG_LOOPW
-int do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint32_t addr, length;
uint8_t data;
* configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
* interrupted by ctrl-c or by a failure of one of the sub-tests.
*/
-int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
+command_ret_t do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
uint32_t start, end;
vu_long *buf, *dummy;
int iteration_limit;
+/* TODO: command_ret_t */
int ret;
uint32_t errs = 0; /* number of errors, or -1 if interrupted */
uint32_t pattern;
}
#endif /* CONFIG_CMD_MEMTEST */
-/* Modify memory.
- *
- * Syntax:
- * mm {addr}
- * nm {addr}
- */
-static int
-mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
-{
- uint32_t addr;
- uint8_t data;
- int nbytes;
-
- (void) cmdtp;
-
- if (argc != 2)
- return CMD_RET_USAGE;
-
- /* We use the last specified parameters, unless new ones are
- * entered.
- */
- addr = mm_last_addr;
-
- if ((flag & CMD_FLAG_REPEAT) == 0) {
- /* New command specified.
- */
-
- /* Address is specified since argc > 1
- */
- addr = strtoul(argv[1], NULL, 16);
- addr += base_address;
- }
-
- /* Print the address, followed by value. Then accept input for
- * the next value. A non-converted value exits.
- */
- do {
- z80_bus_cmd(Request);
- data = z80_read(addr);
- printf("%05lx: %02x", addr, data);
- z80_bus_cmd(Release);
-
- nbytes = cli_readline(PSTR(" ? "));
- if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
- /* <CR> pressed as only input, don't modify current
- * location and move to next. "-" pressed will go back.
- */
- if (incrflag)
- addr += nbytes ? -1 : 1;
- nbytes = 1;
- }
- else {
- char *endp;
- data = strtoul(console_buffer, &endp, 16);
- nbytes = endp - console_buffer;
- if (nbytes) {
- z80_bus_cmd(Request);
- z80_write(addr, data);
- z80_bus_cmd(Release);
- if (incrflag)
- addr++;
- }
- }
- } while (nbytes);
-
- mm_last_addr = addr;
- return 0;
-}
-
#include "cmd_mem.h"
-extern int do_mem_md(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_mm(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_nm(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_mw(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_cp(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_cmp(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_base(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_loop(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_md(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mm(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_nm(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mw(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_cp(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_cmp(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_base(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_loop(cmd_tbl_t *, int, int, char * const []);
#ifdef CONFIG_LOOPW
-extern int do_mem_loopw(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_loopw(cmd_tbl_t *, int, int, char * const []);
#endif
#ifdef CONFIG_CMD_MEMTEST
-extern int do_mem_mtest(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mtest(cmd_tbl_t *, int, int, char * const []);
#endif
#ifdef CONFIG_MX_CYCLIC
-extern int do_mem_mdc(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_mwc(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mdc(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mwc(cmd_tbl_t *, int, int, char * const []);
#endif /* CONFIG_MX_CYCLIC */
#endif /* CMD_MEM_H */
* for long help messages
*/
-int _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp,
+command_ret_t _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp,
int flag, int argc, char * const argv[])
{
uint_fast8_t i;
- int rcode = 0;
+ command_ret_t rcode = CMD_RET_SUCCESS;
(void) flag;
/* allow user abort */
if (ctrlc ())
- return 1;
+ return CMD_RET_FAILURE;
if (usage == NULL)
continue;
#ifdef GCC_BUG_61443
cmd_array[i]->name, usage);
#endif
}
- return 0;
+ return CMD_RET_SUCCESS;
}
/*
* command help (long version)
*/
for (i = 1; i < argc; ++i) {
if ((cmdtp = find_cmd_tbl (argv[i], cmd_start, cmd_items )) != NULL) {
- rcode |= cmd_usage(cmdtp);
+ rcode = cmd_usage(cmdtp);
} else {
printf_P(PSTR("Unknown command '%s' - try 'help'"
" without arguments.\n\n"), argv[i]
);
- rcode = 1;
+ rcode = CMD_RET_FAILURE;
}
}
return rcode;
}
-int cmd_usage(const FLASH cmd_tbl_t *cmdtp)
+command_ret_t cmd_usage(const FLASH cmd_tbl_t *cmdtp)
{
// printf("%s - %s\n\n", cmdtp->name, cmdtp->usage);
print_usage_line(cmdtp->name, cmdtp->usage);
if (!cmdtp->help) {
my_puts_P(PSTR(" - No additional help available.\n"));
- return 1;
+ return CMD_RET_FAILURE;
}
my_puts_P(cmdtp->help);
my_puts_P(PSTR("\n"));
#endif /* CONFIG_SYS_LONGHELP */
- return 1;
+ return CMD_RET_FAILURE;
}
#ifdef CONFIG_AUTO_COMPLETE
* @param argv Arguments
* @return 0 if command succeeded, else non-zero (CMD_RET_...)
*/
-static int cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
- int result;
+ command_ret_t result;
result = (cmdtp->cmd)(cmdtp, flag, argc, argv);
- if (result)
+ if (result != CMD_RET_SUCCESS)
debug("Command failed, result=%d\n", result);
return result;
}
-enum command_ret_t cmd_process(int flag, int argc, char * const argv[],
+command_ret_t cmd_process(int flag, int argc, char * const argv[],
uint_fast8_t *repeatable)
{
- enum command_ret_t rc = CMD_RET_SUCCESS;
+ command_ret_t rc = CMD_RET_SUCCESS;
cmd_tbl_t *cmdtp;
/* Look up command in command table */
cmdtp = find_cmd(argv[0]);
if (cmdtp == NULL) {
printf_P(PSTR("Unknown command '%s' - try 'help'\n"), argv[0]);
- return 1;
+ return CMD_RET_FAILURE;
}
if (!cmdtp->cmd) {
debug("### Command '%s' found, but ->cmd == NULL \n", argv[0]);
- return 1;
+ return CMD_RET_FAILURE;
}
/* found - check max args */
#define CONFIG_SYS_HELP_CMD_WIDTH 8
#endif
+/*
+ * Error codes that commands return to cmd_process(). We use the standard 0
+ * and 1 for success and failure, but add one more case - failure with a
+ * request to call cmd_usage(). But the cmd_process() function handles
+ * CMD_RET_USAGE itself and after calling cmd_usage() it will return 1.
+ * This is just a convenience for commands to avoid them having to call
+ * cmd_usage() all over the place.
+ */
+typedef enum {
+ CMD_RET_SUCCESS, /* 0 = Success */
+ CMD_RET_FAILURE, /* 1 = Failure */
+ CMD_RET_USAGE = -1, /* Failure, please report 'usage' error */
+} command_ret_t;
+
/*
* Monitor Command Table
*/
int maxargs; /* maximum number of arguments */
int repeatable; /* autorepeat allowed? */
/* Implementation function */
- int (*cmd)(const FLASH struct cmd_tbl_s *, int, int, char * const []);
+ command_ret_t (*cmd)(const FLASH struct cmd_tbl_s *, int, int, char * const []);
const FLASH char *usage; /* Usage message (short) */
#ifdef CONFIG_SYS_LONGHELP
const FLASH char *help; /* Help message (long) */
typedef const FLASH struct cmd_tbl_s cmd_tbl_t;
-extern int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern command_ret_t do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+
+/**
+ * Process a command with arguments. We look up the command and execute it
+ * if valid. Otherwise we print a usage message.
+ *
+ * @param flag Some flags normally 0 (see CMD_FLAG_.. above)
+ * @param argc Number of arguments (arg 0 must be the command text)
+ * @param argv Arguments
+ * @param repeatable This function sets this to 0 if the command is not
+ * repeatable. If the command is repeatable, the value
+ * is left unchanged.
+ * @return 0 if the command succeeded, 1 if it failed
+ */
+command_ret_t
+cmd_process(int flag, int argc, char * const argv[], uint_fast8_t *repeatable);
+
/* command.c */
-int _do_help (cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp, int
+command_ret_t _do_help (cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp, int
flag, int argc, char * const argv[]);
cmd_tbl_t *find_cmd(const char *cmd);
cmd_tbl_t *find_cmd_tbl (const char *cmd, cmd_tbl_t *table, int table_len);
int cmd_tbl_item_count(void);
-int cmd_usage(cmd_tbl_t *cmdtp);
+command_ret_t cmd_usage(cmd_tbl_t *cmdtp);
#ifdef CONFIG_AUTO_COMPLETE
extern int var_complete(int argc, char * const argv[], char last_char, int maxv, char *cmdv[]);
#ifdef CONFIG_CMD_BOOTD
-extern int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern command_ret_t do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
#endif
#ifdef CONFIG_CMD_BOOTM
-extern int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern command_ret_t do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
extern int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd);
#else
static inline int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
extern int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
char *const argv[]);
-extern int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-
-/*
- * Error codes that commands return to cmd_process(). We use the standard 0
- * and 1 for success and failure, but add one more case - failure with a
- * request to call cmd_usage(). But the cmd_process() function handles
- * CMD_RET_USAGE itself and after calling cmd_usage() it will return 1.
- * This is just a convenience for commands to avoid them having to call
- * cmd_usage() all over the place.
- */
-enum command_ret_t {
- CMD_RET_SUCCESS, /* 0 = Success */
- CMD_RET_FAILURE, /* 1 = Failure */
- CMD_RET_USAGE = -1, /* Failure, please report 'usage' error */
-};
-
-/**
- * Process a command with arguments. We look up the command and execute it
- * if valid. Otherwise we print a usage message.
- *
- * @param flag Some flags normally 0 (see CMD_FLAG_.. above)
- * @param argc Number of arguments (arg 0 must be the command text)
- * @param argv Arguments
- * @param repeatable This function sets this to 0 if the command is not
- * repeatable. If the command is repeatable, the value
- * is left unchanged.
- * @return 0 if the command succeeded, 1 if it failed
- */
-int cmd_process(int flag, int argc, char * const argv[], uint_fast8_t *repeatable);
-
+extern command_ret_t do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
/*
* Command Flags:
CMD_TBL_ITEM_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, NULL)
-typedef int (*do_cmd_t)(cmd_tbl_t *, int, int, char * const []);
+typedef command_ret_t (*do_cmd_t)(cmd_tbl_t *, int, int, char * const []);
extern cmd_tbl_t cmd_tbl[];
#include "cmd_mem.h"
-extern int do_help(cmd_tbl_t *, int, int, char * const []);
-extern int do_echo(cmd_tbl_t *, int, int, char * const []);
-extern int do_env_print(cmd_tbl_t *, int, int, char * const []);
-extern int do_env_set(cmd_tbl_t *, int, int, char * const []);
-extern int do_env_save(cmd_tbl_t *, int, int, char * const []);
-extern int do_loadf(cmd_tbl_t *, int, int, char * const []);
-extern int do_go(cmd_tbl_t *, int, int, char * const []);
-extern int do_restart(cmd_tbl_t *, int, int, char * const []);
-extern int do_dump_mem(cmd_tbl_t *, int, int, char * const []);
-extern int do_eep_cp(cmd_tbl_t *, int, int, char * const []);
-extern int do_busreq_pulse(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_help(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_echo(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_env_print(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_env_set(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_env_save(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_loadf(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_go(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_restart(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_dump_mem(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_eep_cp(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_busreq_pulse(cmd_tbl_t *, int, int, char * const []);
cmd_tbl_t cmd_tbl[] = {
* EEPROM Display
* md addr {len}
*/
-int do_dump_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_dump_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
// static const uint8_t *addr;
// static uint16_t length = 128;
/* Print the lines. */
dump_mem(addr, length, readhow, NULL);
- return 0;
+ return CMD_RET_SUCCESS;
}
-int do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint16_t src, dest, count;
int_fast8_t step;
if (src > E2END) {
debug("src > EEPROM size: 0x%04x\n", src);
- return 1;
+ return CMD_RET_FAILURE;
}
if (dest > E2END) {
debug("dest > EEPROM size: 0x%04x\n", dest);
- return 1;
+ return CMD_RET_FAILURE;
}
if (count > E2END+1) {
debug("count > EEPROM size: 0x%04x\n", count);
- return 1;
+ return CMD_RET_FAILURE;
}
if (count == 0) {
debug("Zero length ???\n");
- return 1;
+ return CMD_RET_FAILURE;
}
if (dest > src) {
dest += step;
}
- return 0;
+ return CMD_RET_SUCCESS;
}
#endif /* DEBUG */
}
-int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
- int i;
- int rcode = 0;
+ command_ret_t rc = CMD_RET_SUCCESS;
(void) cmdtp; (void) flag;
if (argc == 1) {
/* print all env vars */
- rcode = env_print(NULL);
- if (rcode < 0)
- return 1;
+ int size = env_print(NULL);
+ if (size < 0)
+ return CMD_RET_FAILURE;
printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
- rcode, ENV_SIZE);
+ size, ENV_SIZE);
env_print_ramsize();
- return 0;
+ return CMD_RET_SUCCESS;
}
/* print selected env vars */
- for (i = 1; i < argc; ++i) {
+ for (int i = 1; i < argc; ++i) {
int rc = env_print(argv[i]);
if (rc < 0) {
printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
- ++rcode;
+ rc = CMD_RET_FAILURE;
}
}
- return rcode;
+ return rc;
}
* @return 0 if ok, 1 on error
*/
static
-int _do_env_set(int flag, int argc, char * const argv[])
+command_ret_t _do_env_set(int flag, int argc, char * const argv[])
{
int i, len;
char *name, *value, *s;
if (strchr(name, '=')) {
printf_P(PSTR("## Error: illegal character '='"
"in variable name \"%s\"\n"), name);
- return 1;
+ return CMD_RET_FAILURE;
}
if (strlen(name) > CONFIG_SYS_ENV_NAMELEN) {
printf_P(PSTR("## Error: Variable name \"%s\" too long. "
"(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
- return 1;
+ return CMD_RET_FAILURE;
}
/*
env_id++;
/* Delete only ? */
if (argc < 3 || argv[2] == NULL) {
int rc = envlist_delete(name);
- return rc != 0;
+ return rc ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
/*
value = xmalloc(len);
if (value == NULL) {
printf_P(PSTR("## Can't malloc %d bytes\n"), len);
- return 1;
+ return CMD_RET_FAILURE;
}
for (i = 2, s = value; i < argc; ++i) {
char *v = argv[i];
if (!ep) {
printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
name);
- return 1;
+ return CMD_RET_FAILURE;
}
- return 0;
+ return CMD_RET_SUCCESS;
}
/**
if (varvalue == NULL || varvalue[0] == '\0')
--argc;
- return _do_env_set(0, argc, (char * const *)argv);
+ return (int) _do_env_set(0, argc, (char * const *)argv);
}
#if 0
return value;
}
-int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
(void) cmdtp;
}
-int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
(void) cmdtp; (void) flag; (void) argc; (void) argv;
printf_P(PSTR("Saving Environment ...\n"));
- return saveenv() ? 1 : 0;
+ return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
#if defined(CONFIG_AUTO_COMPLETE)
/ FatFs supports only BMP. */\r
\r
\r
-#define _FS_RPATH 0 /* 0 to 2 */\r
+#define _FS_RPATH 2 /* 0 to 2 */\r
/* The _FS_RPATH option configures relative path feature.\r
/\r
/ 0: Disable relative path feature and remove related functions.\r
*/\r
\r
\r
-#define _WORD_ACCESS 0 /* 0 or 1 */\r
+#define _WORD_ACCESS 1 /* 0 or 1 */\r
/* The _WORD_ACCESS option is an only platform dependent option. It defines\r
/ which access method is used to the word data on the FAT volume.\r
/\r
projects / z180-stamp.git / commitdiff