wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 1 | /* |
Detlev Zundel | 2dce551 | 2009-03-25 17:27:52 +0100 | [diff] [blame] | 2 | * (C) Copyright 2000-2009 |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
| 4 | * |
| 5 | * See file CREDITS for list of people who contributed to this |
| 6 | * project. |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or |
| 9 | * modify it under the terms of the GNU General Public License as |
| 10 | * published by the Free Software Foundation; either version 2 of |
| 11 | * the License, or (at your option) any later version. |
| 12 | * |
| 13 | * This program is distributed in the hope that it will be useful, |
| 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 16 | * GNU General Public License for more details. |
| 17 | * |
| 18 | * You should have received a copy of the GNU General Public License |
| 19 | * along with this program; if not, write to the Free Software |
| 20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, |
| 21 | * MA 02111-1307 USA |
| 22 | */ |
| 23 | |
| 24 | /* |
| 25 | * Command Processor Table |
| 26 | */ |
| 27 | |
| 28 | #include <common.h> |
| 29 | #include <command.h> |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 30 | |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 31 | /* |
| 32 | * Use puts() instead of printf() to avoid printf buffer overflow |
| 33 | * for long help messages |
| 34 | */ |
Detlev Zundel | 2dce551 | 2009-03-25 17:27:52 +0100 | [diff] [blame] | 35 | |
| 36 | int _do_help (cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp, int |
| 37 | flag, int argc, char *argv[]) |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 38 | { |
| 39 | int i; |
| 40 | int rcode = 0; |
| 41 | |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 42 | if (argc == 1) { /*show list of commands */ |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 43 | cmd_tbl_t *cmd_array[cmd_items]; |
| 44 | int i, j, swaps; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 45 | |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 46 | /* Make array of commands from .uboot_cmd section */ |
Detlev Zundel | 2dce551 | 2009-03-25 17:27:52 +0100 | [diff] [blame] | 47 | cmdtp = cmd_start; |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 48 | for (i = 0; i < cmd_items; i++) { |
| 49 | cmd_array[i] = cmdtp++; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 50 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 51 | |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 52 | /* Sort command list (trivial bubble sort) */ |
| 53 | for (i = cmd_items - 1; i > 0; --i) { |
| 54 | swaps = 0; |
| 55 | for (j = 0; j < i; ++j) { |
| 56 | if (strcmp (cmd_array[j]->name, |
| 57 | cmd_array[j + 1]->name) > 0) { |
| 58 | cmd_tbl_t *tmp; |
| 59 | tmp = cmd_array[j]; |
| 60 | cmd_array[j] = cmd_array[j + 1]; |
| 61 | cmd_array[j + 1] = tmp; |
| 62 | ++swaps; |
| 63 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 64 | } |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 65 | if (!swaps) |
| 66 | break; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | /* print short help (usage) */ |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 70 | for (i = 0; i < cmd_items; i++) { |
| 71 | const char *usage = cmd_array[i]->usage; |
| 72 | |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 73 | /* allow user abort */ |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 74 | if (ctrlc ()) |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 75 | return 1; |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 76 | if (usage == NULL) |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 77 | continue; |
Peter Tyser | 2fb2604 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 78 | printf("%-*s- %s\n", CONFIG_SYS_HELP_CMD_WIDTH, |
| 79 | cmd_array[i]->name, usage); |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 80 | } |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 81 | return 0; |
| 82 | } |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 83 | /* |
| 84 | * command help (long version) |
| 85 | */ |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 86 | for (i = 1; i < argc; ++i) { |
Detlev Zundel | 2dce551 | 2009-03-25 17:27:52 +0100 | [diff] [blame] | 87 | if ((cmdtp = find_cmd_tbl (argv[i], cmd_start, cmd_items )) != NULL) { |
Wolfgang Denk | 94796d8 | 2009-05-24 19:17:29 +0200 | [diff] [blame] | 88 | rcode |= cmd_usage(cmdtp); |
wdenk | 71f9511 | 2003-06-15 22:40:42 +0000 | [diff] [blame] | 89 | } else { |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 90 | printf ("Unknown command '%s' - try 'help'" |
| 91 | " without arguments for list of all" |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 92 | " known commands\n\n", argv[i] |
| 93 | ); |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 94 | rcode = 1; |
| 95 | } |
| 96 | } |
| 97 | return rcode; |
| 98 | } |
| 99 | |
| 100 | /*************************************************************************** |
| 101 | * find command table entry for a command |
| 102 | */ |
Kumar Gala | b799cb4 | 2008-09-23 10:05:02 -0500 | [diff] [blame] | 103 | cmd_tbl_t *find_cmd_tbl (const char *cmd, cmd_tbl_t *table, int table_len) |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 104 | { |
| 105 | cmd_tbl_t *cmdtp; |
Kumar Gala | b799cb4 | 2008-09-23 10:05:02 -0500 | [diff] [blame] | 106 | cmd_tbl_t *cmdtp_temp = table; /*Init value */ |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 107 | const char *p; |
| 108 | int len; |
| 109 | int n_found = 0; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 110 | |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 111 | /* |
| 112 | * Some commands allow length modifiers (like "cp.b"); |
| 113 | * compare command name only until first dot. |
| 114 | */ |
| 115 | len = ((p = strchr(cmd, '.')) == NULL) ? strlen (cmd) : (p - cmd); |
| 116 | |
Kumar Gala | b799cb4 | 2008-09-23 10:05:02 -0500 | [diff] [blame] | 117 | for (cmdtp = table; |
| 118 | cmdtp != table + table_len; |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 119 | cmdtp++) { |
| 120 | if (strncmp (cmd, cmdtp->name, len) == 0) { |
| 121 | if (len == strlen (cmdtp->name)) |
| 122 | return cmdtp; /* full match */ |
| 123 | |
| 124 | cmdtp_temp = cmdtp; /* abbreviated command ? */ |
| 125 | n_found++; |
| 126 | } |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 127 | } |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 128 | if (n_found == 1) { /* exactly one match */ |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 129 | return cmdtp_temp; |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 130 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 131 | |
wdenk | 9d2b18a | 2003-06-28 23:11:04 +0000 | [diff] [blame] | 132 | return NULL; /* not found or ambiguous command */ |
wdenk | 5dfa25f | 2002-10-19 19:42:10 +0000 | [diff] [blame] | 133 | } |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 134 | |
Kumar Gala | b799cb4 | 2008-09-23 10:05:02 -0500 | [diff] [blame] | 135 | cmd_tbl_t *find_cmd (const char *cmd) |
| 136 | { |
| 137 | int len = &__u_boot_cmd_end - &__u_boot_cmd_start; |
| 138 | return find_cmd_tbl(cmd, &__u_boot_cmd_start, len); |
| 139 | } |
| 140 | |
Wolfgang Denk | 94796d8 | 2009-05-24 19:17:29 +0200 | [diff] [blame] | 141 | int cmd_usage(cmd_tbl_t *cmdtp) |
Peter Tyser | 62c3ae7 | 2009-01-27 18:03:10 -0600 | [diff] [blame] | 142 | { |
Wolfgang Denk | 94796d8 | 2009-05-24 19:17:29 +0200 | [diff] [blame] | 143 | printf("%s - %s\n\n", cmdtp->name, cmdtp->usage); |
| 144 | |
| 145 | #ifdef CONFIG_SYS_LONGHELP |
| 146 | printf("Usage:\n%s ", cmdtp->name); |
| 147 | |
| 148 | if (!cmdtp->help) { |
| 149 | puts ("- No additional help available.\n"); |
| 150 | return 1; |
| 151 | } |
| 152 | |
| 153 | puts (cmdtp->help); |
| 154 | putc ('\n'); |
| 155 | #endif /* CONFIG_SYS_LONGHELP */ |
| 156 | return 0; |
Peter Tyser | 62c3ae7 | 2009-01-27 18:03:10 -0600 | [diff] [blame] | 157 | } |
| 158 | |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 159 | #ifdef CONFIG_AUTO_COMPLETE |
| 160 | |
| 161 | int var_complete(int argc, char *argv[], char last_char, int maxv, char *cmdv[]) |
| 162 | { |
| 163 | static char tmp_buf[512]; |
| 164 | int space; |
| 165 | |
| 166 | space = last_char == '\0' || last_char == ' ' || last_char == '\t'; |
| 167 | |
| 168 | if (space && argc == 1) |
| 169 | return env_complete("", maxv, cmdv, sizeof(tmp_buf), tmp_buf); |
| 170 | |
| 171 | if (!space && argc == 2) |
| 172 | return env_complete(argv[1], maxv, cmdv, sizeof(tmp_buf), tmp_buf); |
| 173 | |
| 174 | return 0; |
| 175 | } |
| 176 | |
| 177 | static void install_auto_complete_handler(const char *cmd, |
| 178 | int (*complete)(int argc, char *argv[], char last_char, int maxv, char *cmdv[])) |
| 179 | { |
| 180 | cmd_tbl_t *cmdtp; |
| 181 | |
| 182 | cmdtp = find_cmd(cmd); |
| 183 | if (cmdtp == NULL) |
| 184 | return; |
| 185 | |
| 186 | cmdtp->complete = complete; |
| 187 | } |
| 188 | |
| 189 | void install_auto_complete(void) |
| 190 | { |
Trübenbach, Ralf | 39f7aac | 2010-04-14 11:15:16 +0200 | [diff] [blame^] | 191 | #if defined(CONFIG_CMD_EDITENV) |
| 192 | install_auto_complete_handler("editenv", var_complete); |
| 193 | #endif |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 194 | install_auto_complete_handler("printenv", var_complete); |
| 195 | install_auto_complete_handler("setenv", var_complete); |
Jon Loeliger | c3517f9 | 2007-07-08 18:10:08 -0500 | [diff] [blame] | 196 | #if defined(CONFIG_CMD_RUN) |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 197 | install_auto_complete_handler("run", var_complete); |
| 198 | #endif |
| 199 | } |
| 200 | |
| 201 | /*************************************************************************************/ |
| 202 | |
| 203 | static int complete_cmdv(int argc, char *argv[], char last_char, int maxv, char *cmdv[]) |
| 204 | { |
| 205 | cmd_tbl_t *cmdtp; |
| 206 | const char *p; |
| 207 | int len, clen; |
| 208 | int n_found = 0; |
| 209 | const char *cmd; |
| 210 | |
| 211 | /* sanity? */ |
| 212 | if (maxv < 2) |
| 213 | return -2; |
| 214 | |
| 215 | cmdv[0] = NULL; |
| 216 | |
| 217 | if (argc == 0) { |
| 218 | /* output full list of commands */ |
| 219 | for (cmdtp = &__u_boot_cmd_start; cmdtp != &__u_boot_cmd_end; cmdtp++) { |
| 220 | if (n_found >= maxv - 2) { |
| 221 | cmdv[n_found++] = "..."; |
| 222 | break; |
| 223 | } |
| 224 | cmdv[n_found++] = cmdtp->name; |
| 225 | } |
| 226 | cmdv[n_found] = NULL; |
| 227 | return n_found; |
| 228 | } |
| 229 | |
| 230 | /* more than one arg or one but the start of the next */ |
| 231 | if (argc > 1 || (last_char == '\0' || last_char == ' ' || last_char == '\t')) { |
| 232 | cmdtp = find_cmd(argv[0]); |
| 233 | if (cmdtp == NULL || cmdtp->complete == NULL) { |
| 234 | cmdv[0] = NULL; |
| 235 | return 0; |
| 236 | } |
| 237 | return (*cmdtp->complete)(argc, argv, last_char, maxv, cmdv); |
| 238 | } |
| 239 | |
| 240 | cmd = argv[0]; |
| 241 | /* |
| 242 | * Some commands allow length modifiers (like "cp.b"); |
| 243 | * compare command name only until first dot. |
| 244 | */ |
| 245 | p = strchr(cmd, '.'); |
| 246 | if (p == NULL) |
| 247 | len = strlen(cmd); |
| 248 | else |
| 249 | len = p - cmd; |
| 250 | |
| 251 | /* return the partial matches */ |
| 252 | for (cmdtp = &__u_boot_cmd_start; cmdtp != &__u_boot_cmd_end; cmdtp++) { |
| 253 | |
| 254 | clen = strlen(cmdtp->name); |
| 255 | if (clen < len) |
| 256 | continue; |
| 257 | |
| 258 | if (memcmp(cmd, cmdtp->name, len) != 0) |
| 259 | continue; |
| 260 | |
| 261 | /* too many! */ |
| 262 | if (n_found >= maxv - 2) { |
| 263 | cmdv[n_found++] = "..."; |
| 264 | break; |
| 265 | } |
| 266 | |
| 267 | cmdv[n_found++] = cmdtp->name; |
| 268 | } |
| 269 | |
| 270 | cmdv[n_found] = NULL; |
| 271 | return n_found; |
| 272 | } |
| 273 | |
| 274 | static int make_argv(char *s, int argvsz, char *argv[]) |
| 275 | { |
| 276 | int argc = 0; |
| 277 | |
| 278 | /* split into argv */ |
| 279 | while (argc < argvsz - 1) { |
| 280 | |
| 281 | /* skip any white space */ |
| 282 | while ((*s == ' ') || (*s == '\t')) |
| 283 | ++s; |
| 284 | |
Wolfgang Denk | 53677ef | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 285 | if (*s == '\0') /* end of s, no more args */ |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 286 | break; |
| 287 | |
| 288 | argv[argc++] = s; /* begin of argument string */ |
| 289 | |
| 290 | /* find end of string */ |
| 291 | while (*s && (*s != ' ') && (*s != '\t')) |
| 292 | ++s; |
| 293 | |
| 294 | if (*s == '\0') /* end of s, no more args */ |
| 295 | break; |
| 296 | |
| 297 | *s++ = '\0'; /* terminate current arg */ |
| 298 | } |
| 299 | argv[argc] = NULL; |
| 300 | |
| 301 | return argc; |
| 302 | } |
| 303 | |
| 304 | static void print_argv(const char *banner, const char *leader, const char *sep, int linemax, char *argv[]) |
| 305 | { |
| 306 | int ll = leader != NULL ? strlen(leader) : 0; |
| 307 | int sl = sep != NULL ? strlen(sep) : 0; |
| 308 | int len, i; |
| 309 | |
| 310 | if (banner) { |
| 311 | puts("\n"); |
| 312 | puts(banner); |
| 313 | } |
| 314 | |
| 315 | i = linemax; /* force leader and newline */ |
| 316 | while (*argv != NULL) { |
| 317 | len = strlen(*argv) + sl; |
| 318 | if (i + len >= linemax) { |
| 319 | puts("\n"); |
| 320 | if (leader) |
| 321 | puts(leader); |
| 322 | i = ll - sl; |
| 323 | } else if (sep) |
| 324 | puts(sep); |
| 325 | puts(*argv++); |
| 326 | i += len; |
| 327 | } |
| 328 | printf("\n"); |
| 329 | } |
| 330 | |
| 331 | static int find_common_prefix(char *argv[]) |
| 332 | { |
| 333 | int i, len; |
| 334 | char *anchor, *s, *t; |
| 335 | |
| 336 | if (*argv == NULL) |
| 337 | return 0; |
| 338 | |
| 339 | /* begin with max */ |
| 340 | anchor = *argv++; |
| 341 | len = strlen(anchor); |
| 342 | while ((t = *argv++) != NULL) { |
| 343 | s = anchor; |
| 344 | for (i = 0; i < len; i++, t++, s++) { |
| 345 | if (*t != *s) |
| 346 | break; |
| 347 | } |
| 348 | len = s - anchor; |
| 349 | } |
| 350 | return len; |
| 351 | } |
| 352 | |
Jean-Christophe PLAGNIOL-VILLARD | 6d0f6bc | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 353 | static char tmp_buf[CONFIG_SYS_CBSIZE]; /* copy of console I/O buffer */ |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 354 | |
| 355 | int cmd_auto_complete(const char *const prompt, char *buf, int *np, int *colp) |
| 356 | { |
| 357 | int n = *np, col = *colp; |
Jean-Christophe PLAGNIOL-VILLARD | 6d0f6bc | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 358 | char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */ |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 359 | char *cmdv[20]; |
| 360 | char *s, *t; |
| 361 | const char *sep; |
| 362 | int i, j, k, len, seplen, argc; |
| 363 | int cnt; |
| 364 | char last_char; |
| 365 | |
Jean-Christophe PLAGNIOL-VILLARD | 6d0f6bc | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 366 | if (strcmp(prompt, CONFIG_SYS_PROMPT) != 0) |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 367 | return 0; /* not in normal console */ |
| 368 | |
| 369 | cnt = strlen(buf); |
| 370 | if (cnt >= 1) |
| 371 | last_char = buf[cnt - 1]; |
| 372 | else |
| 373 | last_char = '\0'; |
| 374 | |
| 375 | /* copy to secondary buffer which will be affected */ |
| 376 | strcpy(tmp_buf, buf); |
| 377 | |
| 378 | /* separate into argv */ |
| 379 | argc = make_argv(tmp_buf, sizeof(argv)/sizeof(argv[0]), argv); |
| 380 | |
| 381 | /* do the completion and return the possible completions */ |
| 382 | i = complete_cmdv(argc, argv, last_char, sizeof(cmdv)/sizeof(cmdv[0]), cmdv); |
| 383 | |
| 384 | /* no match; bell and out */ |
| 385 | if (i == 0) { |
| 386 | if (argc > 1) /* allow tab for non command */ |
| 387 | return 0; |
| 388 | putc('\a'); |
| 389 | return 1; |
| 390 | } |
| 391 | |
| 392 | s = NULL; |
| 393 | len = 0; |
| 394 | sep = NULL; |
| 395 | seplen = 0; |
| 396 | if (i == 1) { /* one match; perfect */ |
| 397 | k = strlen(argv[argc - 1]); |
| 398 | s = cmdv[0] + k; |
| 399 | len = strlen(s); |
| 400 | sep = " "; |
| 401 | seplen = 1; |
| 402 | } else if (i > 1 && (j = find_common_prefix(cmdv)) != 0) { /* more */ |
| 403 | k = strlen(argv[argc - 1]); |
| 404 | j -= k; |
| 405 | if (j > 0) { |
| 406 | s = cmdv[0] + k; |
| 407 | len = j; |
| 408 | } |
| 409 | } |
| 410 | |
| 411 | if (s != NULL) { |
| 412 | k = len + seplen; |
| 413 | /* make sure it fits */ |
Jean-Christophe PLAGNIOL-VILLARD | 6d0f6bc | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 414 | if (n + k >= CONFIG_SYS_CBSIZE - 2) { |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 415 | putc('\a'); |
| 416 | return 1; |
| 417 | } |
| 418 | |
| 419 | t = buf + cnt; |
| 420 | for (i = 0; i < len; i++) |
| 421 | *t++ = *s++; |
| 422 | if (sep != NULL) |
| 423 | for (i = 0; i < seplen; i++) |
| 424 | *t++ = sep[i]; |
| 425 | *t = '\0'; |
| 426 | n += k; |
| 427 | col += k; |
| 428 | puts(t - k); |
| 429 | if (sep == NULL) |
| 430 | putc('\a'); |
| 431 | *np = n; |
| 432 | *colp = col; |
| 433 | } else { |
| 434 | print_argv(NULL, " ", " ", 78, cmdv); |
| 435 | |
| 436 | puts(prompt); |
| 437 | puts(buf); |
| 438 | } |
| 439 | return 1; |
| 440 | } |
| 441 | |
| 442 | #endif |
Jean-Christophe PLAGNIOL-VILLARD | 8a40fb1 | 2008-09-10 22:48:05 +0200 | [diff] [blame] | 443 | |
| 444 | #ifdef CMD_DATA_SIZE |
| 445 | int cmd_get_data_size(char* arg, int default_size) |
| 446 | { |
| 447 | /* Check for a size specification .b, .w or .l. |
| 448 | */ |
| 449 | int len = strlen(arg); |
| 450 | if (len > 2 && arg[len-2] == '.') { |
| 451 | switch(arg[len-1]) { |
| 452 | case 'b': |
| 453 | return 1; |
| 454 | case 'w': |
| 455 | return 2; |
| 456 | case 'l': |
| 457 | return 4; |
| 458 | case 's': |
| 459 | return -2; |
| 460 | default: |
| 461 | return -1; |
| 462 | } |
| 463 | } |
| 464 | return default_size; |
| 465 | } |
| 466 | #endif |