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_malloc (sizeof (*screen));
 420   if (! screen)
 421     return 0;
 422
 423   screen->num_lines = 1;
 424   screen->column = 0;
 425   screen->real_column = 0;
 426   screen->line = 0;
 427   screen->x = 0;
 428   screen->y = 0;
 429   screen->killed_text = 0;
 430   screen->completion_shown = 0;
 431   screen->lines = grub_malloc (sizeof (struct line));
 432   if (! screen->lines)
 433     goto fail;
 434
 435   /* Initialize the first line which must be always present.  */
 436   if (! init_line (screen->lines))
 437     goto fail;
 438
 439   insert_string (screen, (char *) entry->sourcecode, 0);
 440
 441   /* Reset the cursor position.  */
 442   screen->column = 0;
 443   screen->real_column = 0;
 444   screen->line = 0;
 445   screen->x = 0;
 446   screen->y = 0;
 447
 448   return screen;
 449
 450  fail:
 451   destroy_screen (screen);
 452   return 0;
 453 }
 454
 455 static int
 456 forward_char (struct screen *screen, int update)
 457 {
 458   struct line *linep;
 459
 460   linep = screen->lines + screen->line;
 461   if (screen->column < linep->len)
 462     {
 463       screen->column++;
 464       screen->x++;
 465       if (screen->x == GRUB_TERM_ENTRY_WIDTH)
 466         {
 467           screen->x = 0;
 468           screen->y++;
 469         }
 470     }
 471   else if (screen->num_lines > screen->line + 1)
 472     {
 473       screen->column = 0;
 474       screen->line++;
 475       screen->x = 0;
 476       screen->y++;
 477     }
 478
 479   screen->real_column = screen->column;
 480
 481   if (update)
 482     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 483   return 1;
 484 }
 485
 486 static int
 487 backward_char (struct screen *screen, int update)
 488 {
 489   if (screen->column > 0)
 490     {
 491       screen->column--;
 492       screen->x--;
 493       if (screen->x == -1)
 494         {
 495           screen->x = GRUB_TERM_ENTRY_WIDTH - 1;
 496           screen->y--;
 497         }
 498     }
 499   else if (screen->line > 0)
 500     {
 501       struct line *linep;
 502
 503       screen->line--;
 504       linep = screen->lines + screen->line;
 505       screen->column = linep->len;
 506       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 507       screen->y--;
 508     }
 509
 510   screen->real_column = screen->column;
 511
 512   if (update)
 513     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 514
 515   return 1;
 516 }
 517
 518 static int
 519 previous_line (struct screen *screen, int update)
 520 {
 521   if (screen->line > 0)
 522     {
 523       struct line *linep;
 524       int dy;
 525
 526       /* How many physical lines from the current position
 527          to the first physical line?  */
 528       dy = screen->column / GRUB_TERM_ENTRY_WIDTH;
 529
 530       screen->line--;
 531
 532       linep = screen->lines + screen->line;
 533       if (linep->len < screen->real_column)
 534         screen->column = linep->len;
 535       else
 536         screen->column = screen->real_column;
 537
 538       /* How many physical lines from the current position
 539          to the last physical line?  */
 540       dy += (linep->len / GRUB_TERM_ENTRY_WIDTH
 541              - screen->column / GRUB_TERM_ENTRY_WIDTH);
 542
 543       screen->y -= dy + 1;
 544       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 545     }
 546   else
 547     {
 548       screen->y -= screen->column / GRUB_TERM_ENTRY_WIDTH;
 549       screen->column = 0;
 550       screen->x = 0;
 551     }
 552
 553   if (update)
 554     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 555
 556   return 1;
 557 }
 558
 559 static int
 560 next_line (struct screen *screen, int update)
 561 {
 562   if (screen->line < screen->num_lines - 1)
 563     {
 564       struct line *linep;
 565       int dy;
 566
 567       /* How many physical lines from the current position
 568          to the last physical line?  */
 569       linep = screen->lines + screen->line;
 570       dy = (linep->len / GRUB_TERM_ENTRY_WIDTH
 571             - screen->column / GRUB_TERM_ENTRY_WIDTH);
 572
 573       screen->line++;
 574
 575       linep++;
 576       if (linep->len < screen->real_column)
 577         screen->column = linep->len;
 578       else
 579         screen->column = screen->real_column;
 580
 581       /* How many physical lines from the current position
 582          to the first physical line?  */
 583       dy += screen->column / GRUB_TERM_ENTRY_WIDTH;
 584
 585       screen->y += dy + 1;
 586       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 587     }
 588   else
 589     {
 590       struct line *linep;
 591
 592       linep = screen->lines + screen->line;
 593       screen->y += (linep->len / GRUB_TERM_ENTRY_WIDTH
 594                     - screen->column / GRUB_TERM_ENTRY_WIDTH);
 595       screen->column = linep->len;
 596       screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 597     }
 598
 599   if (update)
 600     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 601
 602   return 1;
 603 }
 604
 605 static int
 606 beginning_of_line (struct screen *screen, int update)
 607 {
 608   screen->y -= screen->column / GRUB_TERM_ENTRY_WIDTH;
 609   screen->column = screen->real_column = 0;
 610   screen->x = 0;
 611
 612   if (update)
 613     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 614
 615   return 1;
 616 }
 617
 618 static int
 619 end_of_line (struct screen *screen, int update)
 620 {
 621   struct line *linep;
 622
 623   linep = screen->lines + screen->line;
 624   screen->y += (linep->len / GRUB_TERM_ENTRY_WIDTH
 625                 - screen->column / GRUB_TERM_ENTRY_WIDTH);
 626   screen->column = screen->real_column = linep->len;
 627   screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
 628
 629   if (update)
 630     update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
 631
 632   return 1;
 633 }
 634
 635 static int
 636 delete_char (struct screen *screen, int update)
 637 {
 638   struct line *linep;
 639   enum update_mode mode = NO_LINE;
 640   int start = screen->num_lines;
 641   int column = 0;
 642   int down = 0;
 643
 644   linep = screen->lines + screen->line;
 645   if (linep->len > screen->column)
 646     {
 647       int orig_num, new_num;
 648
 649       orig_num = get_logical_num_lines (linep);
 650
 651       grub_memmove (linep->buf + screen->column,
 652                     linep->buf + screen->column + 1,
 653                     linep->len - screen->column - 1);
 654       linep->len--;
 655
 656       new_num = get_logical_num_lines (linep);
 657
 658       if (orig_num != new_num)
 659         mode = ALL_LINES;
 660       else
 661         mode = SINGLE_LINE;
 662
 663       start = screen->line;
 664       column = screen->column;
 665     }
 666   else if (screen->num_lines > screen->line + 1)
 667     {
 668       struct line *next_linep;
 669
 670       next_linep = linep + 1;
 671       if (! ensure_space (linep, next_linep->len))
 672         return 0;
 673
 674       grub_memmove (linep->buf + linep->len, next_linep->buf, next_linep->len);
 675       linep->len += next_linep->len;
 676
 677       grub_free (next_linep->buf);
 678       grub_memmove (next_linep,
 679                     next_linep + 1,
 680                     (screen->num_lines - screen->line - 2)
 681                     * sizeof (struct line));
 682       screen->num_lines--;
 683
 684       mode = ALL_LINES;
 685       start = screen->line;
 686       column = screen->column;
 687       down = 1;
 688     }
 689
 690   screen->real_column = screen->column;
 691
 692   if (update)
 693     update_screen (screen, start, column, 0, down, mode);
 694
 695   return 1;
 696 }
 697
 698 static int
 699 backward_delete_char (struct screen *screen, int update)
 700 {
 701   int saved_column;
 702   int saved_line;
 703
 704   saved_column = screen->column;
 705   saved_line = screen->line;
 706
 707   if (! backward_char (screen, 0))
 708     return 0;
 709
 710   if (saved_column != screen->column || saved_line != screen->line)
 711     if (! delete_char (screen, update))
 712       return 0;
 713
 714   return 1;
 715 }
 716
 717 static int
 718 kill_line (struct screen *screen, int continuous, int update)
 719 {
 720   struct line *linep;
 721   char *p;
 722   int size;
 723   int offset;
 724
 725   p = screen->killed_text;
 726   if (! continuous && p)
 727     p[0] = '\0';
 728
 729   linep = screen->lines + screen->line;
 730   size = linep->len - screen->column;
 731
 732   if (p)
 733     offset = grub_strlen (p);
 734   else
 735     offset = 0;
 736
 737   if (size > 0)
 738     {
 739       enum update_mode mode = SINGLE_LINE;
 740       int down = 0;
 741       int orig_num, new_num;
 742
 743       p = grub_realloc (p, offset + size + 1);
 744       if (! p)
 745         return 0;
 746
 747       grub_memmove (p + offset, linep->buf + screen->column, size);
 748       p[offset + size - 1] = '\0';
 749
 750       screen->killed_text = p;
 751
 752       orig_num = get_logical_num_lines (linep);
 753       linep->len = screen->column;
 754       new_num = get_logical_num_lines (linep);
 755
 756       if (orig_num != new_num)
 757         {
 758           mode = ALL_LINES;
 759           down = 1;
 760         }
 761
 762       if (update)
 763         update_screen (screen, screen->line, screen->column, 0, down, mode);
 764     }
 765   else if (screen->line + 1 < screen->num_lines)
 766     {
 767       p = grub_realloc (p, offset + 1 + 1);
 768       if (! p)
 769         return 0;
 770
 771       p[offset] = '\n';
 772       p[offset + 1] = '\0';
 773
 774       screen->killed_text = p;
 775
 776       return delete_char (screen, update);
 777     }
 778
 779   return 1;
 780 }
 781
 782 static int
 783 yank (struct screen *screen, int update)
 784 {
 785   if (screen->killed_text)
 786     return insert_string (screen, screen->killed_text, update);
 787
 788   return 1;
 789 }
 790
 791 static int
 792 open_line (struct screen *screen, int update)
 793 {
 794   int saved_y = screen->y;
 795
 796   if (! insert_string (screen, "\n", 0))
 797     return 0;
 798
 799   if (! backward_char (screen, 0))
 800     return 0;
 801
 802   screen->y = saved_y;
 803
 804   if (update)
 805     update_screen (screen, screen->line, screen->column, 0, 1, ALL_LINES);
 806
 807   return 1;
 808 }
 809
 810 /* A completion hook to print items.  */
 811 static void
 812 store_completion (const char *item, grub_completion_type_t type, int count)
 813 {
 814   char *p;
 815
 816   if (count == 0)
 817     {
 818       /* If this is the first time, print a label.  */
 819       const char *what;
 820
 821       switch (type)
 822         {
 823         case GRUB_COMPLETION_TYPE_COMMAND:
 824           what = "commands";
 825           break;
 826         case GRUB_COMPLETION_TYPE_DEVICE:
 827           what = "devices";
 828           break;
 829         case GRUB_COMPLETION_TYPE_FILE:
 830           what = "files";
 831           break;
 832         case GRUB_COMPLETION_TYPE_PARTITION:
 833           what = "partitions";
 834           break;
 835         case GRUB_COMPLETION_TYPE_ARGUMENT:
 836           what = "arguments";
 837           break;
 838         default:
 839           what = "things";
 840           break;
 841         }
 842
 843       grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 844       grub_printf ("   Possible %s are:\n    ", what);
 845     }
 846
 847   /* Make sure that the completion buffer has enough room.  */
 848   if (completion_buffer.max_len < (completion_buffer.len
 849                                    + (int) grub_strlen (item) + 1 + 1))
 850     {
 851       grub_size_t new_len;
 852
 853       new_len = completion_buffer.len + grub_strlen (item) + 80;
 854       p = grub_realloc (completion_buffer.buf, new_len);
 855       if (! p)
 856         {
 857           /* Possibly not fatal.  */
 858           grub_errno = GRUB_ERR_NONE;
 859           return;
 860         }
 861       p[completion_buffer.len] = 0;
 862       completion_buffer.buf = p;
 863       completion_buffer.max_len = new_len;
 864     }
 865
 866   p = completion_buffer.buf + completion_buffer.len;
 867   if (completion_buffer.len != 0)
 868     {
 869       *p++ = ' ';
 870       completion_buffer.len++;
 871     }
 872   grub_strcpy (p, item);
 873   completion_buffer.len += grub_strlen (item);
 874 }
 875
 876 static int
 877 complete (struct screen *screen, int continuous, int update)
 878 {
 879   grub_uint16_t pos;
 880   char saved_char;
 881   struct line *linep;
 882   int restore;
 883   char *insert;
 884   static int count = -1;
 885
 886   if (continuous)
 887     count++;
 888   else
 889     count = 0;
 890
 891   pos = grub_getxy ();
 892   grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 893
 894   completion_buffer.buf = 0;
 895   completion_buffer.len = 0;
 896   completion_buffer.max_len = 0;
 897
 898   linep = screen->lines + screen->line;
 899   saved_char = linep->buf[screen->column];
 900   linep->buf[screen->column] = '\0';
 901
 902   insert = grub_normal_do_completion (linep->buf, &restore, store_completion);
 903
 904   linep->buf[screen->column] = saved_char;
 905
 906   if (restore)
 907     {
 908       char *p = completion_buffer.buf;
 909
 910       screen->completion_shown = 1;
 911
 912       if (p)
 913         {
 914           int num_sections = ((completion_buffer.len + GRUB_TERM_WIDTH - 8 - 1)
 915                               / (GRUB_TERM_WIDTH - 8));
 916           char *endp;
 917
 918           p += (count % num_sections) * (GRUB_TERM_WIDTH - 8);
 919           endp = p + (GRUB_TERM_WIDTH - 8);
 920
 921           if (p != completion_buffer.buf)
 922             grub_putcode (GRUB_TERM_DISP_LEFT);
 923           else
 924             grub_putchar (' ');
 925
 926           while (*p && p < endp)
 927             grub_putchar (*p++);
 928
 929           if (*p)
 930             grub_putcode (GRUB_TERM_DISP_RIGHT);
 931         }
 932     }
 933
 934   grub_gotoxy (pos >> 8, pos & 0xFF);
 935
 936   if (insert)
 937     {
 938       insert_string (screen, insert, update);
 939       count = -1;
 940       grub_free (insert);
 941     }
 942   else if (update)
 943     grub_refresh ();
 944
 945   grub_free (completion_buffer.buf);
 946   return 1;
 947 }
 948
 949 /* Clear displayed completions.  */
 950 static void
 951 clear_completions (void)
 952 {
 953   grub_uint16_t pos;
 954   int i, j;
 955
 956   pos = grub_getxy ();
 957   grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 958
 959   for (i = 0; i < 2; i++)
 960     {
 961       for (j = 0; j < GRUB_TERM_WIDTH - 1; j++)
 962         grub_putchar (' ');
 963       grub_putchar ('\n');
 964     }
 965
 966   grub_gotoxy (pos >> 8, pos & 0xFF);
 967   grub_refresh ();
 968 }
 969
 970 /* Execute the command list in the screen SCREEN.  */
 971 static int
 972 run (struct screen *screen)
 973 {
 974   int currline = 0;
 975   char *nextline;
 976
 977   auto grub_err_t editor_getline (char **line, int cont);
 978   grub_err_t editor_getline (char **line, int cont __attribute__ ((unused)))
 979     {
 980       struct line *linep = screen->lines + currline;
 981       char *p;
 982
 983       if (currline > screen->num_lines)
 984         {
 985           *line = 0;
 986           return 0;
 987         }
 988
 989       /* Trim down space characters.  */
 990       for (p = linep->buf + linep->len - 1;
 991            p >= linep->buf && grub_isspace (*p);
 992            p--)
 993         ;
 994       *++p = '\0';
 995
 996       linep->len = p - linep->buf;
 997       for (p = linep->buf; grub_isspace (*p); p++)
 998         ;
 999       *line = grub_strdup (p);
1000       currline++;
1001       return 0;
1002     }
1003
1004   grub_cls ();
1005   grub_printf ("  Booting a command list\n\n");
1006
1007
1008   /* Execute the script, line for line.  */
1009   while (currline < screen->num_lines)
1010     {
1011       editor_getline (&nextline, 0);
1012       if (grub_parser_get_current ()->parse_line (nextline, editor_getline))
1013         break;
1014     }
1015
1016   if (grub_errno == GRUB_ERR_NONE && grub_loader_is_loaded ())
1017     /* Implicit execution of boot, only if something is loaded.  */
1018     grub_command_execute ("boot", 0, 0);
1019
1020   if (grub_errno != GRUB_ERR_NONE)
1021     {
1022       grub_print_error ();
1023       grub_errno = GRUB_ERR_NONE;
1024       grub_wait_after_message ();
1025     }
1026
1027   return 1;
1028 }
1029
1030 /* Edit a menu entry with an Emacs-like interface.  */
1031 void
1032 grub_menu_entry_run (grub_menu_entry_t entry)
1033 {
1034   struct screen *screen;
1035   int prev_c;
1036
1037   screen = make_screen (entry);
1038   if (! screen)
1039     return;
1040
1041  refresh:
1042   /* Draw the screen.  */
1043   grub_menu_init_page (0, 1);
1044   update_screen (screen, 0, 0, 1, 1, ALL_LINES);
1045   grub_setcursor (1);
1046   prev_c = '\0';
1047
1048   while (1)
1049     {
1050       int c = GRUB_TERM_ASCII_CHAR (grub_getkey ());
1051
1052       if (screen->completion_shown)
1053         {
1054           clear_completions ();
1055           screen->completion_shown = 0;
1056         }
1057
1058       switch (c)
1059         {
1060         case 16: /* C-p */
1061           if (! previous_line (screen, 1))
1062             goto fail;
1063           break;
1064
1065         case 14: /* C-n */
1066           if (! next_line (screen, 1))
1067             goto fail;
1068           break;
1069
1070         case 6: /* C-f */
1071           if (! forward_char (screen, 1))
1072             goto fail;
1073           break;
1074
1075         case 2: /* C-b */
1076           if (! backward_char (screen, 1))
1077             goto fail;
1078           break;
1079
1080         case 1: /* C-a */
1081           if (! beginning_of_line (screen, 1))
1082             goto fail;
1083           break;
1084
1085         case 5: /* C-e */
1086           if (! end_of_line (screen, 1))
1087             goto fail;
1088           break;
1089
1090         case '\t': /* C-i */
1091           if (! complete (screen, prev_c == c, 1))
1092             goto fail;
1093           break;
1094
1095         case 4: /* C-d */
1096           if (! delete_char (screen, 1))
1097             goto fail;
1098           break;
1099
1100         case 8: /* C-h */
1101           if (! backward_delete_char (screen, 1))
1102             goto fail;
1103           break;
1104
1105         case 11: /* C-k */
1106           if (! kill_line (screen, prev_c == c, 1))
1107             goto fail;
1108           break;
1109
1110         case 21: /* C-u */
1111           /* FIXME: What behavior is good for this key?  */
1112           break;
1113
1114         case 25: /* C-y */
1115           if (! yank (screen, 1))
1116             goto fail;
1117           break;
1118
1119         case 12: /* C-l */
1120           /* FIXME: centering.  */
1121           goto refresh;
1122
1123         case 15: /* C-o */
1124           if (! open_line (screen, 1))
1125             goto fail;
1126           break;
1127
1128         case '\n':
1129         case '\r':
1130           if (! insert_string (screen, "\n", 1))
1131             goto fail;
1132           break;
1133
1134         case '\e':
1135           destroy_screen (screen);
1136           return;
1137
1138         case 3: /* C-c */
1139           grub_cmdline_run (1);
1140           goto refresh;
1141
1142         case 24: /* C-x */
1143           if (! run (screen))
1144             goto fail;
1145           goto refresh;
1146
1147         case 18: /* C-r */
1148         case 19: /* C-s */
1149         case 20: /* C-t */
1150           /* FIXME */
1151           break;
1152
1153         default:
1154           if (grub_isprint (c))
1155             {
1156               char buf[2];
1157
1158               buf[0] = c;
1159               buf[1] = '\0';
1160               if (! insert_string (screen, buf, 1))
1161                 goto fail;
1162             }
1163           break;
1164         }
1165
1166       prev_c = c;
1167     }
1168
1169  fail:
1170   destroy_screen (screen);
1171
1172   grub_cls ();
1173   grub_print_error ();
1174   grub_errno = GRUB_ERR_NONE;
1175   grub_printf ("\nPress any key to continue...");
1176   (void) grub_getkey ();
1177 }