normal/menu_entry.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2005,2006,2007,2008  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/normal.h>
  20 #include <grub/term.h>
  21 #include <grub/misc.h>
  22 #include <grub/mm.h>
  23 #include <grub/loader.h>
  24 #include <grub/command.h>
  25 #include <grub/parser.h>
  26
  27 enum update_mode
  28   {
  29     NO_LINE,
  30     SINGLE_LINE,
  31     ALL_LINES
  32   };
  33
  34 struct line
  35 {
  36   /* The line buffer.  */
  37   char *buf;
  38   /* The length of the line.  */
  39   int len;
  40   /* The maximum length of the line.  */
  41   int max_len;
  42 };
  43
  44 struct screen
  45 {
  46   /* The array of lines.  */
  47   struct line *lines;
  48   /* The number of lines.  */
  49   int num_lines;
  50   /* The current column.  */
  51   int column;
  52   /* The real column.  */
  53   int real_column;
  54   /* The current line.  */
  55   int line;
  56   /* The X coordinate.  */
  57   int x;
  58   /* The Y coordinate.  */
  59   int y;
  60   /* The kill buffer.  */
  61   char *killed_text;
  62   /* The flag of a completion window.  */
  63   int completion_shown;
  64 };
  65
  66 /* Used for storing completion items temporarily.  */
  67 static struct line completion_buffer;
  68
  69 /* Initialize a line.  */
  70 static int
  71 init_line (struct line *linep)
  72 {
  73   linep->len = 0;
  74   linep->max_len = 80; /* XXX */
  75   linep->buf = grub_malloc (linep->max_len);
  76   if (! linep->buf)
  77     return 0;
  78
  79   return 1;
  80 }
  81
  82 /* Allocate extra space if necessary.  */
  83 static int
  84 ensure_space (struct line *linep, int extra)
  85 {
  86   if (linep->max_len < linep->len + extra)
  87     {
  88       linep->max_len = linep->len + extra + 80; /* XXX */
  89       linep->buf = grub_realloc (linep->buf, linep->max_len + 1);
  90       if (! linep->buf)
  91         return 0;
  92     }
  93
  94   return 1;
  95 }
  96
  97 /* Return the number of lines occupied by this line on the screen.  */
  98 static int
  99 get_logical_num_lines (struct line *linep)
 100 {
 101   return (linep->len / GRUB_TERM_ENTRY_WIDTH) + 1;
 102 }
 103
 104 /* Print a line.  */
 105 static void
 106 print_line (struct line *linep, int offset, int start, int y)
 107 {
 108   int i;
 109   char *p;
 110
 111   grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + start + 1,
 112                y + GRUB_TERM_FIRST_ENTRY_Y);
 113
 114   for (p = linep->buf + offset + start, i = start;
 115        i < GRUB_TERM_ENTRY_WIDTH && offset + i < linep->len;
 116        p++, i++)
 117     grub_putchar (*p);
 118
 119   for (; i < GRUB_TERM_ENTRY_WIDTH; i++)
 120     grub_putchar (' ');
 121
 122   if (linep->len >= offset + GRUB_TERM_ENTRY_WIDTH)
 123     grub_putchar ('\\');
 124   else
 125     grub_putchar (' ');
 126 }
 127
 128 /* Print an empty line.  */
 129 static void
 130 print_empty_line (int y)
 131 {
 132   int i;
 133
 134   grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + 1,
 135                y + GRUB_TERM_FIRST_ENTRY_Y);
 136
 137   for (i = 0; i < GRUB_TERM_ENTRY_WIDTH + 1; i++)
 138     grub_putchar (' ');
 139 }
 140
 141 /* Print an up arrow.  */
 142 static void
 143 print_up (int flag)
 144 {
 145   grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_BORDER_WIDTH,
 146                GRUB_TERM_FIRST_ENTRY_Y);
 147
 148   if (flag)
 149     grub_putcode (GRUB_TERM_DISP_UP);
 150   else
 151     grub_putchar (' ');
 152 }
 153
 154 /* Print a down arrow.  */
 155 static void
 156 print_down (int flag)
 157 {
 158   grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_BORDER_WIDTH,
 159                GRUB_TERM_TOP_BORDER_Y + GRUB_TERM_NUM_ENTRIES);
 160
 161   if (flag)
 162     grub_putcode (GRUB_TERM_DISP_DOWN);
 163   else
 164     grub_putchar (' ');
 165 }
 166
 167 /* Draw the lines of the screen SCREEN.  */
 168 static void
 169 update_screen (struct screen *screen, int region_start, int region_column,
 170                int up, int down, enum update_mode mode)
 171 {
 172   int up_flag = 0;
 173   int down_flag = 0;
 174   int y;
 175   int i;
 176   struct line *linep;
 177
 178   /* Check if scrolling is necessary.  */
 179   if (screen->y < 0 || screen->y >= GRUB_TERM_NUM_ENTRIES)
 180     {
 181       if (screen->y < 0)
 182         screen->y = 0;
 183       else
 184         screen->y = GRUB_TERM_NUM_ENTRIES - 1;
 185
 186       region_start = 0;
 187       region_column = 0;
 188       up = 1;
 189       down = 1;
 190       mode = ALL_LINES;
 191     }
 192
 193   if (mode != NO_LINE)
 194     {
 195       /* Draw lines. This code is tricky, because this must calculate logical
 196          positions.  */
 197       y = screen->y - screen->column / GRUB_TERM_ENTRY_WIDTH;
 198       i = screen->line;
 199       linep = screen->lines + i;
 200       while (y > 0)
 201         {
 202            i--;
 203            linep--;
 204            y -= get_logical_num_lines (linep);
 205         }
 206
 207       if (y < 0 || i > 0)
 208         up_flag = 1;
 209
 210       do
 211         {
 212           int column;
 213
 214           for (column = 0;
 215                column <= linep->len && y < GRUB_TERM_NUM_ENTRIES;
 216                column += GRUB_TERM_ENTRY_WIDTH, y++)
 217             {
 218               if (y < 0)
 219                 continue;
 220
 221               if (i == region_start)
 222                 {
 223                   if (region_column >= column
 224                       && region_column < column + GRUB_TERM_ENTRY_WIDTH)
 225                     print_line (linep, column, region_column - column, y);
 226                   else if (region_column < column)
 227                     print_line (linep, column, 0, y);
 228                 }
 229               else if (i > region_start && mode == ALL_LINES)
 230                 print_line (linep, column, 0, y);
 231             }
 232
 233           if (y == GRUB_TERM_NUM_ENTRIES)
 234             {
 235               if (column <= linep->len || i + 1 < screen->num_lines)
 236                 down_flag = 1;
 237             }
 238
 239           linep++;
 240           i++;
 241
 242           if (mode == ALL_LINES && i == screen->num_lines)
 243             for (; y < GRUB_TERM_NUM_ENTRIES; y++)
 244               print_empty_line (y);
 245
 246         }
 247       while (y < GRUB_TERM_NUM_ENTRIES);
 248
 249       /* Draw up and down arrows.  */
 250       if (up)
 251         print_up (up_flag);
 252       if (down)
 253         print_down (down_flag);
 254     }
 255
 256   /* Place the cursor.  */
 257   grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + 1 + screen->x,
 258                GRUB_TERM_FIRST_ENTRY_Y + screen->y);
 259
 260   grub_refresh ();
 261 }
 262
 263 /* Insert the string S into the screen SCREEN. This updates the cursor
 264    position and redraw the screen. Return zero if fails.  */
 265 static int
 266 insert_string (struct screen *screen, char *s, int update)
 267 {
 268   int region_start = screen->num_lines;
 269   int region_column = 0;
 270   int down = 0;
 271   enum update_mode mode = NO_LINE;
 272
 273   while (*s)
 274     {
 275       if (*s == '\n')
 276         {
 277           /* LF is special because it creates a new line.  */
 278           struct line *current_linep;
 279           struct line *next_linep;
 280           int size;
 281
 282           /* Make a new line.  */
 283           screen->num_lines++;
 284           screen->lines = grub_realloc (screen->lines,
 285                                         screen->num_lines
 286                                         * sizeof (struct line));
 287           if (! screen->lines)
 288             return 0;
 289
 290           /* Scroll down. */
 291           grub_memmove (screen->lines + screen->line + 2,
 292                         screen->lines + screen->line + 1,
 293                         ((screen->num_lines - screen->line - 2)
 294                          * sizeof (struct line)));
 295
 296           if (! init_line (screen->lines + screen->line + 1))
 297             return 0;
 298
 299           /* Fold the line.  */
 300           current_linep = screen->lines + screen->line;
 301           next_linep = current_linep + 1;
 302           size = current_linep->len - screen->column;
 303
 304           if (! ensure_space (next_linep, size))
 305             return 0;
 306
 307           grub_memmove (next_linep->buf,
 308                         current_linep->buf + screen->column,
 309                         size);
 310           current_linep->len = screen->column;
 311           next_linep->len = size;
 312
 313           /* Update a dirty region.  */
 314           if (region_start > screen->line)
 315             {
 316               region_start = screen->line;
 317               region_column = screen->column;
 318             }
 319
 320           mode = ALL_LINES;
 321           down = 1; /* XXX not optimal.  */
 322
 323           /* Move the cursor.  */
 324           screen->column = screen->real_column = 0;
 325           screen->line++;
 326           screen->x = 0;
 327           screen->y++;
 328
 329           s++;
 330         }
 331       else
 332         {
 333           /* All but LF.  */
 334           char *p;
 335           struct line *current_linep;
 336           int size;
 337           int orig_num, new_num;
 338
 339           /* Find a string delimited by LF.  */
 340           p = grub_strchr (s, '\n');
 341           if (! p)
 342             p = s + grub_strlen (s);
 343
 344           /* Insert the string.  */
 345           current_linep = screen->lines + screen->line;
 346           size = p - s;
 347           if (! ensure_space (current_linep, size))
 348             return 0;
 349
 350           grub_memmove (current_linep->buf + screen->column + size,
 351                         current_linep->buf + screen->column,
 352                         current_linep->len - screen->column);
 353           grub_memmove (current_linep->buf + screen->column,
 354                         s,
 355                         size);
 356           orig_num = get_logical_num_lines (current_linep);
 357           current_linep->len += size;
 358           new_num = get_logical_num_lines (current_linep);
 359
 360           /* Update the dirty region.  */
 361           if (region_start > screen->line)
 362             {
 363               region_start = screen->line;
 364               region_column = screen->column;
 365             }
 366
 367           if (orig_num != new_num)
 368             {
 369               mode = ALL_LINES;
 370               down = 1; /* XXX not optimal.  */
 371             }
 372           else if (mode != ALL_LINES)
 373             mode = SINGLE_LINE;
 374
 375           /* Move the cursor.  */
 376           screen->column += size;
 377           screen->real_column = screen->column;
 378           screen->x += size;
 379           screen->y += screen->x / GRUB_TERM_ENTRY_WIDTH;
 380           screen->x %= GRUB_TERM_ENTRY_WIDTH;
 381
 382           s = p;
 383         }
 384     }
 385
 386   if (update)
 387     update_screen (screen, region_start, region_column, 0, down, mode);
 388
 389   return 1;
 390 }
 391
 392 /* Release the resource allocated for SCREEN.  */
 393 static void
 394 destroy_screen (struct screen *screen)
 395 {
 396   int i;
 397
 398   if (screen->lines)
 399     for (i = 0; i < screen->num_lines; i++)
 400       {
 401         struct line *linep = screen->lines + i;
 402
 403         if (linep)
 404           grub_free (linep->buf);
 405       }
 406
 407   grub_free (screen->killed_text);
 408   grub_free (screen->lines);
 409   grub_free (screen);
 410 }
 411
 412 /* Make a new screen.  */
 413 static struct screen *
 414 make_screen (grub_menu_entry_t entry)
 415 {
 416   struct screen *screen;
 417
 418   /* Initialize the screen.  */
 419   screen = grub_zalloc (sizeof (*screen));
 420   if (! screen)
 421     return 0;
 422
 423   screen->num_lines = 1;
 424   screen->lines = grub_malloc (sizeof (struct line));
 425   if (! screen->lines)
 426     goto fail;
 427
 428   /* Initialize the first line which must be always present.  */
 429   if (! init_line (screen->lines))
 430     goto fail;
 431
 432   insert_string (screen, (char *) entry->sourcecode, 0);
 433
 434   /* Reset the cursor position.  */
 435   screen->column = 0;
 436   screen->real_column = 0;
 437   screen->line = 0;
 438   screen->x = 0;
 439   screen->y = 0;
 440
 441   return screen;
 442
 443  fail:
 444   destroy_screen (screen);
 445   return 0;
 446 }
 447
 448 static int
 449 forward_char (struct screen *screen, int update)
 450 {
 451   struct line *linep;
 452
 453   linep = screen->lines + screen->line;
 454   if (screen->column < linep->len)
 455     {
 456       screen->column++;
 457       screen->x++;
 458       if (screen->x == GRUB_TERM_ENTRY_WIDTH)
 459         {
 460           screen->x = 0;
 461           screen->y++;
 462         }
 463     }
 464   else if (screen->num_lines > screen->line + 1)
 465     {
 466       screen->column = 0;
 467       screen->line++;
 468       screen->x = 0;
 469       screen->y++;
 470     }
 471
 472   screen->real_column = screen->column;
 473
 474   if (update)
 475     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 476   return 1;
 477 }
 478
 479 static int
 480 backward_char (struct screen *screen, int update)
 481 {
 482   if (screen->column > 0)
 483     {
 484       screen->column--;
 485       screen->x--;
 486       if (screen->x == -1)
 487         {
 488           screen->x = GRUB_TERM_ENTRY_WIDTH - 1;
 489           screen->y--;
 490         }
 491     }
 492   else if (screen->line > 0)
 493     {
 494       struct line *linep;
 495
 496       screen->line--;
 497       linep = screen->lines + screen->line;
 498       screen->column = linep->len;
 499       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 500       screen->y--;
 501     }
 502
 503   screen->real_column = screen->column;
 504
 505   if (update)
 506     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 507
 508   return 1;
 509 }
 510
 511 static int
 512 previous_line (struct screen *screen, int update)
 513 {
 514   if (screen->line > 0)
 515     {
 516       struct line *linep;
 517       int dy;
 518
 519       /* How many physical lines from the current position
 520          to the first physical line?  */
 521       dy = screen->column / GRUB_TERM_ENTRY_WIDTH;
 522
 523       screen->line--;
 524
 525       linep = screen->lines + screen->line;
 526       if (linep->len < screen->real_column)
 527         screen->column = linep->len;
 528       else
 529         screen->column = screen->real_column;
 530
 531       /* How many physical lines from the current position
 532          to the last physical line?  */
 533       dy += (linep->len / GRUB_TERM_ENTRY_WIDTH
 534              - screen->column / GRUB_TERM_ENTRY_WIDTH);
 535
 536       screen->y -= dy + 1;
 537       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 538     }
 539   else
 540     {
 541       screen->y -= screen->column / GRUB_TERM_ENTRY_WIDTH;
 542       screen->column = 0;
 543       screen->x = 0;
 544     }
 545
 546   if (update)
 547     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 548
 549   return 1;
 550 }
 551
 552 static int
 553 next_line (struct screen *screen, int update)
 554 {
 555   if (screen->line < screen->num_lines - 1)
 556     {
 557       struct line *linep;
 558       int dy;
 559
 560       /* How many physical lines from the current position
 561          to the last physical line?  */
 562       linep = screen->lines + screen->line;
 563       dy = (linep->len / GRUB_TERM_ENTRY_WIDTH
 564             - screen->column / GRUB_TERM_ENTRY_WIDTH);
 565
 566       screen->line++;
 567
 568       linep++;
 569       if (linep->len < screen->real_column)
 570         screen->column = linep->len;
 571       else
 572         screen->column = screen->real_column;
 573
 574       /* How many physical lines from the current position
 575          to the first physical line?  */
 576       dy += screen->column / GRUB_TERM_ENTRY_WIDTH;
 577
 578       screen->y += dy + 1;
 579       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 580     }
 581   else
 582     {
 583       struct line *linep;
 584
 585       linep = screen->lines + screen->line;
 586       screen->y += (linep->len / GRUB_TERM_ENTRY_WIDTH
 587                     - screen->column / GRUB_TERM_ENTRY_WIDTH);
 588       screen->column = linep->len;
 589       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 590     }
 591
 592   if (update)
 593     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 594
 595   return 1;
 596 }
 597
 598 static int
 599 beginning_of_line (struct screen *screen, int update)
 600 {
 601   screen->y -= screen->column / GRUB_TERM_ENTRY_WIDTH;
 602   screen->column = screen->real_column = 0;
 603   screen->x = 0;
 604
 605   if (update)
 606     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 607
 608   return 1;
 609 }
 610
 611 static int
 612 end_of_line (struct screen *screen, int update)
 613 {
 614   struct line *linep;
 615
 616   linep = screen->lines + screen->line;
 617   screen->y += (linep->len / GRUB_TERM_ENTRY_WIDTH
 618                 - screen->column / GRUB_TERM_ENTRY_WIDTH);
 619   screen->column = screen->real_column = linep->len;
 620   screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 621
 622   if (update)
 623     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 624
 625   return 1;
 626 }
 627
 628 static int
 629 delete_char (struct screen *screen, int update)
 630 {
 631   struct line *linep;
 632   enum update_mode mode = NO_LINE;
 633   int start = screen->num_lines;
 634   int column = 0;
 635   int down = 0;
 636
 637   linep = screen->lines + screen->line;
 638   if (linep->len > screen->column)
 639     {
 640       int orig_num, new_num;
 641
 642       orig_num = get_logical_num_lines (linep);
 643
 644       grub_memmove (linep->buf + screen->column,
 645                     linep->buf + screen->column + 1,
 646                     linep->len - screen->column - 1);
 647       linep->len--;
 648
 649       new_num = get_logical_num_lines (linep);
 650
 651       if (orig_num != new_num)
 652         mode = ALL_LINES;
 653       else
 654         mode = SINGLE_LINE;
 655
 656       start = screen->line;
 657       column = screen->column;
 658     }
 659   else if (screen->num_lines > screen->line + 1)
 660     {
 661       struct line *next_linep;
 662
 663       next_linep = linep + 1;
 664       if (! ensure_space (linep, next_linep->len))
 665         return 0;
 666
 667       grub_memmove (linep->buf + linep->len, next_linep->buf, next_linep->len);
 668       linep->len += next_linep->len;
 669
 670       grub_free (next_linep->buf);
 671       grub_memmove (next_linep,
 672                     next_linep + 1,
 673                     (screen->num_lines - screen->line - 2)
 674                     * sizeof (struct line));
 675       screen->num_lines--;
 676
 677       mode = ALL_LINES;
 678       start = screen->line;
 679       column = screen->column;
 680       down = 1;
 681     }
 682
 683   screen->real_column = screen->column;
 684
 685   if (update)
 686     update_screen (screen, start, column, 0, down, mode);
 687
 688   return 1;
 689 }
 690
 691 static int
 692 backward_delete_char (struct screen *screen, int update)
 693 {
 694   int saved_column;
 695   int saved_line;
 696
 697   saved_column = screen->column;
 698   saved_line = screen->line;
 699
 700   if (! backward_char (screen, 0))
 701     return 0;
 702
 703   if (saved_column != screen->column || saved_line != screen->line)
 704     if (! delete_char (screen, update))
 705       return 0;
 706
 707   return 1;
 708 }
 709
 710 static int
 711 kill_line (struct screen *screen, int continuous, int update)
 712 {
 713   struct line *linep;
 714   char *p;
 715   int size;
 716   int offset;
 717
 718   p = screen->killed_text;
 719   if (! continuous && p)
 720     p[0] = '\0';
 721
 722   linep = screen->lines + screen->line;
 723   size = linep->len - screen->column;
 724
 725   if (p)
 726     offset = grub_strlen (p);
 727   else
 728     offset = 0;
 729
 730   if (size > 0)
 731     {
 732       enum update_mode mode = SINGLE_LINE;
 733       int down = 0;
 734       int orig_num, new_num;
 735
 736       p = grub_realloc (p, offset + size + 1);
 737       if (! p)
 738         return 0;
 739
 740       grub_memmove (p + offset, linep->buf + screen->column, size);
 741       p[offset + size - 1] = '\0';
 742
 743       screen->killed_text = p;
 744
 745       orig_num = get_logical_num_lines (linep);
 746       linep->len = screen->column;
 747       new_num = get_logical_num_lines (linep);
 748
 749       if (orig_num != new_num)
 750         {
 751           mode = ALL_LINES;
 752           down = 1;
 753         }
 754
 755       if (update)
 756         update_screen (screen, screen->line, screen->column, 0, down, mode);
 757     }
 758   else if (screen->line + 1 < screen->num_lines)
 759     {
 760       p = grub_realloc (p, offset + 1 + 1);
 761       if (! p)
 762         return 0;
 763
 764       p[offset] = '\n';
 765       p[offset + 1] = '\0';
 766
 767       screen->killed_text = p;
 768
 769       return delete_char (screen, update);
 770     }
 771
 772   return 1;
 773 }
 774
 775 static int
 776 yank (struct screen *screen, int update)
 777 {
 778   if (screen->killed_text)
 779     return insert_string (screen, screen->killed_text, update);
 780
 781   return 1;
 782 }
 783
 784 static int
 785 open_line (struct screen *screen, int update)
 786 {
 787   int saved_y = screen->y;
 788
 789   if (! insert_string (screen, "\n", 0))
 790     return 0;
 791
 792   if (! backward_char (screen, 0))
 793     return 0;
 794
 795   screen->y = saved_y;
 796
 797   if (update)
 798     update_screen (screen, screen->line, screen->column, 0, 1, ALL_LINES);
 799
 800   return 1;
 801 }
 802
 803 /* A completion hook to print items.  */
 804 static void
 805 store_completion (const char *item, grub_completion_type_t type, int count)
 806 {
 807   char *p;
 808
 809   if (count == 0)
 810     {
 811       /* If this is the first time, print a label.  */
 812       const char *what;
 813
 814       switch (type)
 815         {
 816         case GRUB_COMPLETION_TYPE_COMMAND:
 817           what = "commands";
 818           break;
 819         case GRUB_COMPLETION_TYPE_DEVICE:
 820           what = "devices";
 821           break;
 822         case GRUB_COMPLETION_TYPE_FILE:
 823           what = "files";
 824           break;
 825         case GRUB_COMPLETION_TYPE_PARTITION:
 826           what = "partitions";
 827           break;
 828         case GRUB_COMPLETION_TYPE_ARGUMENT:
 829           what = "arguments";
 830           break;
 831         default:
 832           what = "things";
 833           break;
 834         }
 835
 836       grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 837       grub_printf ("   Possible %s are:\n    ", what);
 838     }
 839
 840   /* Make sure that the completion buffer has enough room.  */
 841   if (completion_buffer.max_len < (completion_buffer.len
 842                                    + (int) grub_strlen (item) + 1 + 1))
 843     {
 844       grub_size_t new_len;
 845
 846       new_len = completion_buffer.len + grub_strlen (item) + 80;
 847       p = grub_realloc (completion_buffer.buf, new_len);
 848       if (! p)
 849         {
 850           /* Possibly not fatal.  */
 851           grub_errno = GRUB_ERR_NONE;
 852           return;
 853         }
 854       p[completion_buffer.len] = 0;
 855       completion_buffer.buf = p;
 856       completion_buffer.max_len = new_len;
 857     }
 858
 859   p = completion_buffer.buf + completion_buffer.len;
 860   if (completion_buffer.len != 0)
 861     {
 862       *p++ = ' ';
 863       completion_buffer.len++;
 864     }
 865   grub_strcpy (p, item);
 866   completion_buffer.len += grub_strlen (item);
 867 }
 868
 869 static int
 870 complete (struct screen *screen, int continuous, int update)
 871 {
 872   grub_uint16_t pos;
 873   char saved_char;
 874   struct line *linep;
 875   int restore;
 876   char *insert;
 877   static int count = -1;
 878
 879   if (continuous)
 880     count++;
 881   else
 882     count = 0;
 883
 884   pos = grub_getxy ();
 885   grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 886
 887   completion_buffer.buf = 0;
 888   completion_buffer.len = 0;
 889   completion_buffer.max_len = 0;
 890
 891   linep = screen->lines + screen->line;
 892   saved_char = linep->buf[screen->column];
 893   linep->buf[screen->column] = '\0';
 894
 895   insert = grub_normal_do_completion (linep->buf, &restore, store_completion);
 896
 897   linep->buf[screen->column] = saved_char;
 898
 899   if (restore)
 900     {
 901       char *p = completion_buffer.buf;
 902
 903       screen->completion_shown = 1;
 904
 905       if (p)
 906         {
 907           int num_sections = ((completion_buffer.len + GRUB_TERM_WIDTH - 8 - 1)
 908                               / (GRUB_TERM_WIDTH - 8));
 909           char *endp;
 910
 911           p += (count % num_sections) * (GRUB_TERM_WIDTH - 8);
 912           endp = p + (GRUB_TERM_WIDTH - 8);
 913
 914           if (p != completion_buffer.buf)
 915             grub_putcode (GRUB_TERM_DISP_LEFT);
 916           else
 917             grub_putchar (' ');
 918
 919           while (*p && p < endp)
 920             grub_putchar (*p++);
 921
 922           if (*p)
 923             grub_putcode (GRUB_TERM_DISP_RIGHT);
 924         }
 925     }
 926
 927   grub_gotoxy (pos >> 8, pos & 0xFF);
 928
 929   if (insert)
 930     {
 931       insert_string (screen, insert, update);
 932       count = -1;
 933       grub_free (insert);
 934     }
 935   else if (update)
 936     grub_refresh ();
 937
 938   grub_free (completion_buffer.buf);
 939   return 1;
 940 }
 941
 942 /* Clear displayed completions.  */
 943 static void
 944 clear_completions (void)
 945 {
 946   grub_uint16_t pos;
 947   int i, j;
 948
 949   pos = grub_getxy ();
 950   grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 951
 952   for (i = 0; i < 2; i++)
 953     {
 954       for (j = 0; j < GRUB_TERM_WIDTH - 1; j++)
 955         grub_putchar (' ');
 956       grub_putchar ('\n');
 957     }
 958
 959   grub_gotoxy (pos >> 8, pos & 0xFF);
 960   grub_refresh ();
 961 }
 962
 963 /* Execute the command list in the screen SCREEN.  */
 964 static int
 965 run (struct screen *screen)
 966 {
 967   int currline = 0;
 968   char *nextline;
 969
 970   auto grub_err_t editor_getline (char **line, int cont);
 971   grub_err_t editor_getline (char **line, int cont __attribute__ ((unused)))
 972     {
 973       struct line *linep = screen->lines + currline;
 974       char *p;
 975
 976       if (currline > screen->num_lines)
 977         {
 978           *line = 0;
 979           return 0;
 980         }
 981
 982       /* Trim down space characters.  */
 983       for (p = linep->buf + linep->len - 1;
 984            p >= linep->buf && grub_isspace (*p);
 985            p--)
 986         ;
 987       *++p = '\0';
 988
 989       linep->len = p - linep->buf;
 990       for (p = linep->buf; grub_isspace (*p); p++)
 991         ;
 992       *line = grub_strdup (p);
 993       currline++;
 994       return 0;
 995     }
 996
 997   grub_cls ();
 998   grub_printf ("  Booting a command list\n\n");
 999
1000
1001   /* Execute the script, line for line.  */
1002   while (currline < screen->num_lines)
1003     {
1004       editor_getline (&nextline, 0);
1005       if (grub_parser_get_current ()->parse_line (nextline, editor_getline))
1006         break;
1007     }
1008
1009   if (grub_errno == GRUB_ERR_NONE && grub_loader_is_loaded ())
1010     /* Implicit execution of boot, only if something is loaded.  */
1011     grub_command_execute ("boot", 0, 0);
1012
1013   if (grub_errno != GRUB_ERR_NONE)
1014     {
1015       grub_print_error ();
1016       grub_errno = GRUB_ERR_NONE;
1017       grub_wait_after_message ();
1018     }
1019
1020   return 1;
1021 }
1022
1023 /* Edit a menu entry with an Emacs-like interface.  */
1024 void
1025 grub_menu_entry_run (grub_menu_entry_t entry)
1026 {
1027   struct screen *screen;
1028   int prev_c;
1029
1030   screen = make_screen (entry);
1031   if (! screen)
1032     return;
1033
1034  refresh:
1035   /* Draw the screen.  */
1036   grub_menu_init_page (0, 1);
1037   update_screen (screen, 0, 0, 1, 1, ALL_LINES);
1038   grub_setcursor (1);
1039   prev_c = '\0';
1040
1041   while (1)
1042     {
1043       int c = GRUB_TERM_ASCII_CHAR (grub_getkey ());
1044
1045       if (screen->completion_shown)
1046         {
1047           clear_completions ();
1048           screen->completion_shown = 0;
1049         }
1050
1051       switch (c)
1052         {
1053         case 16: /* C-p */
1054           if (! previous_line (screen, 1))
1055             goto fail;
1056           break;
1057
1058         case 14: /* C-n */
1059           if (! next_line (screen, 1))
1060             goto fail;
1061           break;
1062
1063         case 6: /* C-f */
1064           if (! forward_char (screen, 1))
1065             goto fail;
1066           break;
1067
1068         case 2: /* C-b */
1069           if (! backward_char (screen, 1))
1070             goto fail;
1071           break;
1072
1073         case 1: /* C-a */
1074           if (! beginning_of_line (screen, 1))
1075             goto fail;
1076           break;
1077
1078         case 5: /* C-e */
1079           if (! end_of_line (screen, 1))
1080             goto fail;
1081           break;
1082
1083         case '\t': /* C-i */
1084           if (! complete (screen, prev_c == c, 1))
1085             goto fail;
1086           break;
1087
1088         case 4: /* C-d */
1089           if (! delete_char (screen, 1))
1090             goto fail;
1091           break;
1092
1093         case 8: /* C-h */
1094           if (! backward_delete_char (screen, 1))
1095             goto fail;
1096           break;
1097
1098         case 11: /* C-k */
1099           if (! kill_line (screen, prev_c == c, 1))
1100             goto fail;
1101           break;
1102
1103         case 21: /* C-u */
1104           /* FIXME: What behavior is good for this key?  */
1105           break;
1106
1107         case 25: /* C-y */
1108           if (! yank (screen, 1))
1109             goto fail;
1110           break;
1111
1112         case 12: /* C-l */
1113           /* FIXME: centering.  */
1114           goto refresh;
1115
1116         case 15: /* C-o */
1117           if (! open_line (screen, 1))
1118             goto fail;
1119           break;
1120
1121         case '\n':
1122         case '\r':
1123           if (! insert_string (screen, "\n", 1))
1124             goto fail;
1125           break;
1126
1127         case '\e':
1128           destroy_screen (screen);
1129           return;
1130
1131         case 3: /* C-c */
1132           grub_cmdline_run (1);
1133           goto refresh;
1134
1135         case 24: /* C-x */
1136           if (! run (screen))
1137             goto fail;
1138           goto refresh;
1139
1140         case 18: /* C-r */
1141         case 19: /* C-s */
1142         case 20: /* C-t */
1143           /* FIXME */
1144           break;
1145
1146         default:
1147           if (grub_isprint (c))
1148             {
1149               char buf[2];
1150
1151               buf[0] = c;
1152               buf[1] = '\0';
1153               if (! insert_string (screen, buf, 1))
1154                 goto fail;
1155             }
1156           break;
1157         }
1158
1159       prev_c = c;
1160     }
1161
1162  fail:
1163   destroy_screen (screen);
1164
1165   grub_cls ();
1166   grub_print_error ();
1167   grub_errno = GRUB_ERR_NONE;
1168   grub_printf ("\nPress any key to continue...");
1169   (void) grub_getkey ();
1170 }