packages/redboot/v2_0/src/io.c

   1 //==========================================================================
   2 //
   3 //      io.c
   4 //
   5 //      RedBoot I/O support
   6 //
   7 //==========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Red Hat, Inc.
  12 // Copyright (C) 2002, 2003, 2005 Gary Thomas
  13 //
  14 // eCos is free software; you can redistribute it and/or modify it under
  15 // the terms of the GNU General Public License as published by the Free
  16 // Software Foundation; either version 2 or (at your option) any later version.
  17 //
  18 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  19 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  21 // for more details.
  22 //
  23 // You should have received a copy of the GNU General Public License along
  24 // with eCos; if not, write to the Free Software Foundation, Inc.,
  25 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  26 //
  27 // As a special exception, if other files instantiate templates or use macros
  28 // or inline functions from this file, or you compile this file and link it
  29 // with other works to produce a work based on this file, this file does not
  30 // by itself cause the resulting work to be covered by the GNU General Public
  31 // License. However the source code for this file must still be made available
  32 // in accordance with section (3) of the GNU General Public License.
  33 //
  34 // This exception does not invalidate any other reasons why a work based on
  35 // this file might be covered by the GNU General Public License.
  36 //
  37 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  38 // at http://sources.redhat.com/ecos/ecos-license/
  39 // -------------------------------------------
  40 //####ECOSGPLCOPYRIGHTEND####
  41 //==========================================================================
  42 //#####DESCRIPTIONBEGIN####
  43 //
  44 // Author(s):    gthomas
  45 // Contributors: gthomas,hmt,jlarmour
  46 // Date:         2000-07-14
  47 // Purpose:
  48 // Description:
  49 //
  50 // This code is part of RedBoot (tm).
  51 //
  52 //####DESCRIPTIONEND####
  53 //
  54 //==========================================================================
  55
  56 #include "redboot.h"
  57
  58 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
  59 // GDB interface functions
  60 extern void ungetDebugChar(char c);
  61 #endif
  62
  63 static void
  64 do_channel(int argc, char *argv[]);
  65
  66 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
  67 RedBoot_cmd("channel",
  68                         "Display/switch console channel",
  69                         "[-1|<channel number>]",
  70                         do_channel
  71         );
  72 #else
  73 RedBoot_cmd("channel",
  74                         "Display/switch console channel",
  75                         "[<channel number>]",
  76                         do_channel
  77         );
  78 #endif
  79
  80 static void
  81 do_channel(int argc, char *argv[])
  82 {
  83         int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
  84
  85         if (argc == 2) {
  86 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
  87                 if (strcmp( argv[1], "-1") == 0) {
  88                         console_selected = false;
  89                         console_echo = true;
  90                 } else
  91 #endif
  92                 {
  93                         unsigned long chan;
  94                         if ( !parse_num( argv[1], &chan, NULL, NULL) ) {
  95                                 diag_printf("** Error: invalid channel '%s'\n", argv[1]);
  96                         } else {
  97                                 if (chan < CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS) {
  98                                         CYGACC_CALL_IF_SET_CONSOLE_COMM(chan);
  99                                         CYGACC_CALL_IF_SET_DEBUG_COMM(chan);
 100                                         if (chan != cur)
 101                                                 console_echo = true;
 102                                 }
 103                                 else {
 104                                         diag_printf("**Error: bad channel number '%s'\n", argv[1]);
 105                                 }
 106                         }
 107                 }
 108         }
 109         /* else display */
 110         else {
 111                 diag_printf("Current console channel id: ");
 112 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
 113                 if (!console_selected)
 114                         diag_printf("-1\n");
 115                 else
 116 #endif
 117                         diag_printf("%d\n", cur);
 118         }
 119 }
 120
 121 void
 122 mon_write_char(char c)
 123 {
 124         hal_virtual_comm_table_t *__chan;
 125
 126 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
 127         if (!console_selected) {
 128                 int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
 129                 int i;
 130                 // Send output to all channels
 131                 for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++) {
 132                         CYGACC_CALL_IF_SET_CONSOLE_COMM(i);
 133                         __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 134                         CYGACC_COMM_IF_PUTC(*__chan, c);
 135                 }
 136                 CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);
 137         } else
 138 #endif
 139         {
 140                 __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 141                 if (__chan)
 142                         CYGACC_COMM_IF_PUTC(*__chan, c);
 143                 else {
 144                         __chan = CYGACC_CALL_IF_DEBUG_PROCS();
 145                         CYGACC_COMM_IF_PUTC(*__chan, c);
 146                 }
 147         }
 148 }
 149
 150 static void
 151 mon_read_char(char *c)
 152 {
 153         hal_virtual_comm_table_t *__chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 154
 155         if (__chan)
 156                 *c = CYGACC_COMM_IF_GETC(*__chan);
 157         else {
 158                 __chan = CYGACC_CALL_IF_DEBUG_PROCS();
 159                 *c = CYGACC_COMM_IF_GETC(*__chan);
 160         }
 161 }
 162
 163 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
 164 static int _mon_timeout;
 165 #endif
 166
 167 bool
 168 mon_read_char_with_timeout(char *c)
 169 {
 170         bool res = false;
 171         hal_virtual_comm_table_t *__chan;
 172
 173 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
 174         if (!console_selected) {
 175                 int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
 176                 int i, j, tot;
 177                 // Try input from all channels
 178                 tot = 0;
 179                 while (tot < _mon_timeout) {
 180                         for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++, tot++) {
 181                                 CYGACC_CALL_IF_SET_CONSOLE_COMM(i);
 182                                 __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 183                                 res = CYGACC_COMM_IF_GETC_TIMEOUT(*__chan, c);
 184                                 if (res) {
 185                                         // Input available on this channel, make it be the console
 186                                         if (*c != '\0') {
 187                                                 // Don't chose this unless real data have arrived
 188                                                 console_selected = true;
 189                                                 CYGACC_CALL_IF_SET_DEBUG_COMM(i);
 190                                                 // Disable interrupts on all channels but this one
 191                                                 for (j = 0;  j < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  j++) {
 192                                                         if (i != j) {
 193                                                                 CYGACC_CALL_IF_SET_CONSOLE_COMM(j);
 194                                                                 __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 195                                                                 CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE);
 196                                                         }
 197                                                 }
 198                                                 CYGACC_CALL_IF_SET_CONSOLE_COMM(i);
 199                                                 return res;
 200                                         }
 201                                 }
 202                         }
 203                 }
 204                 CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);
 205         } else
 206 #endif
 207         {
 208                 __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 209                 if (__chan)
 210                         res = CYGACC_COMM_IF_GETC_TIMEOUT(*__chan, c);
 211                 else {
 212                         __chan = CYGACC_CALL_IF_DEBUG_PROCS();
 213                         res = CYGACC_COMM_IF_GETC_TIMEOUT(*__chan, c);
 214                 }
 215         }
 216         return res;
 217 }
 218
 219 void
 220 mon_set_read_char_timeout(int ms)
 221 {
 222         hal_virtual_comm_table_t *__chan;
 223
 224 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
 225         if (!console_selected) {
 226                 int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
 227                 int i;
 228                 // Set timeout to minimum on each channel; total amounts to desired value
 229                 _mon_timeout = ms;
 230                 ms = 1;
 231                 for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++) {
 232                         CYGACC_CALL_IF_SET_CONSOLE_COMM(i);
 233                         if ((__chan = CYGACC_CALL_IF_CONSOLE_PROCS()) != 0) {
 234                                 CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_SET_TIMEOUT, ms);
 235                         }
 236                 }
 237                 CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);
 238         } else
 239 #endif
 240         {
 241                 if ((__chan = CYGACC_CALL_IF_CONSOLE_PROCS()) != 0) {
 242                         CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_SET_TIMEOUT, ms);
 243                 }
 244                 if ((__chan = CYGACC_CALL_IF_DEBUG_PROCS()) != 0) {
 245                         CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_SET_TIMEOUT, ms);
 246                 }
 247         }
 248 }
 249
 250 //
 251 // Test for ^C on the console.  CAUTION! discards all console input
 252 //
 253 bool
 254 _rb_break(int timeout)
 255 {
 256         char c;
 257         mon_set_read_char_timeout(timeout);
 258         if (mon_read_char_with_timeout(&c)) {
 259                 if (c == 0x03) {  // Test for ^C
 260                         return true;
 261                 }
 262         }
 263         return false;
 264 }
 265
 266 #ifdef CYGFUN_REDBOOT_BOOT_SCRIPT
 267 #define __STRINGIFY(x) #x
 268 #define _STRINGIFY(x) __STRINGIFY(x)
 269 #define _STARTUP_STR _STRINGIFY(CYG_HAL_STARTUP) "}"
 270
 271 //
 272 // Read a character from script.
 273 // Return true if script character found, false if not.
 274 //
 275 static int
 276 getc_script(char *cp)
 277 {
 278         static bool newline = true;
 279         bool skip;
 280
 281         while (script && *script) {
 282                 if (newline && *script == '{') {
 283                         skip = false;
 284                         ++script;
 285
 286                         // skip if it isn't for this startup type
 287                         if (strncmp(script, _STARTUP_STR, strlen(_STARTUP_STR)))
 288                                 skip = true;
 289
 290                         // skip past "{...}"
 291                         while (*script && *script++ != '}')
 292                                 ;
 293
 294                         // skip script line if neccessary
 295                         if (skip) {
 296                                 while (*script && *script++ != '\n')
 297                                         ;
 298                         } else
 299                                 newline = false;
 300
 301                 } else {
 302                         *cp = *script++;
 303                         if (*cp == '\n') {
 304                                 newline = true;
 305                         } else {
 306                                 newline = false;
 307                         }
 308                         return true;
 309                 }
 310         }
 311         return false;
 312 }
 313 #endif
 314
 315 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 316 #define _CL_NUM_LINES CYGNUM_REDBOOT_CMD_LINE_EDITING       // Number of lines to keep
 317 static char _cl_lines[_CL_NUM_LINES][CYGPKG_REDBOOT_MAX_CMD_LINE];
 318 static int  _cl_index = -1;      // Last known command line
 319 static int  _cl_max_index = -1;  // Last command in buffers
 320
 321 #ifdef CYGBLD_REDBOOT_CMD_LINE_HISTORY
 322 static void expand_history(char *);
 323 #endif
 324 #endif
 325
 326 //
 327 // Read a line of input from the user
 328 // Return:
 329 //        _GETS_OK: 'n' valid characters received
 330 //       _GETS_GDB: '$' (GDB lead-in)
 331 //   _GETS_TIMEOUT: No input before timeout
 332 //     _GETS_CTRLC: ^C typed
 333 //
 334 // if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 335 //   Command line history support
 336 //    ^P - Select previous line from history
 337 //    ^N - Select next line from history
 338 //    ^A - Move insertion [cursor] to start of line
 339 //    ^E - Move cursor to end of line
 340 //    ^B - Move cursor back [previous character]
 341 //    ^F - Move cursor forward [next character]
 342 // "standard" arrow keys work as well
 343 //   left  ^[[D      == ^B
 344 //   right ^[[C      == ^F
 345 //   up    ^[[A      == ^P
 346 //   down  ^[[B      == ^N
 347 //   home  ^[[H/^[1~ == ^A
 348 //   end   ^[[F/^[OF == ^E
 349 //   del   ^[3~      == ^D
 350 //
 351 int
 352 _rb_gets_preloaded(char *buf, int buflen, int timeout)
 353 {
 354         char *ip = buf;   // Insertion point
 355         char *eol = buf;  // End of line
 356         char c;
 357         bool res = false;
 358         static char last_ch = '\0';
 359         int _timeout;
 360 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 361         int   _index = _cl_index;  // Last saved line
 362         char *xp;
 363 #ifdef CYGSEM_REDBOOT_CMD_LINE_ANSI_SEQUENCES
 364         int   ansi_state = 0;      // Used to drive ANSI parser
 365         char  ansi_char = '\0';
 366 #endif
 367 #endif
 368
 369         // Display current buffer data
 370         while (*eol) {
 371                 mon_write_char(*eol++);
 372         }
 373         ip = eol;
 374
 375         while (true) {
 376 #ifdef CYGFUN_REDBOOT_BOOT_SCRIPT
 377                 if (getc_script(&c))
 378                         do_idle(false);
 379                 else
 380 #endif
 381                         if ((timeout > 0) && (eol == buf)) {
 382 #define MIN_TIMEOUT 50
 383                                 _timeout = timeout > MIN_TIMEOUT ? MIN_TIMEOUT : timeout;
 384                                 mon_set_read_char_timeout(_timeout);
 385                                 while (timeout > 0) {
 386                                         res = mon_read_char_with_timeout(&c);
 387                                         if (res) {
 388                                                 // Got a character
 389                                                 do_idle(false);
 390                                                 break;
 391                                         }
 392                                         timeout -= _timeout;
 393                                 }
 394                                 if (res == false) {
 395                                         do_idle(true);
 396                                         return _GETS_TIMEOUT;  // Input timed out
 397                                 }
 398                         } else {
 399                                 mon_read_char(&c);
 400                         }
 401                 *eol = '\0';
 402 #define CTRL(c) ((c)&0x1F)
 403 #ifdef CYGSEM_REDBOOT_CMD_LINE_ANSI_SEQUENCES
 404                 // Special handling of ANSI keyboard sequences (arrows, etc)
 405                 if (c == 0x1B) {
 406                         // Leadin for ANSI keyboard sequence
 407                         ansi_state = 1;
 408                         continue;
 409                 }
 410                 switch (ansi_state) {
 411                 case 0:
 412                         // No ANSI sequence in progress
 413                         break;
 414                 case 1:
 415                         // ESC seen, look for '['
 416                         if (c == '[') {
 417                                 ansi_state = 2;
 418                         } else if (c == 'O') {
 419                                 ansi_state = 4;
 420                         } else {
 421                                 // Handle bad sequences?
 422                                 ansi_state = 0;
 423                         }
 424                         continue;
 425                 case 2:
 426                         // ESC+[ seen, process key
 427                         ansi_state = 0;
 428                         switch (c) {
 429                         case 'A':
 430                                 c = CTRL('P');
 431                                 break;
 432                         case 'B':
 433                                 c = CTRL('N');
 434                                 break;
 435                         case 'C':
 436                                 c = CTRL('F');
 437                                 break;
 438                         case 'D':
 439                                 c = CTRL('B');
 440                                 break;
 441                         case 'F':
 442                                 c = CTRL('E');
 443                                 break;
 444                         case 'H':
 445                                 c = CTRL('A');
 446                                 break;
 447                         case '1':
 448                                 ansi_char = CTRL('A');
 449                                 ansi_state = 3;
 450                                 continue;
 451                         case '3':
 452                                 ansi_char = CTRL('D');
 453                                 ansi_state = 3;
 454                                 continue;
 455                         default:
 456                                 // Handle bad sequences?
 457                                 continue;
 458                         }
 459                         break;
 460                 case 3:
 461                         // Sequences like ^[[1~ == ^H
 462                         ansi_state = 0;
 463                         if (c == '~') {
 464                                 c = ansi_char;
 465                         } else {
 466                                 // Handle bad sequences?
 467                                 continue;
 468                         }
 469                         break;
 470                 case 4:
 471                         // Sequences like ^[OF == ^E
 472                         ansi_state = 0;
 473                         if (c == 'F') {
 474                                 c = CTRL('E');
 475                         } else {
 476                                 // Handle bad sequences?
 477                                 continue;
 478                         }
 479                         break;
 480                 }
 481 #endif
 482                 switch (c) {
 483 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 484                 case CTRL('P'):
 485                         // Fetch the previous line into the buffer
 486                         if (_index >= 0) {
 487                                 // Erase the previous line [crude]
 488                                 while (ip != buf) {
 489                                         mon_write_char('\b');
 490                                         mon_write_char(' ');
 491                                         mon_write_char('\b');
 492                                         ip--;
 493                                 }
 494                                 strcpy(buf, _cl_lines[_index]);
 495                                 while (*ip) {
 496                                         mon_write_char(*ip++);
 497                                 }
 498                                 eol = ip;
 499                                 // Move to previous line
 500                                 _index--;
 501                                 if (_index < 0) {
 502                                         _index = _cl_max_index;
 503                                 }
 504                         } else {
 505                                 mon_write_char(0x07);  // Audible bell on most devices
 506                         }
 507                         break;
 508                 case CTRL('N'):
 509                         // Fetch the next line into the buffer
 510                         if (_index >= 0) {
 511                                 if (++_index > _cl_max_index) _index = 0;
 512                                 // Erase the previous line [crude]
 513                                 while (ip != buf) {
 514                                         mon_write_char('\b');
 515                                         mon_write_char(' ');
 516                                         mon_write_char('\b');
 517                                         ip--;
 518                                 }
 519                                 strcpy(buf, _cl_lines[_index]);
 520                                 while (*ip) {
 521                                         mon_write_char(*ip++);
 522                                 }
 523                                 eol = ip;
 524                         } else {
 525                                 mon_write_char(0x07);  // Audible bell on most devices
 526                         }
 527                         break;
 528                 case CTRL('B'):
 529                         // Move insertion point backwards
 530                         if (ip != buf) {
 531                                 mon_write_char('\b');
 532                                 ip--;
 533                         }
 534                         break;
 535                 case CTRL('F'):
 536                         // Move insertion point forwards
 537                         if (ip != eol) {
 538                                 mon_write_char(*ip++);
 539                         }
 540                         break;
 541                 case CTRL('E'):
 542                         // Move insertion point to end of line
 543                         while (ip != eol) {
 544                                 mon_write_char(*ip++);
 545                         }
 546                         break;
 547                 case CTRL('A'):
 548                         // Move insertion point to beginning of line
 549                         if (ip != buf) {
 550                                 xp = ip;
 551                                 while (xp-- != buf) {
 552                                         mon_write_char('\b');
 553                                 }
 554                         }
 555                         ip = buf;
 556                         break;
 557                 case CTRL('K'):
 558                         // Kill to the end of line
 559                         if (ip != eol) {
 560                                 xp = ip;
 561                                 while (xp++ != eol) {
 562                                         mon_write_char(' ');
 563                                 }
 564                                 while (--xp != ip) {
 565                                         mon_write_char('\b');
 566                                 }
 567                                 eol = ip;
 568                         }
 569                         break;
 570                 case CTRL('D'):
 571                         // Erase the character under the cursor
 572                         if (ip != eol) {
 573                                 xp = ip;
 574                                 eol--;
 575                                 while (xp != eol) {
 576                                         *xp = *(xp+1);
 577                                         mon_write_char(*xp++);
 578                                 }
 579                                 mon_write_char(' ');  // Erases last character
 580                                 mon_write_char('\b');
 581                                 while (xp-- != ip) {
 582                                         mon_write_char('\b');
 583                                 }
 584                         }
 585                         break;
 586 #endif // CYGNUM_REDBOOT_CMD_LINE_EDITING
 587                 case CTRL('C'): // ^C
 588                         // Abort current input
 589                         diag_printf("^C\n");
 590                         *buf = '\0';  // Nothing useful in buffer
 591                         return _GETS_CTRLC;
 592                 case '\n':
 593                 case '\r':
 594                         // If previous character was the "other" end-of-line, ignore this one
 595                         if (((c == '\n') && (last_ch == '\r')) ||
 596                                 ((c == '\r') && (last_ch == '\n'))) {
 597                                 c = '\0';
 598                                 break;
 599                         }
 600                         // End of line
 601                         if (console_echo) {
 602                                 mon_write_char('\r');
 603                                 mon_write_char('\n');
 604                         }
 605                         last_ch = c;
 606 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 607                         if (cmd_history) {
 608                                 // History handling - only when enabled
 609 #ifdef CYGBLD_REDBOOT_CMD_LINE_HISTORY
 610                                 expand_history(buf);
 611 #endif
 612                                 if (*buf != '\0') {
 613                                         if (++_cl_index == _CL_NUM_LINES) _cl_index = 0;
 614                                         if (_cl_index > _cl_max_index) _cl_max_index = _cl_index;
 615                                         strcpy(_cl_lines[_cl_index], buf);
 616                                 }
 617                         }
 618 #endif
 619                         return _GETS_OK;
 620                 case '\b':
 621                 case 0x7F:  // DEL
 622                         if (ip != buf) {
 623 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 624                                 if (ip != eol) {
 625                                         ip--;
 626                                         mon_write_char('\b');
 627                                         xp = ip;
 628                                         while (xp != (eol-1)) {
 629                                                 *xp = *(xp+1);
 630                                                 mon_write_char(*xp++);
 631                                         }
 632                                         mon_write_char(' ');  // Erases last character
 633                                         mon_write_char('\b');
 634                                         while (xp-- != ip) {
 635                                                 mon_write_char('\b');
 636                                         }
 637                                 } else {
 638                                         if (console_echo) {
 639                                                 mon_write_char('\b');
 640                                                 mon_write_char(' ');
 641                                                 mon_write_char('\b');
 642                                         }
 643                                         ip--;
 644                                 }
 645                                 eol--;
 646 #else
 647                                 if (console_echo) {
 648                                         mon_write_char('\b');
 649                                         mon_write_char(' ');
 650                                         mon_write_char('\b');
 651                                 }
 652                                 ip--;
 653                                 eol--;
 654 #endif
 655                         }
 656                         break;
 657 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 658                 case '+': // fall through
 659                 case '$':
 660                         if (ip == buf || last_ch != '\\')
 661                         {
 662                                 // Give up and try GDB protocol
 663                                 ungetDebugChar(c);  // Push back character so stubs will see it
 664                                 return _GETS_GDB;
 665                         }
 666                         if (last_ch == '\\') {
 667 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 668                                 if (ip == eol) {
 669                                         // Just save \$ as $
 670                                         eol = --ip;
 671                                 } else {
 672                                         mon_write_char('\b');
 673                                         *--ip = c;
 674                                         mon_write_char(c);
 675                                         break;
 676                                 }
 677 #else
 678                                 ip--;  // Save \$ as $
 679 #endif
 680                         }
 681                         // else fall through
 682 #endif
 683                 default:
 684 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 685                         // If the insertion point is not at the end of line, make space for it
 686                         if (ip != eol) {
 687                                 xp = eol;
 688                                 *++eol = '\0';
 689                                 while (xp != ip) {
 690                                         *xp = *(xp-1);
 691                                         xp--;
 692                                 }
 693                         }
 694 #endif
 695                         if (console_echo) {
 696                                 mon_write_char(c);
 697                         }
 698                         if (ip == eol) {
 699                                 // Advance both pointers
 700                                 *ip++ = c;
 701                                 eol = ip;
 702 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 703                         } else {
 704                                 // Just insert the character
 705                                 *ip++ = c;
 706                                 xp = ip;
 707                                 while (xp != eol) {
 708                                         mon_write_char(*xp++);
 709                                 }
 710                                 while (xp-- != ip) {
 711                                         mon_write_char('\b');
 712                                 }
 713 #endif
 714                         }
 715                 }
 716                 last_ch = c;
 717                 if (ip == buf + buflen - 1) { // Buffer full
 718                         *ip = '\0';
 719                         return buflen;
 720                 }
 721         }
 722 }
 723
 724 int
 725 _rb_gets(char *buf, int buflen, int timeout)
 726 {
 727         *buf = '\0';  // Empty buffer
 728         return _rb_gets_preloaded(buf, buflen, timeout);
 729 }
 730
 731 static bool
 732 _verify_action(int timeout, char *fmt, va_list ap)
 733 {
 734         char ans[8];
 735         int ret;
 736 #ifdef CYGFUN_REDBOOT_BOOT_SCRIPT
 737         // Don't ask if we're executing a script
 738         if (script && *script)
 739                 return 1;
 740 #endif
 741
 742         diag_vprintf(fmt, ap);
 743         diag_printf(" - continue (y/n)? ");
 744         if ((ret = _rb_gets(ans, sizeof(ans), timeout)) > 0) {
 745                 return ((ans[0] == 'y') || (ans[0] == 'Y'));
 746         } else {
 747                 if (ret == _GETS_TIMEOUT) {
 748                         diag_printf(" ** Timed out!\n");
 749                 }
 750                 return 0;  // Timed out or ^C
 751         }
 752 }
 753
 754 bool
 755 verify_action(char *fmt, ...)
 756 {
 757         va_list ap;
 758
 759         va_start(ap, fmt);
 760         return _verify_action(0, fmt, ap);
 761 }
 762
 763 bool
 764 verify_action_with_timeout(int timeout, char *fmt, ...)
 765 {
 766         va_list ap;
 767
 768         va_start(ap, fmt);
 769         return _verify_action(timeout, fmt, ap);
 770 }
 771
 772
 773 #ifdef CYGBLD_REDBOOT_CMD_LINE_HISTORY
 774 // parse for history index number. Return number or -1 if not
 775 // an index number.
 776 static int
 777 parse_history_index(char *s)
 778 {
 779         int val = 0;
 780
 781         while ('0' <= *s && *s <= '9')
 782                 val = (val * 10) + (*s++ - '0');
 783
 784         if (*s)
 785                 return -1;
 786
 787         return val;
 788 }
 789
 790 // Check input line to see if it needs history expansion. If so,
 791 // try to find matching command and replace buffer as appropriate.
 792 static void
 793 expand_history(char *buf)
 794 {
 795         int ncmds = _cl_max_index + 1;
 796         int i, index, len;
 797
 798         if (buf[0] != '!' || buf[1] == '\0')
 799                 return;
 800
 801         if (ncmds > 0) {
 802                 if (!strcmp(buf, "!!")) {
 803                         strcpy(buf, _cl_lines[_cl_index]);
 804                         return;
 805                 }
 806                 if ((index = parse_history_index(buf + 1)) >= 0) {
 807                         if (index <= _cl_max_index) {
 808                                 strcpy(buf, _cl_lines[index]);
 809                                 return;
 810                         }
 811                 }
 812                 len = strlen(buf + 1);
 813                 for (i = 0, index = _cl_index; i < ncmds; i++) {
 814                         if (!strncmp(_cl_lines[index], buf+1, len)) {
 815                                 strcpy(buf, _cl_lines[index]);
 816                                 return;
 817                         }
 818                         if (--index < 0)
 819                                 index = _cl_max_index;
 820                 }
 821         }
 822
 823         diag_printf("%s: event not found\n", buf);
 824         *buf = '\0';
 825 }
 826
 827 static void
 828 do_history(int argc, char *argv[])
 829 {
 830         int ncmds = _cl_max_index + 1;
 831         int i, index;
 832
 833         if (_cl_index == _cl_max_index) {
 834                 // history has not wrapped around
 835                 for (i = 0; i < ncmds; i++)
 836                         diag_printf("%3d %s\n", i, _cl_lines[i]);
 837         } else {
 838                 for (i = 0, index = _cl_index + 1; i < ncmds; i++) {
 839                         diag_printf("%3d %s\n", i, _cl_lines[index++]);
 840                         if (index > _cl_max_index)
 841                                 index = 0;
 842                 }
 843         }
 844 }
 845
 846 RedBoot_cmd("history",
 847                         "Display command history",
 848                         "",
 849                         do_history
 850         );
 851 #endif  // CYGBLD_REDBOOT_CMD_LINE_HISTORY