470 lines
16 KiB
C
470 lines
16 KiB
C
/*
|
|
* VAS_EBOOT -- GRand Unified Bootloader
|
|
* Copyright (C) 2002,2003,2005,2007,2008,2009,2010 Free Software Foundation, Inc.
|
|
*
|
|
* VAS_EBOOT 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.
|
|
*
|
|
* VAS_EBOOT 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 VAS_EBOOT. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef VAS_EBOOT_TERM_HEADER
|
|
#define VAS_EBOOT_TERM_HEADER 1
|
|
|
|
#define VAS_EBOOT_TERM_NO_KEY 0
|
|
|
|
/* Internal codes used by VAS_EBOOT to represent terminal input. */
|
|
/* Only for keys otherwise not having shifted modification. */
|
|
#define VAS_EBOOT_TERM_SHIFT 0x01000000
|
|
#define VAS_EBOOT_TERM_CTRL 0x02000000
|
|
#define VAS_EBOOT_TERM_ALT 0x04000000
|
|
|
|
/* Keys without associated character. */
|
|
#define VAS_EBOOT_TERM_EXTENDED 0x00800000
|
|
#define VAS_EBOOT_TERM_KEY_MASK 0x00ffffff
|
|
|
|
#define VAS_EBOOT_TERM_KEY_LEFT (VAS_EBOOT_TERM_EXTENDED | 0x4b)
|
|
#define VAS_EBOOT_TERM_KEY_RIGHT (VAS_EBOOT_TERM_EXTENDED | 0x4d)
|
|
#define VAS_EBOOT_TERM_KEY_UP (VAS_EBOOT_TERM_EXTENDED | 0x48)
|
|
#define VAS_EBOOT_TERM_KEY_DOWN (VAS_EBOOT_TERM_EXTENDED | 0x50)
|
|
#define VAS_EBOOT_TERM_KEY_HOME (VAS_EBOOT_TERM_EXTENDED | 0x47)
|
|
#define VAS_EBOOT_TERM_KEY_END (VAS_EBOOT_TERM_EXTENDED | 0x4f)
|
|
#define VAS_EBOOT_TERM_KEY_DC (VAS_EBOOT_TERM_EXTENDED | 0x53)
|
|
#define VAS_EBOOT_TERM_KEY_PPAGE (VAS_EBOOT_TERM_EXTENDED | 0x49)
|
|
#define VAS_EBOOT_TERM_KEY_NPAGE (VAS_EBOOT_TERM_EXTENDED | 0x51)
|
|
#define VAS_EBOOT_TERM_KEY_F1 (VAS_EBOOT_TERM_EXTENDED | 0x3b)
|
|
#define VAS_EBOOT_TERM_KEY_F2 (VAS_EBOOT_TERM_EXTENDED | 0x3c)
|
|
#define VAS_EBOOT_TERM_KEY_F3 (VAS_EBOOT_TERM_EXTENDED | 0x3d)
|
|
#define VAS_EBOOT_TERM_KEY_F4 (VAS_EBOOT_TERM_EXTENDED | 0x3e)
|
|
#define VAS_EBOOT_TERM_KEY_F5 (VAS_EBOOT_TERM_EXTENDED | 0x3f)
|
|
#define VAS_EBOOT_TERM_KEY_F6 (VAS_EBOOT_TERM_EXTENDED | 0x40)
|
|
#define VAS_EBOOT_TERM_KEY_F7 (VAS_EBOOT_TERM_EXTENDED | 0x41)
|
|
#define VAS_EBOOT_TERM_KEY_F8 (VAS_EBOOT_TERM_EXTENDED | 0x42)
|
|
#define VAS_EBOOT_TERM_KEY_F9 (VAS_EBOOT_TERM_EXTENDED | 0x43)
|
|
#define VAS_EBOOT_TERM_KEY_F10 (VAS_EBOOT_TERM_EXTENDED | 0x44)
|
|
#define VAS_EBOOT_TERM_KEY_F11 (VAS_EBOOT_TERM_EXTENDED | 0x57)
|
|
#define VAS_EBOOT_TERM_KEY_F12 (VAS_EBOOT_TERM_EXTENDED | 0x58)
|
|
#define VAS_EBOOT_TERM_KEY_INSERT (VAS_EBOOT_TERM_EXTENDED | 0x52)
|
|
#define VAS_EBOOT_TERM_KEY_CENTER (VAS_EBOOT_TERM_EXTENDED | 0x4c)
|
|
|
|
/* Hex value is used for ESC, since '\e' is nonstandard */
|
|
#define VAS_EBOOT_TERM_ESC 0x1b
|
|
#define VAS_EBOOT_TERM_TAB '\t'
|
|
#define VAS_EBOOT_TERM_BACKSPACE '\b'
|
|
|
|
#define VAS_EBOOT_PROGRESS_NO_UPDATE -1
|
|
#define VAS_EBOOT_PROGRESS_FAST 0
|
|
#define VAS_EBOOT_PROGRESS_SLOW 2
|
|
|
|
#ifndef ASM_FILE
|
|
|
|
#include <VasEBoot/err.h>
|
|
#include <VasEBoot/symbol.h>
|
|
#include <VasEBoot/types.h>
|
|
#include <VasEBoot/unicode.h>
|
|
#include <VasEBoot/list.h>
|
|
|
|
/* These are used to represent the various color states we use. */
|
|
typedef enum
|
|
{
|
|
/* Used for uninitialized VasEBoot_term_color_state variables */
|
|
VAS_EBOOT_TERM_COLOR_UNDEFINED = -1,
|
|
/* The color used to display all text that does not use the
|
|
user defined colors below. */
|
|
VAS_EBOOT_TERM_COLOR_STANDARD = 0,
|
|
/* The user defined colors for normal text. */
|
|
VAS_EBOOT_TERM_COLOR_NORMAL,
|
|
/* The user defined colors for highlighted text. */
|
|
VAS_EBOOT_TERM_COLOR_HIGHLIGHT
|
|
}
|
|
VasEBoot_term_color_state;
|
|
|
|
/* Flags for representing the capabilities of a terminal. */
|
|
/* Some notes about the flags:
|
|
- These flags are used by higher-level functions but not terminals
|
|
themselves.
|
|
- If a terminal is dumb, you may assume that only putchar, getkey and
|
|
checkkey are called.
|
|
- Some fancy features (setcolorstate, setcolor and setcursor) can be set
|
|
to NULL. */
|
|
|
|
/* Set when input characters shouldn't be echoed back. */
|
|
#define VAS_EBOOT_TERM_NO_ECHO (1 << 0)
|
|
/* Set when the editing feature should be disabled. */
|
|
#define VAS_EBOOT_TERM_NO_EDIT (1 << 1)
|
|
/* Set when the terminal cannot do fancy things. */
|
|
#define VAS_EBOOT_TERM_DUMB (1 << 2)
|
|
/* Which encoding does terminal expect stream to be. */
|
|
#define VAS_EBOOT_TERM_CODE_TYPE_SHIFT 3
|
|
#define VAS_EBOOT_TERM_CODE_TYPE_MASK (7 << VAS_EBOOT_TERM_CODE_TYPE_SHIFT)
|
|
/* Only ASCII characters accepted. */
|
|
#define VAS_EBOOT_TERM_CODE_TYPE_ASCII (0 << VAS_EBOOT_TERM_CODE_TYPE_SHIFT)
|
|
/* Expects CP-437 characters (ASCII + pseudographics). */
|
|
#define VAS_EBOOT_TERM_CODE_TYPE_CP437 (1 << VAS_EBOOT_TERM_CODE_TYPE_SHIFT)
|
|
/* UTF-8 stream in logical order. Usually used for terminals
|
|
which just forward the stream to another computer. */
|
|
#define VAS_EBOOT_TERM_CODE_TYPE_UTF8_LOGICAL (2 << VAS_EBOOT_TERM_CODE_TYPE_SHIFT)
|
|
/* UTF-8 in visual order. Like UTF-8 logical but for buggy endpoints. */
|
|
#define VAS_EBOOT_TERM_CODE_TYPE_UTF8_VISUAL (3 << VAS_EBOOT_TERM_CODE_TYPE_SHIFT)
|
|
/* Glyph description in visual order. */
|
|
#define VAS_EBOOT_TERM_CODE_TYPE_VISUAL_GLYPHS (4 << VAS_EBOOT_TERM_CODE_TYPE_SHIFT)
|
|
|
|
|
|
/* Bitmasks for modifier keys returned by VasEBoot_getkeystatus. */
|
|
#define VAS_EBOOT_TERM_STATUS_RSHIFT (1 << 0)
|
|
#define VAS_EBOOT_TERM_STATUS_LSHIFT (1 << 1)
|
|
#define VAS_EBOOT_TERM_STATUS_RCTRL (1 << 2)
|
|
#define VAS_EBOOT_TERM_STATUS_RALT (1 << 3)
|
|
#define VAS_EBOOT_TERM_STATUS_SCROLL (1 << 4)
|
|
#define VAS_EBOOT_TERM_STATUS_NUM (1 << 5)
|
|
#define VAS_EBOOT_TERM_STATUS_CAPS (1 << 6)
|
|
#define VAS_EBOOT_TERM_STATUS_LCTRL (1 << 8)
|
|
#define VAS_EBOOT_TERM_STATUS_LALT (1 << 9)
|
|
|
|
/* Menu-related geometrical constants. */
|
|
|
|
/* The number of columns/lines between messages/borders/etc. */
|
|
#define VAS_EBOOT_TERM_MARGIN 1
|
|
|
|
/* The number of columns of scroll information. */
|
|
#define VAS_EBOOT_TERM_SCROLL_WIDTH 1
|
|
|
|
struct VasEBoot_term_input
|
|
{
|
|
/* The next terminal. */
|
|
struct VasEBoot_term_input *next;
|
|
struct VasEBoot_term_input **prev;
|
|
|
|
/* The terminal name. */
|
|
const char *name;
|
|
|
|
/* Initialize the terminal. */
|
|
VasEBoot_err_t (*init) (struct VasEBoot_term_input *term);
|
|
|
|
/* Clean up the terminal. */
|
|
VasEBoot_err_t (*fini) (struct VasEBoot_term_input *term);
|
|
|
|
/* Get a character if any input character is available. Otherwise return -1 */
|
|
int (*getkey) (struct VasEBoot_term_input *term);
|
|
|
|
/* Get keyboard modifier status. */
|
|
int (*getkeystatus) (struct VasEBoot_term_input *term);
|
|
|
|
void *data;
|
|
};
|
|
typedef struct VasEBoot_term_input *VasEBoot_term_input_t;
|
|
|
|
/* Made in a way to fit into uint32_t and so be passed in a register. */
|
|
struct VasEBoot_term_coordinate
|
|
{
|
|
VasEBoot_uint16_t x;
|
|
VasEBoot_uint16_t y;
|
|
};
|
|
|
|
struct VasEBoot_term_output
|
|
{
|
|
/* The next terminal. */
|
|
struct VasEBoot_term_output *next;
|
|
struct VasEBoot_term_output **prev;
|
|
|
|
/* The terminal name. */
|
|
const char *name;
|
|
|
|
/* Initialize the terminal. */
|
|
VasEBoot_err_t (*init) (struct VasEBoot_term_output *term);
|
|
|
|
/* Clean up the terminal. */
|
|
VasEBoot_err_t (*fini) (struct VasEBoot_term_output *term);
|
|
|
|
/* Put a character. C is encoded in Unicode. */
|
|
void (*putchar) (struct VasEBoot_term_output *term,
|
|
const struct VasEBoot_unicode_glyph *c);
|
|
|
|
/* Get the number of columns occupied by a given character C. C is
|
|
encoded in Unicode. */
|
|
VasEBoot_size_t (*getcharwidth) (struct VasEBoot_term_output *term,
|
|
const struct VasEBoot_unicode_glyph *c);
|
|
|
|
/* Get the screen size. */
|
|
struct VasEBoot_term_coordinate (*getwh) (struct VasEBoot_term_output *term);
|
|
|
|
/* Get the cursor position. The return value is ((X << 8) | Y). */
|
|
struct VasEBoot_term_coordinate (*getxy) (struct VasEBoot_term_output *term);
|
|
|
|
/* Go to the position (X, Y). */
|
|
void (*gotoxy) (struct VasEBoot_term_output *term,
|
|
struct VasEBoot_term_coordinate pos);
|
|
|
|
/* Clear the screen. */
|
|
void (*cls) (struct VasEBoot_term_output *term);
|
|
|
|
/* Set the current color to be used */
|
|
void (*setcolorstate) (struct VasEBoot_term_output *term,
|
|
VasEBoot_term_color_state state);
|
|
|
|
/* Turn on/off the cursor. */
|
|
void (*setcursor) (struct VasEBoot_term_output *term, int on);
|
|
|
|
/* Update the screen. */
|
|
void (*refresh) (struct VasEBoot_term_output *term);
|
|
|
|
/* gfxterm only: put in fullscreen mode. */
|
|
VasEBoot_err_t (*fullscreen) (void);
|
|
|
|
/* The feature flags defined above. */
|
|
VasEBoot_uint32_t flags;
|
|
|
|
/* Progress data. */
|
|
VasEBoot_uint32_t progress_update_divisor;
|
|
VasEBoot_uint32_t progress_update_counter;
|
|
|
|
void *data;
|
|
};
|
|
typedef struct VasEBoot_term_output *VasEBoot_term_output_t;
|
|
|
|
#define VAS_EBOOT_TERM_DEFAULT_NORMAL_COLOR 0x07
|
|
#define VAS_EBOOT_TERM_DEFAULT_HIGHLIGHT_COLOR 0x70
|
|
#define VAS_EBOOT_TERM_DEFAULT_STANDARD_COLOR 0x07
|
|
|
|
/* Current color state. */
|
|
extern VasEBoot_uint8_t EXPORT_VAR(VasEBoot_term_normal_color);
|
|
extern VasEBoot_uint8_t EXPORT_VAR(VasEBoot_term_highlight_color);
|
|
|
|
extern struct VasEBoot_term_output *EXPORT_VAR(VasEBoot_term_outputs_disabled);
|
|
extern struct VasEBoot_term_input *EXPORT_VAR(VasEBoot_term_inputs_disabled);
|
|
extern struct VasEBoot_term_output *EXPORT_VAR(VasEBoot_term_outputs);
|
|
extern struct VasEBoot_term_input *EXPORT_VAR(VasEBoot_term_inputs);
|
|
|
|
static inline void
|
|
VasEBoot_term_register_input (const char *name __attribute__ ((unused)),
|
|
VasEBoot_term_input_t term)
|
|
{
|
|
if (VasEBoot_term_inputs)
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_inputs_disabled),
|
|
VAS_EBOOT_AS_LIST (term));
|
|
else
|
|
{
|
|
/* If this is the first terminal, enable automatically. */
|
|
if (! term->init || term->init (term) == VAS_EBOOT_ERR_NONE)
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_inputs), VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_register_input_inactive (const char *name __attribute__ ((unused)),
|
|
VasEBoot_term_input_t term)
|
|
{
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_inputs_disabled),
|
|
VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_register_input_active (const char *name __attribute__ ((unused)),
|
|
VasEBoot_term_input_t term)
|
|
{
|
|
if (! term->init || term->init (term) == VAS_EBOOT_ERR_NONE)
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_inputs), VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_register_output (const char *name __attribute__ ((unused)),
|
|
VasEBoot_term_output_t term)
|
|
{
|
|
if (VasEBoot_term_outputs)
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_outputs_disabled),
|
|
VAS_EBOOT_AS_LIST (term));
|
|
else
|
|
{
|
|
/* If this is the first terminal, enable automatically. */
|
|
if (! term->init || term->init (term) == VAS_EBOOT_ERR_NONE)
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_outputs),
|
|
VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_register_output_inactive (const char *name __attribute__ ((unused)),
|
|
VasEBoot_term_output_t term)
|
|
{
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_outputs_disabled),
|
|
VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_register_output_active (const char *name __attribute__ ((unused)),
|
|
VasEBoot_term_output_t term)
|
|
{
|
|
if (! term->init || term->init (term) == VAS_EBOOT_ERR_NONE)
|
|
VasEBoot_list_push (VAS_EBOOT_AS_LIST_P (&VasEBoot_term_outputs),
|
|
VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_unregister_input (VasEBoot_term_input_t term)
|
|
{
|
|
VasEBoot_list_remove (VAS_EBOOT_AS_LIST (term));
|
|
VasEBoot_list_remove (VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_unregister_output (VasEBoot_term_output_t term)
|
|
{
|
|
VasEBoot_list_remove (VAS_EBOOT_AS_LIST (term));
|
|
VasEBoot_list_remove (VAS_EBOOT_AS_LIST (term));
|
|
}
|
|
|
|
#define FOR_ACTIVE_TERM_INPUTS(var) FOR_LIST_ELEMENTS((var), (VasEBoot_term_inputs))
|
|
#define FOR_DISABLED_TERM_INPUTS(var) FOR_LIST_ELEMENTS((var), (VasEBoot_term_inputs_disabled))
|
|
#define FOR_ACTIVE_TERM_OUTPUTS(var) FOR_LIST_ELEMENTS((var), (VasEBoot_term_outputs))
|
|
#define FOR_DISABLED_TERM_OUTPUTS(var) FOR_LIST_ELEMENTS((var), (VasEBoot_term_outputs_disabled))
|
|
|
|
void VasEBoot_putcode (VasEBoot_uint32_t code, struct VasEBoot_term_output *term);
|
|
int EXPORT_FUNC(VasEBoot_getkey) (void);
|
|
int EXPORT_FUNC(VasEBoot_getkey_noblock) (void);
|
|
int EXPORT_FUNC(VasEBoot_getkeystatus) (void);
|
|
int EXPORT_FUNC(VasEBoot_key_is_interrupt) (int key);
|
|
void VasEBoot_cls (void);
|
|
void EXPORT_FUNC(VasEBoot_refresh) (void);
|
|
void VasEBoot_puts_terminal (const char *str, struct VasEBoot_term_output *term);
|
|
struct VasEBoot_term_coordinate *VasEBoot_term_save_pos (void);
|
|
void VasEBoot_term_restore_pos (struct VasEBoot_term_coordinate *pos);
|
|
|
|
static inline unsigned VasEBoot_term_width (struct VasEBoot_term_output *term)
|
|
{
|
|
return term->getwh(term).x ? : 80;
|
|
}
|
|
|
|
static inline unsigned VasEBoot_term_height (struct VasEBoot_term_output *term)
|
|
{
|
|
return term->getwh(term).y ? : 24;
|
|
}
|
|
|
|
static inline struct VasEBoot_term_coordinate
|
|
VasEBoot_term_getxy (struct VasEBoot_term_output *term)
|
|
{
|
|
return term->getxy (term);
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_refresh (struct VasEBoot_term_output *term)
|
|
{
|
|
if (term->refresh)
|
|
term->refresh (term);
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_gotoxy (struct VasEBoot_term_output *term, struct VasEBoot_term_coordinate pos)
|
|
{
|
|
term->gotoxy (term, pos);
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_setcolorstate (struct VasEBoot_term_output *term,
|
|
VasEBoot_term_color_state state)
|
|
{
|
|
if (term->setcolorstate)
|
|
term->setcolorstate (term, state);
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_setcolorstate (VasEBoot_term_color_state state)
|
|
{
|
|
struct VasEBoot_term_output *term;
|
|
|
|
FOR_ACTIVE_TERM_OUTPUTS(term)
|
|
VasEBoot_term_setcolorstate (term, state);
|
|
}
|
|
|
|
/* Turn on/off the cursor. */
|
|
static inline void
|
|
VasEBoot_term_setcursor (struct VasEBoot_term_output *term, int on)
|
|
{
|
|
if (term->setcursor)
|
|
term->setcursor (term, on);
|
|
}
|
|
|
|
static inline void
|
|
VasEBoot_term_cls (struct VasEBoot_term_output *term)
|
|
{
|
|
if (term->cls)
|
|
(term->cls) (term);
|
|
else
|
|
{
|
|
VasEBoot_putcode ('\n', term);
|
|
VasEBoot_term_refresh (term);
|
|
}
|
|
}
|
|
|
|
#if HAVE_FONT_SOURCE
|
|
|
|
VasEBoot_size_t
|
|
VasEBoot_unicode_estimate_width (const struct VasEBoot_unicode_glyph *c);
|
|
|
|
#else
|
|
|
|
static inline VasEBoot_size_t
|
|
VasEBoot_unicode_estimate_width (const struct VasEBoot_unicode_glyph *c __attribute__ ((unused)))
|
|
{
|
|
if (VasEBoot_unicode_get_comb_type (c->base))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
#endif
|
|
|
|
#define VAS_EBOOT_TERM_TAB_WIDTH 8
|
|
|
|
static inline VasEBoot_size_t
|
|
VasEBoot_term_getcharwidth (struct VasEBoot_term_output *term,
|
|
const struct VasEBoot_unicode_glyph *c)
|
|
{
|
|
if (c->base == '\t')
|
|
return VAS_EBOOT_TERM_TAB_WIDTH;
|
|
|
|
if (term->getcharwidth)
|
|
return term->getcharwidth (term, c);
|
|
else if (((term->flags & VAS_EBOOT_TERM_CODE_TYPE_MASK)
|
|
== VAS_EBOOT_TERM_CODE_TYPE_UTF8_LOGICAL)
|
|
|| ((term->flags & VAS_EBOOT_TERM_CODE_TYPE_MASK)
|
|
== VAS_EBOOT_TERM_CODE_TYPE_UTF8_VISUAL)
|
|
|| ((term->flags & VAS_EBOOT_TERM_CODE_TYPE_MASK)
|
|
== VAS_EBOOT_TERM_CODE_TYPE_VISUAL_GLYPHS))
|
|
return VasEBoot_unicode_estimate_width (c);
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
struct VasEBoot_term_autoload
|
|
{
|
|
struct VasEBoot_term_autoload *next;
|
|
char *name;
|
|
char *modname;
|
|
};
|
|
|
|
extern struct VasEBoot_term_autoload *VasEBoot_term_input_autoload;
|
|
extern struct VasEBoot_term_autoload *VasEBoot_term_output_autoload;
|
|
|
|
static inline void
|
|
VasEBoot_print_spaces (struct VasEBoot_term_output *term, int number_spaces)
|
|
{
|
|
while (--number_spaces >= 0)
|
|
VasEBoot_putcode (' ', term);
|
|
}
|
|
|
|
extern void (*EXPORT_VAR (VasEBoot_term_poll_usb)) (int wait_for_completion);
|
|
|
|
#define VAS_EBOOT_TERM_REPEAT_PRE_INTERVAL 400
|
|
#define VAS_EBOOT_TERM_REPEAT_INTERVAL 50
|
|
|
|
#endif /* ! ASM_FILE */
|
|
|
|
#endif /* ! VAS_EBOOT_TERM_HEADER */
|