diff options
Diffstat (limited to 'grub-core/term/terminfo.c')
| -rw-r--r-- | grub-core/term/terminfo.c | 796 |
1 files changed, 796 insertions, 0 deletions
diff --git a/grub-core/term/terminfo.c b/grub-core/term/terminfo.c new file mode 100644 index 0000000..85ecf06 --- /dev/null +++ b/grub-core/term/terminfo.c @@ -0,0 +1,796 @@ +/* terminfo.c - simple terminfo module */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2003,2004,2005,2007 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see <http://www.gnu.org/licenses/>. + */ + +/* + * This file contains various functions dealing with different + * terminal capabilities. For example, vt52 and vt100. + */ + +#include <grub/types.h> +#include <grub/misc.h> +#include <grub/mm.h> +#include <grub/err.h> +#include <grub/dl.h> +#include <grub/term.h> +#include <grub/terminfo.h> +#include <grub/tparm.h> +#include <grub/extcmd.h> +#include <grub/i18n.h> +#include <grub/time.h> +#if defined(__powerpc__) && defined(GRUB_MACHINE_IEEE1275) +#include <grub/ieee1275/ieee1275.h> +#endif + +GRUB_MOD_LICENSE ("GPLv3+"); + +#define ANSI_CSI 0x9b +#define ANSI_CSI_STR "\x9b" + +static struct grub_term_output *terminfo_outputs; + +/* Get current terminfo name. */ +char * +grub_terminfo_get_current (struct grub_term_output *term) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + return data->name; +} + +/* Free *PTR and set *PTR to NULL, to prevent double-free. */ +static void +grub_terminfo_free (char **ptr) +{ + grub_free (*ptr); + *ptr = 0; +} + +static void +grub_terminfo_all_free (struct grub_term_output *term) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + /* Free previously allocated memory. */ + grub_terminfo_free (&data->name); + grub_terminfo_free (&data->gotoxy); + grub_terminfo_free (&data->cls); + grub_terminfo_free (&data->reverse_video_on); + grub_terminfo_free (&data->reverse_video_off); + grub_terminfo_free (&data->cursor_on); + grub_terminfo_free (&data->cursor_off); +} + +/* Set current terminfo type. */ +grub_err_t +grub_terminfo_set_current (struct grub_term_output *term, + const char *str) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + /* TODO + * Lookup user specified terminfo type. If found, set term variables + * as appropriate. Otherwise return an error. + * + * How should this be done? + * a. A static table included in this module. + * - I do not like this idea. + * b. A table stored in the configuration directory. + * - Users must convert their terminfo settings if we have not already. + * c. Look for terminfo files in the configuration directory. + * - /usr/share/terminfo is 6.3M on my system. + * - /usr/share/terminfo is not on most users boot partition. + * + Copying the terminfo files you want to use to the grub + * configuration directory is easier then (b). + * d. Your idea here. + */ + + grub_terminfo_all_free (term); + + if (grub_strcmp ("vt100", str) == 0) + { + data->name = grub_strdup ("vt100"); + data->gotoxy = grub_strdup ("\e[%i%p1%d;%p2%dH"); + data->cls = grub_strdup ("\e[H\e[J"); + data->reverse_video_on = grub_strdup ("\e[7m"); + data->reverse_video_off = grub_strdup ("\e[m"); + data->cursor_on = grub_strdup ("\e[?25h"); + data->cursor_off = grub_strdup ("\e[?25l"); + data->setcolor = NULL; + return grub_errno; + } + + if (grub_strcmp ("vt100-color", str) == 0) + { + data->name = grub_strdup ("vt100-color"); + data->gotoxy = grub_strdup ("\e[%i%p1%d;%p2%dH"); + data->cls = grub_strdup ("\e[H\e[J"); + data->reverse_video_on = grub_strdup ("\e[7m"); + data->reverse_video_off = grub_strdup ("\e[m"); + data->cursor_on = grub_strdup ("\e[?25h"); + data->cursor_off = grub_strdup ("\e[?25l"); + data->setcolor = grub_strdup ("\e[3%p1%dm\e[4%p2%dm"); + return grub_errno; + } + + if (grub_strcmp ("arc", str) == 0) + { + data->name = grub_strdup ("arc"); + data->gotoxy = grub_strdup (ANSI_CSI_STR "%i%p1%d;%p2%dH"); + data->cls = grub_strdup (ANSI_CSI_STR "2J"); + data->reverse_video_on = grub_strdup (ANSI_CSI_STR "7m"); + data->reverse_video_off = grub_strdup (ANSI_CSI_STR "0m"); + data->cursor_on = 0; + data->cursor_off = 0; + data->setcolor = grub_strdup (ANSI_CSI_STR "3%p1%dm" + ANSI_CSI_STR "4%p2%dm"); + return grub_errno; + } + + if (grub_strcmp ("ieee1275", str) == 0 + || grub_strcmp ("ieee1275-nocursor", str) == 0) + { + data->name = grub_strdup ("ieee1275"); + data->gotoxy = grub_strdup ("\e[%i%p1%d;%p2%dH"); + /* Clear the screen. Using serial console, screen(1) only recognizes the + * ANSI escape sequence. Using video console, Apple Open Firmware + * (version 3.1.1) only recognizes the literal ^L. So use both. */ + data->cls = grub_strdup (" \e[2J"); + data->reverse_video_on = grub_strdup ("\e[7m"); + data->reverse_video_off = grub_strdup ("\e[m"); + if (grub_strcmp ("ieee1275", str) == 0) + { + data->cursor_on = grub_strdup ("\e[?25h"); + data->cursor_off = grub_strdup ("\e[?25l"); + } + else + { + data->cursor_on = 0; + data->cursor_off = 0; + } + data->setcolor = grub_strdup ("\e[3%p1%dm\e[4%p2%dm"); + return grub_errno; + } + + if (grub_strcmp ("dumb", str) == 0) + { + data->name = grub_strdup ("dumb"); + data->gotoxy = NULL; + data->cls = NULL; + data->reverse_video_on = NULL; + data->reverse_video_off = NULL; + data->cursor_on = NULL; + data->cursor_off = NULL; + data->setcolor = NULL; + return grub_errno; + } + + return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("unknown terminfo type `%s'"), + str); +} + +grub_err_t +grub_terminfo_output_register (struct grub_term_output *term, + const char *type) +{ + grub_err_t err; + struct grub_terminfo_output_state *data; + + err = grub_terminfo_set_current (term, type); + + if (err) + return err; + + data = (struct grub_terminfo_output_state *) term->data; + data->next = terminfo_outputs; + terminfo_outputs = term; + + return GRUB_ERR_NONE; +} + +grub_err_t +grub_terminfo_output_unregister (struct grub_term_output *term) +{ + struct grub_term_output **ptr; + + for (ptr = &terminfo_outputs; *ptr; + ptr = &((struct grub_terminfo_output_state *) (*ptr)->data)->next) + if (*ptr == term) + { + grub_terminfo_all_free (term); + *ptr = ((struct grub_terminfo_output_state *) (*ptr)->data)->next; + return GRUB_ERR_NONE; + } + return grub_error (GRUB_ERR_BUG, "terminal not found"); +} + +/* Wrapper for grub_putchar to write strings. */ +static void +putstr (struct grub_term_output *term, const char *str) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + while (*str) + data->put (term, *str++); +} + +struct grub_term_coordinate +grub_terminfo_getxy (struct grub_term_output *term) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + return data->pos; +} + +void +grub_terminfo_gotoxy (struct grub_term_output *term, + struct grub_term_coordinate pos) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + if (pos.x > grub_term_width (term) || pos.y > grub_term_height (term)) + { + grub_error (GRUB_ERR_BUG, "invalid point (%u,%u)", pos.x, pos.y); + return; + } + + if (data->gotoxy) + putstr (term, grub_terminfo_tparm (data->gotoxy, pos.y, pos.x)); + else + { + if ((pos.y == data->pos.y) && (pos.x == data->pos.x - 1)) + data->put (term, '\b'); + } + + data->pos = pos; +} + +/* Clear the screen. */ +void +grub_terminfo_cls (struct grub_term_output *term) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + putstr (term, grub_terminfo_tparm (data->cls)); + grub_terminfo_gotoxy (term, (struct grub_term_coordinate) { 0, 0 }); +} + +void +grub_terminfo_setcolorstate (struct grub_term_output *term, + const grub_term_color_state state) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + if (data->setcolor) + { + int fg; + int bg; + /* Map from VGA to terminal colors. */ + const int colormap[8] + = { 0, /* Black. */ + 4, /* Blue. */ + 2, /* Green. */ + 6, /* Cyan. */ + 1, /* Red. */ + 5, /* Magenta. */ + 3, /* Yellow. */ + 7, /* White. */ + }; + + switch (state) + { + case GRUB_TERM_COLOR_STANDARD: + case GRUB_TERM_COLOR_NORMAL: + fg = grub_term_normal_color & 0x0f; + bg = grub_term_normal_color >> 4; + break; + case GRUB_TERM_COLOR_HIGHLIGHT: + fg = grub_term_highlight_color & 0x0f; + bg = grub_term_highlight_color >> 4; + break; + default: + return; + } + + putstr (term, grub_terminfo_tparm (data->setcolor, colormap[fg & 7], + colormap[bg & 7])); + return; + } + + switch (state) + { + case GRUB_TERM_COLOR_STANDARD: + case GRUB_TERM_COLOR_NORMAL: + putstr (term, grub_terminfo_tparm (data->reverse_video_off)); + break; + case GRUB_TERM_COLOR_HIGHLIGHT: + putstr (term, grub_terminfo_tparm (data->reverse_video_on)); + break; + default: + break; + } +} + +void +grub_terminfo_setcursor (struct grub_term_output *term, const int on) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + if (on) + putstr (term, grub_terminfo_tparm (data->cursor_on)); + else + putstr (term, grub_terminfo_tparm (data->cursor_off)); +} + +/* The terminfo version of putchar. */ +void +grub_terminfo_putchar (struct grub_term_output *term, + const struct grub_unicode_glyph *c) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + /* Keep track of the cursor. */ + switch (c->base) + { + case '\a': + break; + + case '\b': + case 127: + if (data->pos.x > 0) + data->pos.x--; + break; + + case '\n': + if (data->pos.y < grub_term_height (term) - 1) + data->pos.y++; + break; + + case '\r': + data->pos.x = 0; + break; + + default: + if ((int) data->pos.x + c->estimated_width >= (int) grub_term_width (term) + 1) + { + data->pos.x = 0; + if (data->pos.y < grub_term_height (term) - 1) + data->pos.y++; + data->put (term, '\r'); + data->put (term, '\n'); + } + data->pos.x += c->estimated_width; + break; + } + + data->put (term, c->base); +} + +struct grub_term_coordinate +grub_terminfo_getwh (struct grub_term_output *term) +{ + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) term->data; + + return data->size; +} + +static void +grub_terminfo_readkey (struct grub_term_input *term, int *keys, int *len, int max_len, + int (*readkey) (struct grub_term_input *term)) +{ + int c; + +#define CONTINUE_READ \ + { \ + grub_uint64_t start; \ + /* On 9600 we have to wait up to 12 milliseconds. */ \ + start = grub_get_time_ms (); \ + do \ + c = readkey (term); \ + while (c == -1 && grub_get_time_ms () - start < 100); \ + if (c == -1) \ + return; \ + \ + if (*len >= max_len) \ + return; \ + \ + keys[*len] = c; \ + (*len)++; \ + } + + c = readkey (term); + if (c < 0) + { + *len = 0; + return; + } + *len = 1; + keys[0] = c; + if (c != ANSI_CSI && c != GRUB_TERM_ESC) + { + /* Backspace: Ctrl-h. */ + if (c == 0x7f) + c = GRUB_TERM_BACKSPACE; + if (c < 0x20 && c != GRUB_TERM_TAB && c!= GRUB_TERM_BACKSPACE && c != '\n' && c != '\r') + c = GRUB_TERM_CTRL | (c - 1 + 'a'); + *len = 1; + keys[0] = c; + return; + } + + { + static struct + { + char key; + unsigned ascii; + } + three_code_table[] = + { + {'4', GRUB_TERM_KEY_DC}, + {'A', GRUB_TERM_KEY_UP}, + {'B', GRUB_TERM_KEY_DOWN}, + {'C', GRUB_TERM_KEY_RIGHT}, + {'D', GRUB_TERM_KEY_LEFT}, + {'F', GRUB_TERM_KEY_END}, + {'H', GRUB_TERM_KEY_HOME}, + {'K', GRUB_TERM_KEY_END}, + {'P', GRUB_TERM_KEY_DC}, + {'?', GRUB_TERM_KEY_PPAGE}, + {'/', GRUB_TERM_KEY_NPAGE}, + {'@', GRUB_TERM_KEY_INSERT}, + }; + + static unsigned four_code_table[] = + { + [1] = GRUB_TERM_KEY_HOME, + [3] = GRUB_TERM_KEY_DC, + [5] = GRUB_TERM_KEY_PPAGE, + [6] = GRUB_TERM_KEY_NPAGE, + [7] = GRUB_TERM_KEY_HOME, + [8] = GRUB_TERM_KEY_END, + [17] = GRUB_TERM_KEY_F6, + [18] = GRUB_TERM_KEY_F7, + [19] = GRUB_TERM_KEY_F8, + [20] = GRUB_TERM_KEY_F9, + [21] = GRUB_TERM_KEY_F10, + [23] = GRUB_TERM_KEY_F11, + [24] = GRUB_TERM_KEY_F12, + }; + char fx_key[] = + { 'P', 'Q', 'w', 'x', 't', 'u', + 'q', 'r', 'p', 'M', 'A', 'B', 'H', 'F' }; + unsigned fx_code[] = + { GRUB_TERM_KEY_F1, GRUB_TERM_KEY_F2, GRUB_TERM_KEY_F3, + GRUB_TERM_KEY_F4, GRUB_TERM_KEY_F5, GRUB_TERM_KEY_F6, + GRUB_TERM_KEY_F7, GRUB_TERM_KEY_F8, GRUB_TERM_KEY_F9, + GRUB_TERM_KEY_F10, GRUB_TERM_KEY_F11, GRUB_TERM_KEY_F12, + GRUB_TERM_KEY_HOME, GRUB_TERM_KEY_END }; + unsigned i; + + if (c == GRUB_TERM_ESC) + { + CONTINUE_READ; + + if (c == 'O') + { + CONTINUE_READ; + + for (i = 0; i < ARRAY_SIZE (fx_key); i++) + if (fx_key[i] == c) + { + keys[0] = fx_code[i]; + *len = 1; + return; + } + } + + if (c != '[') + return; + } + + CONTINUE_READ; + + for (i = 0; i < ARRAY_SIZE (three_code_table); i++) + if (three_code_table[i].key == c) + { + keys[0] = three_code_table[i].ascii; + *len = 1; + return; + } + + switch (c) + { + case '[': + CONTINUE_READ; + if (c >= 'A' && c <= 'E') + { + keys[0] = GRUB_TERM_KEY_F1 + c - 'A'; + *len = 1; + return; + } + return; + case 'O': + CONTINUE_READ; + for (i = 0; i < ARRAY_SIZE (fx_key); i++) + if (fx_key[i] == c) + { + keys[0] = fx_code[i]; + *len = 1; + return; + } + return; + + case '0': + { + int num = 0; + CONTINUE_READ; + if (c != '0' && c != '1') + return; + num = (c - '0') * 10; + CONTINUE_READ; + if (c < '0' || c > '9') + return; + num += (c - '0'); + if (num == 0 || num > 12) + return; + CONTINUE_READ; + if (c != 'q') + return; + keys[0] = fx_code[num - 1]; + *len = 1; + return; + } + + case '1' ... '9': + { + unsigned val = c - '0'; + CONTINUE_READ; + if (c >= '0' && c <= '9') + { + val = val * 10 + (c - '0'); + CONTINUE_READ; + } + if (c != '~') + return; + if (val >= ARRAY_SIZE (four_code_table) + || four_code_table[val] == 0) + return; + keys[0] = four_code_table[val]; + *len = 1; + return; + } + default: + return; + } + } +#undef CONTINUE_READ +} + +/* The terminfo version of getkey. */ +int +grub_terminfo_getkey (struct grub_term_input *termi) +{ + struct grub_terminfo_input_state *data + = (struct grub_terminfo_input_state *) (termi->data); + if (data->npending) + { + int ret; + data->npending--; + ret = data->input_buf[0]; + grub_memmove (data->input_buf, data->input_buf + 1, data->npending + * sizeof (data->input_buf[0])); + return ret; + } + + grub_terminfo_readkey (termi, data->input_buf, &data->npending, + GRUB_TERMINFO_READKEY_MAX_LEN, data->readkey); + +#if defined(__powerpc__) && defined(GRUB_MACHINE_IEEE1275) + if (data->npending == 1 && data->input_buf[0] == GRUB_TERM_ESC + && grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_BROKEN_REPEAT) + && grub_get_time_ms () - data->last_key_time < 1000 + && (data->last_key & GRUB_TERM_EXTENDED)) + { + data->npending = 0; + data->last_key_time = grub_get_time_ms (); + return data->last_key; + } +#endif + + if (data->npending) + { + int ret; + data->npending--; + ret = data->input_buf[0]; +#if defined(__powerpc__) && defined(GRUB_MACHINE_IEEE1275) + if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_BROKEN_REPEAT)) + { + data->last_key = ret; + data->last_key_time = grub_get_time_ms (); + } +#endif + grub_memmove (data->input_buf, data->input_buf + 1, data->npending + * sizeof (data->input_buf[0])); + return ret; + } + + return GRUB_TERM_NO_KEY; +} + +grub_err_t +grub_terminfo_input_init (struct grub_term_input *termi) +{ + struct grub_terminfo_input_state *data + = (struct grub_terminfo_input_state *) (termi->data); + data->npending = 0; + + return GRUB_ERR_NONE; +} + +grub_err_t +grub_terminfo_output_init (struct grub_term_output *term) +{ + grub_terminfo_cls (term); + return GRUB_ERR_NONE; +} + +/* GRUB Command. */ + +static grub_err_t +print_terminfo (void) +{ + const char *encoding_names[(GRUB_TERM_CODE_TYPE_MASK + >> GRUB_TERM_CODE_TYPE_SHIFT) + 1] + = { + /* VGA and glyph descriptor types are just for completeness, + they are not used on terminfo terminals. + */ + [GRUB_TERM_CODE_TYPE_ASCII >> GRUB_TERM_CODE_TYPE_SHIFT] = _("ASCII"), + [GRUB_TERM_CODE_TYPE_CP437 >> GRUB_TERM_CODE_TYPE_SHIFT] = "CP-437", + [GRUB_TERM_CODE_TYPE_UTF8_LOGICAL >> GRUB_TERM_CODE_TYPE_SHIFT] + = _("UTF-8"), + [GRUB_TERM_CODE_TYPE_UTF8_VISUAL >> GRUB_TERM_CODE_TYPE_SHIFT] + /* TRANSLATORS: visually ordered UTF-8 is a non-compliant encoding + based on UTF-8 with right-to-left languages written in reverse. + Used on some terminals. Normal UTF-8 is refered as + "logically-ordered UTF-8" by opposition. */ + = _("visually-ordered UTF-8"), + [GRUB_TERM_CODE_TYPE_VISUAL_GLYPHS >> GRUB_TERM_CODE_TYPE_SHIFT] + = "Glyph descriptors", + _("Unknown encoding"), _("Unknown encoding"), _("Unknown encoding") + }; + struct grub_term_output *cur; + + grub_puts_ (N_("Current terminfo types:")); + for (cur = terminfo_outputs; cur; + cur = ((struct grub_terminfo_output_state *) cur->data)->next) + grub_printf ("%s: %s\t%s\t%dx%d\n", cur->name, + grub_terminfo_get_current(cur), + encoding_names[(cur->flags & GRUB_TERM_CODE_TYPE_MASK) + >> GRUB_TERM_CODE_TYPE_SHIFT], + ((struct grub_terminfo_output_state *) cur->data)->pos.x, + ((struct grub_terminfo_output_state *) cur->data)->pos.y); + + return GRUB_ERR_NONE; +} + +static const struct grub_arg_option options[] = +{ + {"ascii", 'a', 0, N_("Terminal is ASCII-only [default]."), 0, ARG_TYPE_NONE}, + {"utf8", 'u', 0, N_("Terminal is logical-ordered UTF-8."), 0, ARG_TYPE_NONE}, + {"visual-utf8", 'v', 0, N_("Terminal is visually-ordered UTF-8."), 0, + ARG_TYPE_NONE}, + {"geometry", 'g', 0, N_("Terminal has specified geometry."), + /* TRANSLATORS: "x" has to be entered in, like an identifier, so please don't + use better Unicode codepoints. */ + N_("WIDTHxHEIGHT."), ARG_TYPE_STRING}, + {0, 0, 0, 0, 0, 0} +}; + +enum + { + OPTION_ASCII, + OPTION_UTF8, + OPTION_VISUAL_UTF8, + OPTION_GEOMETRY + }; + +static grub_err_t +grub_cmd_terminfo (grub_extcmd_context_t ctxt, int argc, char **args) +{ + struct grub_term_output *cur; + int encoding = GRUB_TERM_CODE_TYPE_ASCII; + struct grub_arg_list *state = ctxt->state; + int w = 0, h = 0; + + if (argc == 0) + return print_terminfo (); + + if (state[OPTION_ASCII].set) + encoding = GRUB_TERM_CODE_TYPE_ASCII; + + if (state[OPTION_UTF8].set) + encoding = GRUB_TERM_CODE_TYPE_UTF8_LOGICAL; + + if (state[OPTION_VISUAL_UTF8].set) + encoding = GRUB_TERM_CODE_TYPE_UTF8_VISUAL; + + if (state[OPTION_GEOMETRY].set) + { + const char *ptr = state[OPTION_GEOMETRY].arg; + w = grub_strtoul (ptr, &ptr, 0); + if (grub_errno) + return grub_errno; + if (*ptr != 'x') + return grub_error (GRUB_ERR_BAD_ARGUMENT, + N_("incorrect terminal dimensions specification")); + ptr++; + h = grub_strtoul (ptr, &ptr, 0); + if (grub_errno) + return grub_errno; + } + + for (cur = terminfo_outputs; cur; + cur = ((struct grub_terminfo_output_state *) cur->data)->next) + if (grub_strcmp (args[0], cur->name) == 0 + || (grub_strcmp (args[0], "ofconsole") == 0 + && grub_strcmp ("console", cur->name) == 0)) + { + cur->flags = (cur->flags & ~GRUB_TERM_CODE_TYPE_MASK) | encoding; + + if (w && h) + { + struct grub_terminfo_output_state *data + = (struct grub_terminfo_output_state *) cur->data; + data->size.x = w; + data->size.y = h; + } + + if (argc == 1) + return GRUB_ERR_NONE; + + return grub_terminfo_set_current (cur, args[1]); + } + + return grub_error (GRUB_ERR_BAD_ARGUMENT, + N_("terminal %s isn't found or it's not handled by terminfo"), + args[0]); +} + +static grub_extcmd_t cmd; + +GRUB_MOD_INIT(terminfo) +{ + cmd = grub_register_extcmd ("terminfo", grub_cmd_terminfo, 0, + N_("[[-a|-u|-v] [-g WxH] [TERM] [TYPE]]"), + N_("Set terminfo type of TERM to TYPE.\n"), + options); +} + +GRUB_MOD_FINI(terminfo) +{ + grub_unregister_extcmd (cmd); +} |