#define DEBUG_CP 1 /* set to 1 to debug */
#define DEBUG_LS 1 /* set to 1 to debug */
+#define DEBUG_RM 1 /* set to 1 to debug */
+#define DEBUG_FA 1 /* set to 1 to debug */
#define debug_cp(fmt, args...) \
debug_cond(DEBUG_CP, fmt, ##args)
#define debug_ls(fmt, args...) \
debug_cond(DEBUG_LS, fmt, ##args)
+#define debug_rm(fmt, args...) \
+ debug_cond(DEBUG_RM, fmt, ##args)
+#define debug_fa(fmt, args...) \
+ debug_cond(DEBUG_FA, fmt, ##args)
+
/* TODO: use memory size test function (detect_ramsize() in cmd_loadihex.c) */
PATH_T from;
PATH_T to;
command_ret_t command_ret;
+char *cmdname;
+
+static uint8_t flags;
+#define F_FLAG (1<<3) // overwrite existing file ignoring write protection
+#define I_FLAG (1<<1) // prompt before overwrite (overrides a previous -n option)
+#define N_FLAG (1<<2) // do not overwrite an existing file (overrides a previous -i option)
+#define P_FLAG (1<<4) // preserve attributes and timestamps
+#define R_FLAG (1<<0) // copy directories recursively
+#define V_FLAG (1<<5) // explain what is being done
+
+
void setup_fatfs(void)
{
{
va_list ap;
va_start(ap, fmt);
-// (void)fprintf(stderr, "%s: ", progname);
- (void)vfprintf_P(stdout, fmt, ap);
+ printf_P(PSTR("fat %s: "), cmdname);
+ vfprintf_P(stdout, fmt, ap);
va_end(ap);
- (void)printf_P(PSTR("\n"));
+ printf_P(PSTR("\n"));
_delay_ms(20);
command_ret = CMD_RET_FAILURE;
}
to.p_path[0] = '\0'; to.p_end = to.p_path;
}
+static char *path_skip_heading(char *p)
+{
+ if ((p[0] & 0x38) == '0' && p[1] == ':') {
+ p += 2;
+ } else {
+ char *q = p;
+ if (*q++ == '.') {
+ if (*q == '.')
+ ++q;
+ if (*q == '\0' || *q == '/')
+ p = q;
+ }
+ return p;
+ }
+ if (*p == '/')
+ ++p;
+
+ return p;
+}
+
static void strip_trailing_slash(PATH_T *p)
{
- char *beg = p->p_path;
+ char *beg = path_skip_heading(p->p_path);
char *end = p->p_end;
- if ((beg + 2) < end && (*beg & 0x38) == '0' && *(beg+1) == ':')
- beg += 2;
- if (beg < end && *beg == '/')
- ++beg;
+
while (end > beg && end[-1] == '/')
*--end = '\0';
/* The "+ 1" accounts for the '/' between old path and name. */
if ((len + p->p_end - p->p_path + 1) > MAX_PATHLEN) {
err(PSTR("append: '%s/%s': name too long"), p->p_path, name);
- return(0);
+ return NULL;
}
/*
*p->p_end = '\0';
}
- (void)strncat(p->p_end, name, len);
+ strncat(p->p_end, name, len);
p->p_end += len;
*p->p_end = '\0';
return basename;
}
+#if 0
char *path_basename_pattern(PATH_T *p)
{
char *pattern = path_basename(p);
}
return pattern;
}
+#endif
+
+/*
+ * Split path
+ * Return basename/pattern of path.
+ */
+
+char *path_split_pattern(PATH_T *p)
+{
+ char *pp = path_skip_heading(p->p_path);
+ char *pattern = strrchr(pp, '/');
+
+ if (pattern == NULL) {
+ pattern = pp;
+ p->p_end = pattern;
+ } else {
+ p->p_end = pattern;
+ pattern++;
+ }
+ memmove(pattern+2, pattern, strlen(pattern)+1);
+ pattern += 2;
+ *p->p_end = '\0' ;
+
+ return pattern;
+}
+
+void path_fix(PATH_T *p)
+{
+ char *pp = path_skip_heading(p->p_path);
+
+ if (pp != p->p_end) {
+ *p->p_end++ = '/';
+ *p->p_end = '\0' ;
+ }
+}
+
+void path_unfix(PATH_T *p)
+{
+ char *pp = path_skip_heading(p->p_path);
+
+ if (pp != p->p_end) {
+ *--p->p_end = '\0' ;
+ }
+}
static void swirl(void)
{
command_ret_t do_pwd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
{
FRESULT res;
- char *buf;
- buf = (char *) malloc(BUFFER_SIZE);
- if (buf == NULL) {
- printf_P(PSTR("pwd: Out of Memory!\n"));
- free(buf);
- return CMD_RET_FAILURE;
- }
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
- res = f_getcwd(buf, BUFFER_SIZE); /* Get current directory path */
+ res = f_getcwd(from.p_path, MAX_PATHLEN); /* Get current directory path */
- if (!res) {
- puts(buf);
- }
- free(buf);
- if (res) {
- put_rc(res);
- return CMD_RET_FAILURE;
- }
- return CMD_RET_SUCCESS;
+ if (res == FR_OK)
+ puts(from.p_path);
+ else
+ err(PSTR("Error: %S"), rctostr(res));
+
+ return command_ret;
}
command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
char *arg;
- FRESULT res = 0;
+ FRESULT res = FR_OK;
+
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
if (argc < 2) {
arg = getenv_str(PSTR(ENV_HOME));
if (arg == NULL) {
- printf_P(PSTR("%s: \"%S\" is not set\n"), argv[0], PSTR(ENV_HOME));
- return CMD_RET_FAILURE;
+ err(PSTR("'%S' is not set"), PSTR(ENV_HOME));
+ return command_ret;
}
} else
arg = argv[1];
- if (arg[1] == ':') {
- char drv[3];
- drv[2] = '\0';
- drv[1] = ':';
- drv[0] = arg[0];
- res = f_chdrive(drv);
- }
- if (!res) {
+ if (arg[1] == ':')
+ res = f_chdrive(arg);
+ if (res == FR_OK)
res = f_chdir(arg);
- }
+ if (res != FR_OK)
+ err(PSTR("'%s': %S"), arg, rctostr(res));
- if (res) {
- put_rc(res);
- return CMD_RET_FAILURE;
- }
- return CMD_RET_SUCCESS;
+ return command_ret;
}
-#if 0
-/*
- * Remove trailing slashes,
- * but keep a leading slash (absolute path)
- */
-void strip_trailing_slash_relpath(char *p)
+
+static int decode_arg(const char *arg)
{
- int n = strlen(p);
+ BYTE attr = 0;
+ char c;
- if (n >= 2 && (p[0] & 0x38) == '0' && p[1] == ':') {
- p += 2;
- n -= 2;
- }
- if (n >= 1 && p[0] == '/') {
- p++;
- n--;
+ while ((c = *++arg) != '\0') {
+ switch (c) {
+ case 'a':
+ attr |= AM_ARC; /* Archive */
+ break;
+ case 'h':
+ attr |= AM_HID; /* Hidden */
+ break;
+ case 'r':
+ attr |= AM_RDO; /* Read only */
+ break;
+ case 's':
+ attr |= AM_SYS; /* System */
+ break;
+ default:
+ err(PSTR("unknown attribute: '%c'"), c);
+ return -1;
+ }
}
- while (n-- != 0 && p[n] == '/')
- p[n] = '\0';
+ return attr;
}
-#endif
-command_ret_t do_rm(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+static void print_attrib(char *path, FILINFO *f)
+{
+ printf_P(PSTR("%c%c%c%c%c %s%s\n"),
+ (f->fattrib & AM_DIR) ? 'D' : '-',
+ (f->fattrib & AM_RDO) ? 'R' : '-',
+ (f->fattrib & AM_HID) ? 'H' : '-',
+ (f->fattrib & AM_SYS) ? 'S' : '-',
+ (f->fattrib & AM_ARC) ? 'A' : '-',
+ path, f->fname);
+}
+
+command_ret_t do_attrib(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, UNUSED char * const argv[])
{
DIR Dir; /* Directory object */
FILINFO Finfo;
FRESULT res;
+ BYTE set_mask = 0;
+ BYTE clear_mask = 0;
- if (argc < 2)
- err("missing operand");
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
- for (int i = 1; i < argc; i++) {
- if (!path_set(&from, argv[1])) {
- /* TODO: error out*/
- }
- char *pattern = path_basename_pattern(&from);
- //debug_rm("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
+ for (;;) {
+ int attr;
+ char *arg = *++argv;
+
+ if (!arg)
+ return CMD_RET_USAGE;
+ if (arg[0] != '-' && arg[0] != '+')
+ break;
+ attr = decode_arg(arg);
+ if (attr < 0)
+ return CMD_RET_FAILURE;
+ if (arg[0] == '+')
+ set_mask |= attr;
+ else
+ clear_mask |= attr;
+ }
+ do {
+ if (!path_set(&from, *argv)) {
+ /* TODO: error out*/
+ }
+ char *pattern = path_split_pattern(&from);
+ if (*pattern == '\0')
+ pattern = "*";
+ debug_fa("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
- while (res == FR_OK && Finfo.fname[0]) {
- if (!(Finfo.fattrib & AM_DIR)) {
- if ((res = f_unlink(Finfo.fname)) != FR_OK) {
- put_rc(res);
- break;
+ debug_fa("==== findfirst %d\n", res);
+ if (res != FR_OK || !Finfo.fname[0]) {
+ path_fix(&from);
+ err(PSTR("'%s%s': No such file or directory"), from.p_path, pattern);
+ } else {
+ do {
+ if (set_mask | clear_mask) {
+ if ((res = f_chmod(Finfo.fname, set_mask, set_mask | clear_mask)) != FR_OK) {
+ path_fix(&from);
+ err(PSTR("'%s%s': %S"), from.p_path, Finfo.fname, rctostr(res));
+ path_unfix(&from);
+ }
+ } else {
+ path_fix(&from);
+ print_attrib(from.p_path, &Finfo);
+ path_unfix(&from);
}
- }
- res = f_findnext(&Dir, &Finfo);
+
+ res = f_findnext(&Dir, &Finfo);
+ //debug_fa("==== findnext %d\n", res);
+ } while (res == FR_OK && Finfo.fname[0]);
}
f_closedir(&Dir);
- }
+ } while (*++argv);
- if (res) {
- put_rc(res);
- return CMD_RET_FAILURE;
+ return command_ret;
+}
+
+command_ret_t do_rm(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+ DIR Dir; /* Directory object */
+ FILINFO Finfo;
+ FRESULT res;
+
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
+ /* reset getopt() */
+ optind = 0;
+ flags = 0;
+
+ int opt;
+ while ((opt = getopt(argc, argv, PSTR("nv"))) != -1) {
+ switch (opt) {
+ case 'n':
+ flags |= N_FLAG;
+ break;
+ case 'v':
+ flags |= V_FLAG;
+ break;
+ default:
+ return CMD_RET_USAGE;
+ break;
+ }
}
+ argc -= optind;
+ argv += optind;
- return CMD_RET_SUCCESS;
+ if (argc < 1) {
+ err(PSTR("missing operand"));
+ } else {
+ for (int i = 0; i < argc; i++) {
+ if (!path_set(&from, argv[i])) {
+ /* TODO: error out*/
+ }
+ char *pattern = path_split_pattern(&from);
+
+ debug_rm("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
+
+ res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+ debug_rm("==== findfirst %d\n", res);
+
+ if (res != FR_OK || !Finfo.fname[0]) {
+ path_fix(&from);
+ err(PSTR("cannot remove '%s%s': No such file or directory"), from.p_path, pattern);
+ } else {
+ do {
+ if (Finfo.fattrib & AM_DIR) {
+ path_fix(&from);
+ err(PSTR("cannot remove '%s%s': Is a directory"), from.p_path, Finfo.fname);
+ } else {
+ if (!(flags & N_FLAG)) {
+ if ((res = f_unlink(Finfo.fname)) == FR_OK) {
+ if (flags & V_FLAG)
+ path_fix(&from);
+ printf_P(PSTR("removed '%s%s'\n"), from.p_path, Finfo.fname);
+ path_unfix(&from);
+ } else {
+ path_fix(&from);
+ err(PSTR("cannot remove '%s%s': %S"), from.p_path, Finfo.fname, rctostr(res));
+ }
+ } else {
+ path_fix(&from);
+ printf_P(PSTR("not removed '%s%s'\n"), from.p_path, Finfo.fname);
+ path_unfix(&from);
+ }
+ }
+ res = f_findnext(&Dir, &Finfo);
+ //debug_rm("==== findnext %d\n", res);
+ } while (res == FR_OK && Finfo.fname[0]);
+ }
+ f_closedir(&Dir);
+ }
+
+ /* TODO */
+ if (res) {
+ put_rc(res);
+ return CMD_RET_FAILURE;
+ }
+ }
+ return command_ret;
}
command_ret_t do_rmdir(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
+ return command_ret;
}
command_ret_t do_mkdir(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
+ return command_ret;
}
-int print_dirent(FILINFO *f)
+static void print_dirent(FILINFO *f)
{
- return printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu %s\n"),
+ printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu %s\n"),
(f->fattrib & AM_DIR) ? 'D' : '-',
(f->fattrib & AM_RDO) ? 'R' : '-',
(f->fattrib & AM_HID) ? 'H' : '-',
unsigned int s1, s2;
FRESULT res;
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
path_init();
if (argc > 1)
if (!path_set(&from, argv[1])) {
/* TODO: error out*/
}
+#if 0
char *pattern = path_basename_pattern(&from);
-
+#else
+ char *pattern = path_split_pattern(&from);
+ if (*pattern == '\0')
+ pattern = "*";
+#endif
debug_ls("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
p1 = s1 = s2 = 0;
res = f_findfirst(&Dir, &Finfo, from.p_path, pattern); /* Start to search for files */
- while (res == FR_OK && Finfo.fname[0]) {
- if (Finfo.fattrib & AM_DIR) {
- s2++;
- } else {
- s1++; p1 += Finfo.fsize;
- }
- print_dirent(&Finfo);
- if (check_abort())
- break;
- res = f_findnext(&Dir, &Finfo);
+ if (res != FR_OK || !Finfo.fname[0]) {
+ path_fix(&from);
+ err(PSTR("'%s%s': No such file or directory"), from.p_path, pattern);
+ } else {
+ do {
+ if (Finfo.fattrib & AM_DIR) {
+ s2++;
+ } else {
+ s1++; p1 += Finfo.fsize;
+ }
+ print_dirent(&Finfo);
+ if (check_abort())
+ break;
+ res = f_findnext(&Dir, &Finfo);
+ } while (res == FR_OK && Finfo.fname[0]);
}
f_closedir(&Dir);
- if (res == FR_OK) {
+ if (res == FR_OK && command_ret == CMD_RET_SUCCESS) {
printf_P(PSTR("%4u File(s),%10lu bytes total\n%4u Dir(s)"), s1, p1, s2);
if (f_getfree(from.p_path, (DWORD*)&p1, &fs) == FR_OK)
printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2);
}
- if (res) {
+ if (res && command_ret == CMD_RET_SUCCESS) {
put_rc(res);
return CMD_RET_FAILURE;
}
- return CMD_RET_SUCCESS;
+ return command_ret;
}
/*
DIR Dir; /* Directory object */
FILINFO Finfo;
FRESULT res = FR_OK;
- char *path;
+ char *path = "";
+ char *pattern = "*";
printf_P(PSTR("sizeof DIR: %u, sizeof FIL: %u\n"), sizeof (DIR), sizeof (FILINFO));
char * buf = (char *) malloc(BUFFER_SIZE);
if (buf == NULL) {
printf_P(PSTR("tst: Out of Memory!\n"));
- free(buf);
return CMD_RET_FAILURE;
}
res = f_getcwd(buf, BUFFER_SIZE); /* Get current directory path */
if (argc > 1)
path = argv[1];
- else
- path = "";
+ if (argc > 2)
+ pattern = argv[2];
- printf_P(PSTR("arg: '%s'\n"), path);
+ printf_P(PSTR("arg: '%s' '%s'\n"), path, pattern);
printf_P(PSTR("==== f_stat: "));
res = f_stat(path, &Finfo);
put_rc(res);
}
printf_P(PSTR("==== f_findfirst: "));
- res = f_findfirst(&Dir, &Finfo, path, "*"); /* Start to search for files */
+ res = f_findfirst(&Dir, &Finfo, path, pattern); /* Start to search for files */
put_rc(res);
if (res == FR_OK) {
print_dirent(&Finfo);
/******************************************************************************/
-static uint8_t flags;
-#define F_FLAG (1<<3) // overwrite existing file ignoring write protection
-#define I_FLAG (1<<1) // prompt before overwrite (overrides a previous -n option)
-#define N_FLAG (1<<2) // do not overwrite an existing file (overrides a previous -i option)
-#define P_FLAG (1<<4) // preserve attributes and timestamps
-#define R_FLAG (1<<0) // copy directories recursively
-#define V_FLAG (1<<5) // explain what is being done
-
static void
setfile(FILINFO *fs)
{
static void copy();
-#if 0
-static void copy_dir(void)
-{
-debug_cp("==== copy_dir()");
-debug_cp(" from:'%s' to:'%s'\n", from->p_path, to.p_path);
-
- printf_P(PSTR("directory copy not supported, ommitting dir '%s'\n"),
- from->p_path);
- command_ret = CMD_RET_FAILURE;
-}
-#else
static void copy_dir(void)
{
DIR Dir; /* Directory object */
debug_cp("==== copy_dir(): freemem: %u\n", get_freemem());
debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
+#if 0
+
+ printf_P(PSTR("directory copy not supported, ommitting dir '%s'\n"),
+ from->p_path);
+ command_ret = CMD_RET_FAILURE;
+
+#else
for (res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
res == FR_OK && Finfo.fname[0];
}
}
#endif
-#if 0
-static void copy_dir(void)
-{
- FILINFO from_stat;
- struct dirent *dp, **dir_list;
- int dir_cnt, i;
- char *old_from, *old_to;
-
-debug_cp("==== copy_file(): dne: %u\n", dne, );
-debug_cp(" from:'%s' to:'%s'\n", from->p_path, to.p_path);
-
- dir_cnt = scandir(from->p_path, &dir_list, NULL, NULL);
- if (dir_cnt == -1) {
- (void)fprintf(stderr, "%s: can't read directory %s.\n",
- progname, from->p_path);
- command_ret = CMD_RET_FAILURE;
- }
-
- /*
- * Instead of handling directory entries in the order they appear
- * on disk, do non-directory files before directory files.
- * There are two reasons to do directories last. The first is
- * efficiency. Files tend to be in the same cylinder group as
- * their parent, whereas directories tend not to be. Copying files
- * all at once reduces seeking. Second, deeply nested tree's
- * could use up all the file descriptors if we didn't close one
- * directory before recursivly starting on the next.
- */
- /* copy files */
- for (i = 0; i < dir_cnt; ++i) {
- dp = dir_list[i];
- if (dp->d_namlen <= 2 && dp->d_name[0] == '.'
- && (dp->d_name[1] == NULL || dp->d_name[1] == '.'))
- goto done;
- if (!(old_from =
- path_append(&from, dp->d_name, (int)dp->d_namlen)))
- goto done;
-
- if (statfcn(from->p_path, &from_stat) < 0) {
- err(PSTR("%s: %s"), dp->d_name, strerror(errno));
- path_restore(&from, old_from);
- goto done;
- }
- if (S_ISDIR(from_stat.st_mode)) {
- path_restore(&from, old_from);
- continue;
- }
- if (old_to = path_append(&to, dp->d_name, (int)dp->d_namlen)) {
- copy();
- path_restore(&to, old_to);
- }
- path_restore(&from, old_from);
-done: dir_list[i] = NULL;
- free(dp);
- }
-
- /* copy directories */
- for (i = 0; i < dir_cnt; ++i) {
- dp = dir_list[i];
- if (!dp)
- continue;
- if (!(old_from =
- path_append(&from, dp->d_name, (int)dp->d_namlen))) {
- free(dp);
- continue;
- }
- if (!(old_to =
- path_append(&to, dp->d_name, (int)dp->d_namlen))) {
- free(dp);
- path_restore(&from, old_from);
- continue;
- }
- copy();
- free(dp);
- path_restore(&from, old_from);
- path_restore(&to, old_to);
- }
- free(dir_list);
-}
-#endif
/*
* copy file or directory at "from" to "to".
err(PSTR("%s: %S"), to.p_path, rctostr(fr));
return;
}
- }
- else if (!(to_stat.fattrib & AM_DIR)) {
+ } else if (!(to_stat.fattrib & AM_DIR)) {
(void)printf_P(PSTR("%s: not a directory.\n"), to.p_path);
return;
}
char *old_to;
+ cmdname = argv[0];
uint8_t tflags = 0;
command_ret = CMD_RET_SUCCESS;
#endif
-
-
-
-
/******************************************************************************/
/*
i = strlen(path);
while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) &&
statp->Finfo.fname[0]) {
- if (_FS_RPATH && statp->Finfo.fname[0] == '.')
+ if (FF_FS_RPATH && statp->Finfo.fname[0] == '.')
continue;
fn = statp->Finfo.fname;
if (statp->Finfo.fattrib & AM_DIR) {
"dev"
),
CMD_TBL_ITEM(
- pwd, 2, CTBL_RPT, do_pwd,
+ pwd, 1, CTBL_RPT, do_pwd,
"Print name of current/working directory",
""
),
+CMD_TBL_ITEM(
+ attrib, CONFIG_SYS_MAXARGS, 0, do_attrib,
+ "Display or change attributes on a FAT filesystem",
+ "[+-ahrs] files...\n"
+ "\n"
+ " - Clear attributes\n"
+ " + Set attributes\n"
+ " a Archive\n"
+ " h Hidden\n"
+ " r Read only\n"
+ " s System\n"
+ "Display only:\n"
+ " v Volume label\n"
+ " d Directory\n"
+),
CMD_TBL_ITEM(
cd, 2, 0, do_cd,
"Change the current/working directory.",
CMD_TBL_ITEM(
rm, CONFIG_SYS_MAXARGS, 0, do_rm,
"Remove FILE(s)",
- "[OPTION]... [FILE]..."
+ "[OPTION]... [FILE]...\n"
+ //" -i prompt before removal\n"
+ " -v explain what is being done\n"
+ "\n"
+ "rm does not remove directories."
),
CMD_TBL_ITEM(
rmdir, CONFIG_SYS_MAXARGS, 0, do_rmdir,
"path"
),
CMD_TBL_ITEM(
- tst, 2, CTBL_DBG|CTBL_RPT, do_tst,
+ tst, 3, CTBL_DBG|CTBL_RPT, do_tst,
"FatFS test function",
"path"
),
projects / z180-stamp.git / blobdiff