static int red_cmd(char *cmd) {
char *arg = cmd+1;
SKIPSPACES(arg);
switch(*cmd) {
case 'q':
return 0;
case ';':
case '#':
break; // comment
case '>':
return cmd_dump(arg);
break;
case '<':
return cmd_load(arg);
break;
case '.':
return red_interpret(arg);
break;
case 's':
return cmd_seek(arg);
break;
case 'b':
return cmd_bsize(arg);
break;
case '/':
return cmd_search(arg);
break;
case 'd':
return cmd_system ("echo X | ired -n $BLOCK | rasm2 -o $OFFSET -D - |head -n $(($LINES-1))");
case 'p':
return cmd_print(arg);
break;
case 'r':
return cmd_resize(arg);
break;
case 'x':
return cmd_hexdump(arg);
break;
case 'X':
return cmd_bytedump(arg);
break;
case 'w':
return cmd_write(arg);
break;
case '!':
return cmd_system(arg);
break;
case 'V':
return cmd_system("vired $FILE");
break;
case '?':
return cmd_help(arg);
break;
default:
fprintf(stderr, "? %s\n", cmd);
}
return 1;
}
static void do_diagnosis_cmds(int argc, char *argv[])
{
struct cmd * cmd;
if (argc < 2) {
diagnosis_usage("too few arguments");
return;
}
if ((cmd = cmd_search(__DIAGNOSIS_cmds_TAB__,
&__DIAGNOSIS_cmds_TAB_END__,
argv[1])) != (struct cmd *)0) {
(cmd->fun)(argc, argv);
return;
}
diagnosis_usage("unrecognized command");
}
int recursive_execute(int argc, const char * const * argv, const ShellCmd_t *cmdarray){
int i = 0;
/* search first token */
i = cmd_search(argv[0], cmdarray);
/* search token in cmd array */
if (i != -1){
if (argc > 1)
current_cmd_tp = cmdarray[i].func(argc - 1, &argv[1], cmdarray);
else
current_cmd_tp = cmdarray[i].func(argc - 1, NULL, cmdarray);
}
return i;
}
static void
do_fs(int argc, char *argv[])
{
struct cmd *cmd;
if (argc < 2) {
fs_usage("too few arguments");
return;
}
if ((cmd = cmd_search(__FS_cmds_TAB__, &__FS_cmds_TAB_END__,
argv[1])) != (struct cmd *)0) {
(cmd->fun)(argc-1, argv+1);
return;
}
fs_usage("unrecognized command");
}
int redboot_exec( char *command, ... )
{
int argc;
char *argv[ARGV_MAX+1];
va_list ap;
struct cmd *cmd;
int result = 0;
va_start(ap, command);
argv[0] = command;
for( argc = 1; argc < ARGV_MAX; argc++ )
{
char *arg = va_arg(ap, char *);
if( arg == 0 )
break;
argv[argc] = arg;
}
argv[argc] = NULL;
if(( cmd = cmd_search(__RedBoot_CMD_TAB__, &__RedBoot_CMD_TAB_END__, command) ))
{
// Try to handle aborts - messy because of the stack unwinding...
#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
__mem_fault_handler = error_handler;
#endif
redboot_exec_call = true;
if (hal_setjmp(error_jmpbuf))
result = -1;
else
(cmd->fun)(argc, argv);
redboot_exec_call = false;
#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
__mem_fault_handler = 0;
#endif
}
else
result = -1;
va_end(ap);
return result;
}
static void
do_fis(int argc, char *argv[])
{
struct cmd *cmd;
if (argc < 2) {
fis_usage("too few arguments");
return;
}
if (!do_flash_init()) {
diag_printf("Sorry, no FLASH memory is available\n");
return;
}
if ((cmd = cmd_search(__FIS_cmds_TAB__, &__FIS_cmds_TAB_END__,
argv[1])) != (struct cmd *)0) {
(cmd->fun)(argc, argv);
return;
}
fis_usage("unrecognized command");
}
//
// Scan through an input line and break it into "arguments". These
// are space delimited strings. Return a structure which points to
// the strings, similar to a Unix program. Multiple commands in the line
// are separated by ; similar to sh. If we find a semi we stop processing the
// line, terminate the current command with a null and return the start
// of the next command in *line. parse() can then be called again to
// process the next command on the line.
// Note: original input is destroyed by replacing the delimiters with
// null ('\0') characters for ease of use.
//
struct cmd *
parse(char **line, int *argc, char **argv)
{
char *cp = *line;
char *pp;
int indx = 0;
int semi = 0;
while (*cp) {
// Skip leading spaces
while (*cp && *cp == ' ') cp++;
if (!*cp) {
break; // Line ended with a string of spaces
}
if (*cp == ';') {
*cp = '\0';
semi=1;
break;
}
if (indx < MAX_ARGV) {
argv[indx++] = cp;
} else {
diag_printf("Too many arguments - stopped at: '%s'\n", cp);
}
while (*cp) {
if (*cp == ' ') {
*cp++ = '\0';
break;
} else if (*cp == ';') {
break;
} else if (*cp == '"') {
// Swallow quote, scan till following one
if (argv[indx-1] == cp) {
argv[indx-1] = ++cp;
}
pp = cp;
while (*cp && *cp != '"') {
if (*cp == '\\') {
// Skip over escape - allows for escaped '"'
cp++;
}
// Move string to swallow escapes
*pp++ = *cp++;
}
if (!*cp) {
diag_printf("Unbalanced string!\n");
} else {
if (pp != cp) *pp = '\0';
*cp++ = '\0';
break;
}
} else {
cp++;
}
}
}
if (semi) {
*line = cp + 1;
} else {
*line = cp;
}
*argc = indx;
return cmd_search(__RedBoot_CMD_TAB__, &__RedBoot_CMD_TAB_END__, argv[0]);
}
