merge mainline into mbtag

INSTALL

@@ -14,6 +14,7 @@ configuring the GRUB.
 * GCC 4.1.3 or later
 * GNU Make
 * GNU Bison 2.3 or later
+* GNU gettext 0.17 or later
 * GNU binutils 2.9.1.0.23 or later
 * Other standard GNU/Unix tools
 
@@ -25,6 +26,10 @@ need the following.
 * Autoconf 2.60 or later
 * Automake 1.10.1 or later
 
+Prerequisites for make-check:
+
+* qemu, specifically the binary 'qemu-system-i386'
+
 Configuring the GRUB
 ====================
 

Makefile.in

@@ -89,7 +89,7 @@ TARGET_ASFLAGS = @TARGET_ASFLAGS@
 TARGET_MODULE_FORMAT = @TARGET_MODULE_FORMAT@
 TARGET_APPLE_CC = @TARGET_APPLE_CC@
 OBJCONV = @OBJCONV@
-TARGET_CPPFLAGS = @TARGET_CPPFLAGS@ -nostdinc -isystem $(shell $(TARGET_CC) -print-file-name=include) -I$(srcdir)/include -I$(builddir) -I$(builddir)/include \
+TARGET_CPPFLAGS = @TARGET_CPPFLAGS@ -I$(srcdir)/include -I$(builddir) -I$(builddir)/include \
 	-Wall -W
 TARGET_LDFLAGS = @TARGET_LDFLAGS@
 TARGET_IMG_LDSCRIPT = @TARGET_IMG_LDSCRIPT@
@@ -114,12 +114,14 @@ endif
 AWK = @AWK@
 LIBCURSES = @LIBCURSES@
 LIBUSB = @LIBUSB@
+LIBSDL = @LIBSDL@
 LIBPCIACCESS = @LIBPCIACCESS@
 YACC = @YACC@
 FONT_SOURCE = @FONT_SOURCE@
 
 # Options.
 enable_grub_emu_usb = @enable_grub_emu_usb@
+enable_grub_emu_sdl = @enable_grub_emu_sdl@
 enable_grub_emu_pci = @enable_grub_emu_pci@
 enable_grub_fstest = @enable_grub_fstest@
 enable_grub_pe2elf = @enable_grub_pe2elf@
@@ -145,7 +147,7 @@ INFOS = $(info_INFOS)
 CLEANFILES =
 MOSTLYCLEANFILES =
 DISTCLEANFILES = config.status config.cache config.log config.h \
-	Makefile stamp-h include/grub/cpu include/grub/machine \
+	Makefile stamp-h stamp-h1 include/grub/cpu include/grub/machine \
 	gensymlist.sh genkernsyms.sh build_env.mk \
 	docs/grub.info docs/version.texi docs/stamp-vti
 
@@ -236,7 +238,8 @@ else
 
 ifeq ($(enable_grub_mkfont),yes)
 
-pkgdata_DATA += unicode.pf2 ascii.pf2
+pkgdata_DATA += unicode.pf2 ascii.pf2 ascii.h
+CLEANFILES += ascii.bitmaps
 
 # Arrows and lines are needed to draw the menu, so we always include them
 UNICODE_ARROWS=0x2190-0x2193
@@ -247,6 +250,14 @@ unicode.pf2: $(FONT_SOURCE) grub-mkfont
 
 ascii.pf2: $(FONT_SOURCE) grub-mkfont
 	$(builddir)/grub-mkfont -o $@ $(FONT_SOURCE) -r 0x0-0x7f,$(UNICODE_ARROWS),$(UNICODE_LINES)
+
+ascii.bitmaps: $(FONT_SOURCE) grub-mkfont
+	$(builddir)/grub-mkfont --ascii-bitmaps -o $@ $(FONT_SOURCE)
+
+ascii.h: ascii.bitmaps grub-bin2h
+	$(builddir)/grub-bin2h ascii_bitmaps < $< > $@
+
+TARGET_CFLAGS += -DUSE_ASCII_FAILBACK=1
 endif
 endif
 
@@ -465,23 +476,21 @@ distcheck: dist
 
 check: all $(UNIT_TESTS) $(FUNCTIONAL_TESTS) $(SCRIPTED_TESTS)
 	@list="$(UNIT_TESTS)"; \
+	set -e; \
 	for file in $$list; do \
 	  $(builddir)/$$file; \
 	done
 	@list="$(FUNCTIONAL_TESTS)"; \
+	set -e; \
 	for file in $$list; do \
 	  mod=`basename $$file .mod`; \
 	  echo "insmod functional_test; insmod $$mod; functional_test" \
 	    | $(builddir)/grub-shell; \
 	done
 	@list="$(SCRIPTED_TESTS)"; \
+	set -e; \
 	for file in $$list; do \
-	  echo "$$file:"; \
+	  $(builddir)/$$file; \
-	  if $(builddir)/$$file; then \
-	    echo "$$file: PASS"; \
-	  else \
-	    echo "$$file: FAIL"; \
-	  fi; \
 	done
 
 .SUFFIX:

NEWS

@@ -1,4 +1,21 @@
-New in 1.98:
+New in 1.98 - 2010-03-06:
+
+* Multiboot on EFI support.
+
+* Graphical menu support.
+
+* MIPS support.
+
+* Saved default menu entry support, with new utilities `grub-reboot' and
+  `grub-set-default'.
+
+* Unit testing framework.
+
+* Support for multiple terminals.
+
+* Encrypted password support, with a new utility `grub-mkpasswd-pbkdf2'.
+
+* `grub-mkfloppy' removed; use `grub-mkrescue' to create floppy images.
 
 * Add grub-probe support for GNU/Hurd.
 

acinclude.m4

@@ -14,11 +14,11 @@ $2
 
 
 dnl Check whether target compiler is working
-AC_DEFUN(grub_PROG_TARGET_CC,
+AC_DEFUN([grub_PROG_TARGET_CC],
 [AC_MSG_CHECKING([whether target compiler is working])
 AC_CACHE_VAL(grub_cv_prog_target_cc,
 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-asm (".globl start; start: nop");
+asm (".globl start; start:");
 int main (void);
 ]], [[]])],
   		[grub_cv_prog_target_cc=yes],
@@ -36,7 +36,7 @@ dnl grub_ASM_USCORE checks if C symbols get an underscore after
 dnl compiling to assembler.
 dnl Written by Pavel Roskin. Based on grub_ASM_EXT_C written by
 dnl Erich Boleyn and modified by Yoshinori K. Okuji.
-AC_DEFUN(grub_ASM_USCORE,
+AC_DEFUN([grub_ASM_USCORE],
 [AC_REQUIRE([AC_PROG_CC])
 AC_MSG_CHECKING([if C symbols get an underscore after compilation])
 AC_CACHE_VAL(grub_cv_asm_uscore,
@@ -75,7 +75,7 @@ AC_MSG_RESULT([$grub_cv_asm_uscore])
 
 dnl Some versions of `objcopy -O binary' vary their output depending
 dnl on the link address.
-AC_DEFUN(grub_PROG_OBJCOPY_ABSOLUTE,
+AC_DEFUN([grub_PROG_OBJCOPY_ABSOLUTE],
 [AC_MSG_CHECKING([whether ${OBJCOPY} works for absolute addresses])
 AC_CACHE_VAL(grub_cv_prog_objcopy_absolute,
 [cat > conftest.c <<\EOF
@@ -119,7 +119,7 @@ fi
 
 dnl Supply --build-id=none to ld if building modules.
 dnl This suppresses warnings from ld on some systems
-AC_DEFUN(grub_PROG_LD_BUILD_ID_NONE,
+AC_DEFUN([grub_PROG_LD_BUILD_ID_NONE],
 [AC_MSG_CHECKING([whether linker accepts --build-id=none])
 AC_CACHE_VAL(grub_cv_prog_ld_build_id_none,
 [save_LDFLAGS="$LDFLAGS"
@@ -150,7 +150,7 @@ dnl
 dnl We only support the newer versions, because the old versions cause
 dnl major pain, by requiring manual assembly to get 16-bit instructions into
 dnl asm files.
-AC_DEFUN(grub_I386_ASM_ADDR32,
+AC_DEFUN([grub_I386_ASM_ADDR32],
 [AC_REQUIRE([AC_PROG_CC])
 AC_REQUIRE([grub_I386_ASM_PREFIX_REQUIREMENT])
 AC_MSG_CHECKING([for .code16 addr32 assembler support])
@@ -178,7 +178,7 @@ AC_MSG_RESULT([$grub_cv_i386_asm_addr32])])
 
 dnl check if our compiler is apple cc
 dnl because it requires numerous workarounds
-AC_DEFUN(grub_apple_cc,
+AC_DEFUN([grub_apple_cc],
 [AC_REQUIRE([AC_PROG_CC])
 AC_MSG_CHECKING([whether our compiler is apple cc])
 AC_CACHE_VAL(grub_cv_apple_cc,
@@ -193,7 +193,7 @@ AC_MSG_RESULT([$grub_cv_apple_cc])])
 
 dnl check if our target compiler is apple cc
 dnl because it requires numerous workarounds
-AC_DEFUN(grub_apple_target_cc,
+AC_DEFUN([grub_apple_target_cc],
 [AC_REQUIRE([AC_PROG_CC])
 AC_MSG_CHECKING([whether our target compiler is apple cc])
 AC_CACHE_VAL(grub_cv_apple_target_cc,
@@ -210,7 +210,7 @@ AC_MSG_RESULT([$grub_cv_apple_target_cc])])
 dnl Later versions of GAS requires that addr32 and data32 prefixes
 dnl appear in the same lines as the instructions they modify, while
 dnl earlier versions requires that they appear in separate lines.
-AC_DEFUN(grub_I386_ASM_PREFIX_REQUIREMENT,
+AC_DEFUN([grub_I386_ASM_PREFIX_REQUIREMENT],
 [AC_REQUIRE([AC_PROG_CC])
 AC_MSG_CHECKING(dnl
 [whether addr32 must be in the same line as the instruction])
@@ -246,7 +246,7 @@ AC_MSG_RESULT([$grub_cv_i386_asm_prefix_requirement])])
 
 dnl Older versions of GAS require that absolute indirect calls/jumps are
 dnl not prefixed with `*', while later versions warn if not prefixed.
-AC_DEFUN(grub_I386_ASM_ABSOLUTE_WITHOUT_ASTERISK,
+AC_DEFUN([grub_I386_ASM_ABSOLUTE_WITHOUT_ASTERISK],
 [AC_REQUIRE([AC_PROG_CC])
 AC_MSG_CHECKING(dnl
 [whether an absolute indirect call/jump must not be prefixed with an asterisk])
@@ -276,7 +276,7 @@ AC_MSG_RESULT([$grub_cv_i386_asm_absolute_without_asterisk])])
 
 dnl Check what symbol is defined as a bss start symbol.
 dnl Written by Michael Hohmoth and Yoshinori K. Okuji.
-AC_DEFUN(grub_CHECK_BSS_START_SYMBOL,
+AC_DEFUN([grub_CHECK_BSS_START_SYMBOL],
 [AC_REQUIRE([AC_PROG_CC])
 AC_MSG_CHECKING([if __bss_start is defined by the compiler])
 AC_CACHE_VAL(grub_cv_check_uscore_uscore_bss_start_symbol,
@@ -320,7 +320,7 @@ fi
 
 dnl Check what symbol is defined as an end symbol.
 dnl Written by Yoshinori K. Okuji.
-AC_DEFUN(grub_CHECK_END_SYMBOL,
+AC_DEFUN([grub_CHECK_END_SYMBOL],
 [AC_REQUIRE([AC_PROG_CC])
 AC_MSG_CHECKING([if end is defined by the compiler])
 AC_CACHE_VAL(grub_cv_check_end_symbol,
@@ -352,7 +352,7 @@ fi
 ])
 
 dnl Check if the C compiler generates calls to `__enable_execute_stack()'.
-AC_DEFUN(grub_CHECK_ENABLE_EXECUTE_STACK,[
+AC_DEFUN([grub_CHECK_ENABLE_EXECUTE_STACK],[
 AC_MSG_CHECKING([whether `$CC' generates calls to `__enable_execute_stack()'])
 AC_LANG_CONFTEST([[
 void f (int (*p) (void));
@@ -379,7 +379,7 @@ rm -f conftest*
 
 
 dnl Check if the C compiler supports `-fstack-protector'.
-AC_DEFUN(grub_CHECK_STACK_PROTECTOR,[
+AC_DEFUN([grub_CHECK_STACK_PROTECTOR],[
 [# Smashing stack protector.
 ssp_possible=yes]
 AC_MSG_CHECKING([whether `$CC' accepts `-fstack-protector'])
@@ -398,7 +398,7 @@ else
 ])
 
 dnl Check if the C compiler supports `-mstack-arg-probe' (Cygwin).
-AC_DEFUN(grub_CHECK_STACK_ARG_PROBE,[
+AC_DEFUN([grub_CHECK_STACK_ARG_PROBE],[
 [# Smashing stack arg probe.
 sap_possible=yes]
 AC_MSG_CHECKING([whether `$CC' accepts `-mstack-arg-probe'])
@@ -414,7 +414,7 @@ else
 ])
 
 dnl Check if ln can handle directories properly (mingw).
-AC_DEFUN(grub_CHECK_LINK_DIR,[
+AC_DEFUN([grub_CHECK_LINK_DIR],[
 AC_MSG_CHECKING([whether ln can handle directories properly])
 [mkdir testdir 2>/dev/null
 case $srcdir in
@@ -432,7 +432,7 @@ rm -rf testdir]
 ])
 
 dnl Check if the C compiler supports `-fPIE'.
-AC_DEFUN(grub_CHECK_PIE,[
+AC_DEFUN([grub_CHECK_PIE],[
 [# Position independent executable.
 pie_possible=yes]
 AC_MSG_CHECKING([whether `$CC' has `-fPIE' as default])

boot/i386/pc/pxeboot.S

@@ -1,6 +1,6 @@
 /*
  *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2000,2005,2007,2008,2009   Free Software Foundation, Inc.
+ *  Copyright (C) 2000,2005,2007,2008,2009,2010   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
@@ -16,6 +16,8 @@
  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <grub/machine/boot.h>
+
 	.file	"pxeboot.S"
 	.text
 
@@ -28,7 +30,7 @@ _start:
 start:
 
 	/* Use drive number 0x7F for PXE */
-        movb	$0x7F, %dl
+        movb	$GRUB_BOOT_MACHINE_PXE_DL, %dl
 
 	/* Jump to the real world */
 	ljmp	$0, $0x8200

bus/bonito.c

@@ -0,0 +1,90 @@
+/* bonito.c - PCI bonito interface.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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/>.
+ */
+
+#include <grub/pci.h>
+#include <grub/misc.h>
+
+static grub_uint32_t base_win[GRUB_MACHINE_PCI_NUM_WIN];
+static const grub_size_t sizes_win[GRUB_MACHINE_PCI_NUM_WIN] = 
+  {GRUB_MACHINE_PCI_WIN1_SIZE, GRUB_MACHINE_PCI_WIN_SIZE, 
+   GRUB_MACHINE_PCI_WIN_SIZE};
+/* Usage counters.  */
+static int usage_win[GRUB_MACHINE_PCI_NUM_WIN];
+static grub_addr_t addr_win[GRUB_MACHINE_PCI_NUM_WIN] = 
+  {GRUB_MACHINE_PCI_WIN1_ADDR, GRUB_MACHINE_PCI_WIN2_ADDR,
+   GRUB_MACHINE_PCI_WIN3_ADDR};
+
+static inline void
+write_bases (void)
+{
+  int i;
+  grub_uint32_t reg = 0;
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++) 
+    reg |= (((base_win[i] >> GRUB_MACHINE_PCI_WIN_SHIFT) 
+	     & GRUB_MACHINE_PCI_WIN_MASK) 
+	    >> (i * GRUB_MACHINE_PCI_WIN_MASK_SIZE));
+  GRUB_MACHINE_PCI_IO_CTRL_REG = reg;
+}
+
+volatile void *
+grub_pci_device_map_range (grub_pci_device_t dev __attribute__ ((unused)),
+			   grub_addr_t base, grub_size_t size)
+{
+  int i;
+  grub_addr_t newbase;
+
+  /* First try already used registers. */
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++)
+    if (usage_win[i] && base_win[i] <= base 
+	&& base_win[i] + sizes_win[i] > base + size)
+      {
+	usage_win[i]++;
+	return (void *) 
+	  (addr_win[i] | (base & GRUB_MACHINE_PCI_WIN_OFFSET_MASK));
+      }
+  /* Map new register.  */
+  newbase = base & ~GRUB_MACHINE_PCI_WIN_OFFSET_MASK;
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++)
+    if (!usage_win[i] && newbase <= base 
+	&& newbase + sizes_win[i] > base + size)
+      {
+	usage_win[i]++;
+	base_win[i] = newbase;
+	write_bases ();
+	return (void *) 
+	  (addr_win[i] | (base & GRUB_MACHINE_PCI_WIN_OFFSET_MASK));
+      }
+  grub_fatal ("Out of PCI windows.");
+}
+
+void
+grub_pci_device_unmap_range (grub_pci_device_t dev __attribute__ ((unused)),
+			     volatile void *mem __attribute__ ((unused)),
+			     grub_size_t size __attribute__ ((unused)))
+{
+  int i;
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++)
+    if (usage_win[i] && addr_win[i] 
+	== (((grub_addr_t) mem) & ~GRUB_MACHINE_PCI_WIN_OFFSET_MASK))
+      {
+	usage_win[i]--;
+	return;
+      }
+  grub_fatal ("Tried to unmap not mapped region");
+}

bus/pci.c

@@ -24,7 +24,7 @@ grub_pci_address_t
 grub_pci_make_address (grub_pci_device_t dev, int reg)
 {
   return (1 << 31) | (dev.bus << 16) | (dev.device << 11)
-    | (dev.function << 8) | (reg << 2);
+    | (dev.function << 8) | reg;
 }
 
 void
@@ -35,13 +35,13 @@ grub_pci_iterate (grub_pci_iteratefunc_t hook)
   grub_pci_id_t id;
   grub_uint32_t hdr;
 
-  for (dev.bus = 0; dev.bus < 256; dev.bus++)
+  for (dev.bus = 0; dev.bus < GRUB_PCI_NUM_BUS; dev.bus++)
     {
-      for (dev.device = 0; dev.device < 32; dev.device++)
+      for (dev.device = 0; dev.device < GRUB_PCI_NUM_DEVICES; dev.device++)
 	{
 	  for (dev.function = 0; dev.function < 8; dev.function++)
 	    {
-	      addr = grub_pci_make_address (dev, 0);
+	      addr = grub_pci_make_address (dev, GRUB_PCI_REG_PCI_ID);
 	      id = grub_pci_read (addr);
 
 	      /* Check if there is a device present.  */
@@ -54,7 +54,7 @@ grub_pci_iterate (grub_pci_iteratefunc_t hook)
 	      /* Probe only func = 0 if the device if not multifunction */
 	      if (dev.function == 0)
 		{
-		  addr = grub_pci_make_address (dev, 3);
+		  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CACHELINE);
 		  hdr = grub_pci_read (addr);
 		  if (!(hdr & 0x800000))
 		    break;

bus/usb/ohci.c

@@ -126,7 +126,7 @@ grub_ohci_pci_iter (grub_pci_device_t dev,
   grub_uint32_t revision;
   grub_uint32_t frame_interval;
 
-  addr = grub_pci_make_address (dev, 2);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
   class_code = grub_pci_read (addr) >> 8;
 
   interf = class_code & 0xFF;
@@ -138,7 +138,7 @@ grub_ohci_pci_iter (grub_pci_device_t dev,
     return 0;
 
   /* Determine IO base address.  */
-  addr = grub_pci_make_address (dev, 4);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
   base = grub_pci_read (addr);
 
 #if 0

bus/usb/uhci.c

@@ -150,7 +150,7 @@ grub_uhci_pci_iter (grub_pci_device_t dev,
   struct grub_uhci *u;
   int i;
 
-  addr = grub_pci_make_address (dev, 2);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
   class_code = grub_pci_read (addr) >> 8;
 
   interf = class_code & 0xFF;
@@ -162,7 +162,7 @@ grub_uhci_pci_iter (grub_pci_device_t dev,
     return 0;
 
   /* Determine IO base address.  */
-  addr = grub_pci_make_address (dev, 8);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG4);
   base = grub_pci_read (addr);
   /* Stop if there is no IO space base address defined.  */
   if (! (base & 1))

commands/cat.c

@@ -41,7 +41,7 @@ grub_cmd_cat (grub_command_t cmd __attribute__ ((unused)),
 
   file = grub_gzfile_open (args[0], 1);
   if (! file)
-    return 0;
+    return grub_errno;
 
   while ((size = grub_file_read (file, buf, sizeof (buf))) > 0
 	 && key != GRUB_TERM_ESC)

commands/efi/fixvideo.c

@@ -43,7 +43,7 @@ scan_card (grub_pci_device_t dev, grub_pci_id_t pciid)
 {
   grub_pci_address_t addr;
 
-  addr = grub_pci_make_address (dev, 2);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
   if (grub_pci_read_byte (addr + 3) == 0x3)
     {
       struct grub_video_patch *p = video_patches;

commands/efi/loadbios.c

@@ -51,7 +51,8 @@ enable_rom_area (void)
       return 0;
     }
 
-  addr = grub_pci_make_address (dev, 36);
+  /* FIXME: should be macroified.  */
+  addr = grub_pci_make_address (dev, 144);
   grub_pci_write_byte (addr++, 0x30);
   grub_pci_write_byte (addr++, 0x33);
   grub_pci_write_byte (addr++, 0x33);
@@ -77,7 +78,8 @@ lock_rom_area (void)
   grub_pci_address_t addr;
   grub_pci_device_t dev = { .bus = 0, .device = 0, .function = 0};
 
-  addr = grub_pci_make_address (dev, 36);
+  /* FIXME: should be macroified.  */
+  addr = grub_pci_make_address (dev, 144);
   grub_pci_write_byte (addr++, 0x10);
   grub_pci_write_byte (addr++, 0x11);
   grub_pci_write_byte (addr++, 0x11);

commands/hashsum.c

@@ -57,7 +57,7 @@ static grub_err_t
 hash_file (grub_file_t file, const gcry_md_spec_t *hash, void *result)
 {
   grub_uint8_t context[hash->contextsize];
-  char *readbuf[4096];
+  grub_uint8_t readbuf[4096];
 
   grub_memset (context, 0, sizeof (context));
   hash->init (context);
@@ -111,11 +111,9 @@ check_list (const gcry_md_spec_t *hash, const char *hashfilename,
 	{
 	  char *filename;
 	  
-	  filename = grub_malloc (grub_strlen (prefix)
+	  filename = grub_xasprintf ("%s/%s", prefix, p);
-				  + grub_strlen (p) + 2);
 	  if (!filename)
 	    return grub_errno;
-	  grub_sprintf (filename, "%s/%s", prefix, p);
 	  file = grub_file_open (filename);
 	  grub_free (filename);
 	}

commands/help.c

@@ -47,11 +47,9 @@ grub_cmd_help (grub_extcmd_t ext __attribute__ ((unused)), int argc,
 	  grub_uint32_t *unicode_command_help;
 	  grub_uint32_t *unicode_last_position;
 	  			      
-	  command_help = grub_malloc (grub_strlen (cmd->name) +
+	  command_help = grub_xasprintf ("%s %s", cmd->name, summary_translated);
-	  			      sizeof (" ") - 1 +
+	  if (!command_help)
-				      grub_strlen (summary_translated));
+	    return 1;
-	  			      
-	  grub_sprintf(command_help, "%s %s", cmd->name, summary_translated);
 
 	  grub_utf8_to_ucs4_alloc (command_help, &unicode_command_help,
 	  			   &unicode_last_position);

commands/i386/pc/play.c

@@ -29,7 +29,7 @@
 #include <grub/command.h>
 #include <grub/i18n.h>
 
-#define BASE_TEMPO 120
+#define BASE_TEMPO (60 * GRUB_TICKS_PER_SECOND)
 
 /* The speaker port.  */
 #define SPEAKER			0x61
@@ -101,13 +101,13 @@
 #define PIT_CTRL_COUNT_BINARY	0x00	/* 16-bit binary counter.  */
 #define PIT_CTRL_COUNT_BCD	0x01	/* 4-decade BCD counter.  */
 
-#define T_REST			((short) 0)
+#define T_REST			((grub_uint16_t) 0)
-#define T_FINE			((short) -1)
+#define T_FINE			((grub_uint16_t) -1)
 
 struct note
 {
-  short pitch;
+  grub_uint16_t pitch;
-  short duration;
+  grub_uint16_t duration;
 };
 
 static void
@@ -120,7 +120,7 @@ beep_off (void)
 }
 
 static void
-beep_on (short pitch)
+beep_on (grub_uint16_t pitch)
 {
   unsigned char status;
   unsigned int counter;
@@ -143,60 +143,111 @@ beep_on (short pitch)
   grub_outb (status | SPEAKER_TMR2 | SPEAKER_DATA, SPEAKER);
 }
 
+/* Returns whether playing should continue.  */
+static int
+play (unsigned tempo, struct note *note)
+{
+  unsigned int to;
+
+  if (note->pitch == T_FINE || grub_checkkey () >= 0)
+    return 1;
+
+  grub_dprintf ("play", "pitch = %d, duration = %d\n", note->pitch,
+                note->duration);
+
+  switch (note->pitch)
+    {
+      case T_REST:
+        beep_off ();
+        break;
+
+      default:
+        beep_on (note->pitch);
+        break;
+    }
+
+  to = grub_get_rtc () + BASE_TEMPO * note->duration / tempo;
+  while (((unsigned int) grub_get_rtc () <= to) && (grub_checkkey () < 0))
+    ;
+
+  return 0;
+}
+
 static grub_err_t
 grub_cmd_play (grub_command_t cmd __attribute__ ((unused)),
 	       int argc, char **args)
 {
   grub_file_t file;
-  struct note buf;
-  int tempo;
-  unsigned int to;
 
-  if (argc != 1)
+  if (argc < 1)
-    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name or tempo and notes required");
 
   file = grub_file_open (args[0]);
-  if (! file)
+  if (file)
-    return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
-
-  if (grub_file_read (file, &tempo, sizeof(tempo)) != sizeof(tempo))
     {
-      grub_file_close (file);
+      struct note buf;
-      return grub_error (GRUB_ERR_FILE_READ_ERROR,
+      grub_uint32_t tempo;
-                         "file doesn't even contains a full tempo record");
-    }
 
-  grub_dprintf ("play","tempo = %d\n", tempo);
+      if (grub_file_read (file, &tempo, sizeof (tempo)) != sizeof (tempo))
-
-  while (grub_file_read (file, &buf,
-                         sizeof (struct note)) == sizeof (struct note)
-         && buf.pitch != T_FINE && grub_checkkey () < 0)
-    {
-
-      grub_dprintf ("play", "pitch = %d, duration = %d\n", buf.pitch,
-                    buf.duration);
-
-      switch (buf.pitch)
         {
-          case T_REST:
+          grub_file_close (file);
-            beep_off ();
+          return grub_error (GRUB_ERR_FILE_READ_ERROR,
-            break;
+                             "file doesn't even contains a full tempo record");
+        }
 
-          default:
+      tempo = grub_le_to_cpu32 (tempo);
-            beep_on (buf.pitch);
+      grub_dprintf ("play","tempo = %d\n", tempo);
+
+      while (grub_file_read (file, &buf,
+                             sizeof (struct note)) == sizeof (struct note))
+        {
+          buf.pitch = grub_le_to_cpu16 (buf.pitch);
+          buf.duration = grub_le_to_cpu16 (buf.duration);
+
+          if (play (tempo, &buf))
             break;
         }
 
-      to = grub_get_rtc () + BASE_TEMPO * buf.duration / tempo;
+      grub_file_close (file);
-      while (((unsigned int) grub_get_rtc () <= to) && (grub_checkkey () < 0))
+    }
-        ;
+  else
+    {
+      char *end;
+      unsigned tempo;
+      struct note note;
+      int i;
 
+      tempo = grub_strtoul (args[0], &end, 0);
+
+      if (*end)
+        /* Was not a number either, assume it was supposed to be a file name.  */
+        return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
+
+      grub_dprintf ("play","tempo = %d\n", tempo);
+
+      for (i = 1; i + 1 < argc; i += 2)
+        {
+          note.pitch = grub_strtoul (args[i], &end, 0);
+          if (*end)
+            {
+              grub_error (GRUB_ERR_BAD_NUMBER, "bogus pitch number");
+              break;
+            }
+
+          note.duration = grub_strtoul (args[i + 1], &end, 0);
+          if (*end)
+            {
+              grub_error (GRUB_ERR_BAD_NUMBER, "bogus duration number");
+              break;
+            }
+
+          if (play (tempo, &note))
+            break;
+        }
     }
 
   beep_off ();
 
-  grub_file_close (file);
-
   while (grub_checkkey () > 0)
     grub_getkey ();
 
@@ -208,7 +259,8 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(play)
 {
   cmd = grub_register_command ("play", grub_cmd_play,
-			       N_("FILE"), N_("Play a tune."));
+			       N_("FILE | TEMPO [PITCH1 DURATION1] [PITCH2 DURATION2] ... "),
+			       N_("Play a tune."));
 }
 
 GRUB_MOD_FINI(play)

commands/i386/pc/vbetest.c

@@ -24,6 +24,7 @@
 #include <grub/term.h>
 #include <grub/machine/init.h>
 #include <grub/machine/vbe.h>
+#include <grub/video.h>
 #include <grub/err.h>
 #include <grub/i18n.h>
 

commands/loadenv.c

@@ -1,7 +1,7 @@
 /* loadenv.c - command to load/save environment variable.  */
 /*
  *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2008,2009  Free Software Foundation, Inc.
+ *  Copyright (C) 2008,2009,2010  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
@@ -196,7 +196,7 @@ free_blocklists (struct blocklist *p)
     }
 }
 
-static int
+static grub_err_t
 check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
                   grub_file_t file)
 {
@@ -219,8 +219,7 @@ check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
             {
               /* This might be actually valid, but it is unbelievable that
                  any filesystem makes such a silly allocation.  */
-              grub_error (GRUB_ERR_BAD_FS, "malformed file");
+              return grub_error (GRUB_ERR_BAD_FS, "malformed file");
-              return 0;
             }
         }
 
@@ -230,8 +229,7 @@ check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
   if (total_length != grub_file_size (file))
     {
       /* Maybe sparse, unallocated sectors. No way in GRUB.  */
-      grub_error (GRUB_ERR_BAD_FILE_TYPE, "sparse file not allowed");
+      return grub_error (GRUB_ERR_BAD_FILE_TYPE, "sparse file not allowed");
-      return 0;
     }
 
   /* One more sanity check. Re-read all sectors by blocklists, and compare
@@ -249,16 +247,13 @@ check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
 
       if (grub_disk_read (disk, p->sector - part_start,
                           p->offset, p->length, blockbuf))
-        return 0;
+        return grub_errno;
 
       if (grub_memcmp (buf + index, blockbuf, p->length) != 0)
-        {
+	return grub_error (GRUB_ERR_FILE_READ_ERROR, "invalid blocklist");
-          grub_error (GRUB_ERR_FILE_READ_ERROR, "invalid blocklist");
-          return 0;
-        }
     }
 
-  return 1;
+  return GRUB_ERR_NONE;
 }
 
 static int
@@ -347,7 +342,7 @@ grub_cmd_save_env (grub_extcmd_t cmd, int argc, char **args)
   if (! envblk)
     goto fail;
 
-  if (! check_blocklists (envblk, head, file))
+  if (check_blocklists (envblk, head, file))
     goto fail;
 
   while (argc)

commands/ls.c

@@ -87,19 +87,21 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
   int print_files_long (const char *filename,
 			const struct grub_dirhook_info *info)
     {
-      char pathname[grub_strlen (dirname) + grub_strlen (filename) + 1];
-
       if ((! all) && (filename[0] == '.'))
 	return 0;
 
       if (! info->dir)
 	{
 	  grub_file_t file;
+	  char *pathname;
 
 	  if (dirname[grub_strlen (dirname) - 1] == '/')
-	    grub_sprintf (pathname, "%s%s", dirname, filename);
+	    pathname = grub_xasprintf ("%s%s", dirname, filename);
 	  else
-	    grub_sprintf (pathname, "%s/%s", dirname, filename);
+	    pathname = grub_xasprintf ("%s/%s", dirname, filename);
+
+	  if (!pathname)
+	    return 1;
 
 	  /* XXX: For ext2fs symlinks are detected as files while they
 	     should be reported as directories.  */
@@ -107,6 +109,7 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
 	  if (! file)
 	    {
 	      grub_errno = 0;
+	      grub_free (pathname);
 	      return 0;
 	    }
 
@@ -131,8 +134,9 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
 		  grub_uint32_t whole, fraction;
 
 		  whole = grub_divmod64 (fsize, 100, &fraction);
-		  grub_sprintf (buf, "%u.%02u%c", whole, fraction,
+		  grub_snprintf (buf, sizeof (buf),
-				grub_human_sizes[units]);
+				 "%u.%02u%c", whole, fraction,
+				 grub_human_sizes[units]);
 		  grub_printf ("%-12s", buf);
 		}
 	      else
@@ -140,6 +144,7 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
 
 	    }
 	  grub_file_close (file);
+	  grub_free (pathname);
 	}
       else
 	grub_printf ("%-12s", "DIR");

commands/lspci.c

@@ -135,7 +135,7 @@ grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
   grub_printf ("%02x:%02x.%x %04x:%04x", grub_pci_get_bus (dev),
 	       grub_pci_get_device (dev), grub_pci_get_function (dev),
 	       pciid & 0xFFFF, pciid >> 16);
-  addr = grub_pci_make_address (dev, 2);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
   class = grub_pci_read (addr);
 
   /* Lookup the class name, if there isn't a specific one,
@@ -156,14 +156,14 @@ grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 
   if (iospace)
     {
-      reg = 4;
+      reg = GRUB_PCI_REG_ADDRESSES;
-      while (reg < 10)
+      while (reg < GRUB_PCI_REG_CIS_POINTER)
 	{
 	  grub_uint64_t space;
 	  addr = grub_pci_make_address (dev, reg);
 	  space = grub_pci_read (addr);
 
-	  reg++;
+	  reg += sizeof (grub_uint32_t);
 
 	  if (space == 0)
 	    continue;
@@ -171,7 +171,9 @@ grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 	  switch (space & GRUB_PCI_ADDR_SPACE_MASK)
 	    {
 	    case GRUB_PCI_ADDR_SPACE_IO:
-	      grub_printf ("\tIO space %d at 0x%llx\n", (reg - 1) - 4,
+	      grub_printf ("\tIO space %d at 0x%llx\n",
+			   (unsigned) ((reg - GRUB_PCI_REG_ADDRESSES)
+			    / sizeof (grub_uint32_t)) - 1,
 			   (unsigned long long)
 			   (space & GRUB_PCI_ADDR_IO_MASK));
 	      break;
@@ -181,9 +183,11 @@ grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 		{
 		  addr = grub_pci_make_address (dev, reg);
 		  space |= ((grub_uint64_t) grub_pci_read (addr)) << 32;
-		  reg++;
+		  reg += sizeof (grub_uint32_t);
 		  grub_printf ("\t64-bit memory space %d at 0x%016llx [%s]\n",
-			       (reg - 2) - 4, (unsigned long long)
+			       (unsigned) ((reg - GRUB_PCI_REG_ADDRESSES)
+				/ sizeof (grub_uint32_t)) - 2,
+			       (unsigned long long)
 			       (space & GRUB_PCI_ADDR_MEM_MASK),
 			       space & GRUB_PCI_ADDR_MEM_PREFETCH
 			       ? "prefetchable" : "non-prefetchable");
@@ -191,7 +195,9 @@ grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 		}
 	      else
 		grub_printf ("\t32-bit memory space %d at 0x%016llx [%s]\n",
-			     (reg - 1) - 4, (unsigned long long)
+			     (unsigned) ((reg - GRUB_PCI_REG_ADDRESSES)
+			      / sizeof (grub_uint32_t)) - 1,
+			     (unsigned long long) 
 			     (space & GRUB_PCI_ADDR_MEM_MASK),
 			     space & GRUB_PCI_ADDR_MEM_PREFETCH
 			     ? "prefetchable" : "non-prefetchable");

commands/memrw.c

@@ -62,7 +62,7 @@ grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
 
   if (cmd->state[0].set)
     {
-      grub_sprintf (buf, "%x", value);
+      grub_snprintf (buf, sizeof (buf), "%x", value);
       grub_env_set (cmd->state[0].arg, buf);
     }
   else

commands/minicmd.c

@@ -316,7 +316,6 @@ grub_mini_cmd_lsmod (struct grub_command *cmd __attribute__ ((unused)),
 	  grub_printf ("%s", dep->mod->name);
 	}
       grub_putchar ('\n');
-      grub_refresh ();
 
       return 0;
     }

commands/parttool.c

@@ -183,12 +183,11 @@ grub_cmd_parttool (grub_command_t cmd __attribute__ ((unused)),
       {
 	char *filename;
 
-	filename = grub_malloc (grub_strlen (prefix) + sizeof ("/parttool.lst"));
+	filename = grub_xasprintf ("%s/parttool.lst", prefix);
 	if (filename)
 	  {
 	    grub_file_t file;
 
-	    grub_sprintf (filename, "%s/parttool.lst", prefix);
 	    file = grub_file_open (filename);
 	    if (file)
 	      {

commands/search.c

@@ -33,7 +33,6 @@ void
 FUNC_NAME (const char *key, const char *var, int no_floppy)
 {
   int count = 0;
-  char *buf = NULL;
   grub_fs_autoload_hook_t saved_autoload;
 
   auto int iterate_device (const char *name);
@@ -48,24 +47,20 @@ FUNC_NAME (const char *key, const char *var, int no_floppy)
 
 #ifdef DO_SEARCH_FILE
       {
-	grub_size_t len;
+	char *buf;
-	char *p;
 	grub_file_t file;
 
-	len = grub_strlen (name) + 2 + grub_strlen (key) + 1;
+	buf = grub_xasprintf ("(%s)%s", name, key);
-	p = grub_realloc (buf, len);
+	if (! buf)
-	if (! p)
 	  return 1;
 
-	buf = p;
-	grub_sprintf (buf, "(%s)%s", name, key);
-
 	file = grub_file_open (buf);
 	if (file)
 	  {
 	    found = 1;
 	    grub_file_close (file);
 	  }
+	grub_free (buf);
       }
 #else
       {
@@ -135,8 +130,6 @@ FUNC_NAME (const char *key, const char *var, int no_floppy)
   else
     grub_device_iterate (iterate_device);
 
-  grub_free (buf);
-
   if (grub_errno == GRUB_ERR_NONE && count == 0)
     grub_error (GRUB_ERR_FILE_NOT_FOUND, "no such device: %s", key);
 }

commands/setpci.c

@@ -0,0 +1,340 @@
+/* lspci.c - List PCI devices.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008, 2009  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/>.
+ */
+
+#include <grub/pci.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/mm.h>
+
+struct pci_register
+{
+  const char *name;
+  grub_uint16_t addr;
+  unsigned size;
+};
+
+struct pci_register pci_registers[] =
+  {
+    {"VENDOR_ID",       GRUB_PCI_REG_VENDOR      , 2},
+    {"DEVICE_ID",       GRUB_PCI_REG_DEVICE      , 2},
+    {"COMMAND",         GRUB_PCI_REG_COMMAND     , 2},
+    {"STATUS",          GRUB_PCI_REG_STATUS      , 2},
+    {"REVISION",        GRUB_PCI_REG_REVISION    , 1},
+    {"CLASS_PROG",      GRUB_PCI_REG_CLASS + 1   , 1},
+    {"CLASS_DEVICE",    GRUB_PCI_REG_CLASS + 2   , 2},
+    {"CACHE_LINE_SIZE", GRUB_PCI_REG_CACHELINE   , 1},
+    {"LATENCY_TIMER",   GRUB_PCI_REG_LAT_TIMER   , 1},
+    {"HEADER_TYPE",     GRUB_PCI_REG_HEADER_TYPE , 1},
+    {"BIST",            GRUB_PCI_REG_BIST        , 1},
+    {"BASE_ADDRESS_0",  GRUB_PCI_REG_ADDRESS_REG0, 4},
+    {"BASE_ADDRESS_1",  GRUB_PCI_REG_ADDRESS_REG1, 4},
+    {"BASE_ADDRESS_2",  GRUB_PCI_REG_ADDRESS_REG2, 4},
+    {"BASE_ADDRESS_3",  GRUB_PCI_REG_ADDRESS_REG3, 4},
+    {"BASE_ADDRESS_4",  GRUB_PCI_REG_ADDRESS_REG4, 4},
+    {"BASE_ADDRESS_5",  GRUB_PCI_REG_ADDRESS_REG5, 4},
+    {"CARDBUS_CIS",     GRUB_PCI_REG_CIS_POINTER , 4},
+    {"SUBVENDOR_ID",    GRUB_PCI_REG_SUBVENDOR   , 2},
+    {"SUBSYSTEM_ID",    GRUB_PCI_REG_SUBSYSTEM   , 2},
+    {"ROM_ADDRESS",     GRUB_PCI_REG_ROM_ADDRESS , 4},
+    {"CAP_POINTER",     GRUB_PCI_REG_CAP_POINTER , 1},
+    {"INTERRUPT_LINE",  GRUB_PCI_REG_IRQ_LINE    , 1},
+    {"INTERRUPT_PIN",   GRUB_PCI_REG_IRQ_PIN     , 1},
+    {"MIN_GNT",         GRUB_PCI_REG_MIN_GNT     , 1},
+    {"MAX_LAT",         GRUB_PCI_REG_MIN_GNT     , 1},
+  };
+
+static const struct grub_arg_option options[] =
+  {
+    {0, 'd', 0, "Select device by vendor and device IDs.",
+     "[vendor]:[device]", ARG_TYPE_STRING},
+    {0, 's', 0, "Select device by its position on the bus.",
+     "[bus]:[slot][.func]", ARG_TYPE_STRING},
+    {0, 'v', 0, "Save read value into variable VARNAME.",
+     "VARNAME", ARG_TYPE_STRING},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_uint32_t pciid_check_mask, pciid_check_value;
+static int bus, device, function;
+static int check_bus, check_device, check_function;
+static grub_uint32_t write_mask, regwrite;
+static int regsize;
+static grub_uint16_t regaddr;
+static const char *varname;
+
+static int NESTED_FUNC_ATTR
+grub_setpci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
+{
+  grub_uint32_t regval = 0;
+  grub_pci_address_t addr;
+
+  if ((pciid & pciid_check_mask) != pciid_check_value)
+    return 0;
+
+  if (check_bus && grub_pci_get_bus (dev) != bus)
+    return 0;
+
+  if (check_device && grub_pci_get_device (dev) != device)
+    return 0;
+
+  if (check_function && grub_pci_get_function (dev) != device)
+    return 0;
+
+  addr = grub_pci_make_address (dev, regaddr);
+
+  switch (regsize)
+    {
+    case 1:
+      regval = grub_pci_read_byte (addr);
+      break;
+
+    case 2:
+      regval = grub_pci_read_word (addr);
+      break;
+
+    case 4:
+      regval = grub_pci_read (addr);
+      break;
+    }
+
+  if (varname)
+    {
+      char buf[sizeof ("XXXXXXXX")];
+      grub_snprintf (buf, sizeof (buf), "%x", regval);
+      grub_env_set (varname, buf);
+      return 1;
+    }
+
+  if (!write_mask)
+    {
+      grub_printf ("Register %x of %d:%d.%d is %x\n", regaddr,
+		   grub_pci_get_bus (dev),
+		   grub_pci_get_device (dev),
+		   grub_pci_get_function (dev),
+		   regval);
+      return 0;
+    }
+
+  regval = (regval & ~write_mask) | regwrite;
+
+  switch (regsize)
+    {
+    case 1:
+      grub_pci_write_byte (addr, regval);
+      break;
+
+    case 2:
+      grub_pci_write_word (addr, regval);
+      break;
+
+    case 4:
+      grub_pci_write (addr, regval);
+      break;
+    }
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_setpci (grub_extcmd_t cmd, int argc, char **argv)
+{
+  const char *ptr;
+  unsigned i;
+
+  pciid_check_value = 0;
+  pciid_check_mask = 0;
+
+  if (cmd->state[0].set)
+    {
+      ptr = cmd->state[0].arg;
+      pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff);
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  ptr = cmd->state[0].arg;
+	}
+      else
+	pciid_check_mask |= 0xffff;
+      if (grub_errno)
+	return grub_errno;
+      if (*ptr != ':')
+	return grub_error (GRUB_ERR_BAD_ARGUMENT, "Colon expected.");
+      ptr++;
+      pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff)
+	<< 16;
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	grub_errno = GRUB_ERR_NONE;
+      else
+	pciid_check_mask |= 0xffff0000;
+    }
+
+  pciid_check_value &= pciid_check_mask;
+
+  check_bus = check_device = check_function = 0;
+
+  if (cmd->state[1].set)
+    {
+      const char *optr;
+      
+      ptr = cmd->state[1].arg;
+      optr = ptr;
+      bus = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  ptr = optr;
+	}
+      else
+	check_bus = 1;
+      if (grub_errno)
+	return grub_errno;
+      if (*ptr != ':')
+	return grub_error (GRUB_ERR_BAD_ARGUMENT, "Colon expected.");
+      ptr++;
+      optr = ptr;
+      device = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  ptr = optr;
+	}
+      else
+	check_device = 1;
+      if (*ptr == '.')
+	{
+	  ptr++;
+	  function = grub_strtoul (ptr, (char **) &ptr, 16);
+	  if (grub_errno)
+	    return grub_errno;
+	  check_function = 1;
+	}
+    }
+
+  if (cmd->state[2].set)
+    varname = cmd->state[2].arg;
+  else
+    varname = NULL;
+
+  write_mask = 0;
+
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Command expected.");
+
+  if (argc > 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Only one command is supported.");
+
+  ptr = argv[0];
+
+  for (i = 0; i < ARRAY_SIZE (pci_registers); i++)
+    {
+      if (grub_strncmp (ptr, pci_registers[i].name,
+			grub_strlen (pci_registers[i].name)) == 0)
+	break;
+    }
+  if (i == ARRAY_SIZE (pci_registers))
+    {
+      regsize = 0;
+      regaddr = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno)
+	return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unknown register");
+    }
+  else
+    {
+      regaddr = pci_registers[i].addr;
+      regsize = pci_registers[i].size;
+      ptr += grub_strlen (pci_registers[i].name);
+    }
+
+  if (grub_errno)
+    return grub_errno;
+
+  if (*ptr == '+')
+    {
+      ptr++;
+      regaddr += grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno)
+	return grub_errno;
+    }
+
+  if (grub_memcmp (ptr, ".L", sizeof (".L") - 1) == 0
+      || grub_memcmp (ptr, ".l", sizeof (".l") - 1) == 0)
+    {
+      regsize = 4;
+      ptr += sizeof (".l") - 1;
+    }
+  else if (grub_memcmp (ptr, ".W", sizeof (".W") - 1) == 0
+      || grub_memcmp (ptr, ".w", sizeof (".w") - 1) == 0)
+    {
+      regsize = 2;
+      ptr += sizeof (".w") - 1;
+    }
+  else if (grub_memcmp (ptr, ".B", sizeof (".B") - 1) == 0
+      || grub_memcmp (ptr, ".b", sizeof (".b") - 1) == 0)
+    {
+      regsize = 1;
+      ptr += sizeof (".b") - 1;
+    }
+
+  if (!regsize)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT,
+		       "Unknown register size.");
+
+  write_mask = 0;
+  if (*ptr == '=')
+    {
+      ptr++;
+      regwrite = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno)
+	return grub_errno;
+      write_mask = 0xffffffff;
+      if (*ptr == ':')
+	{
+	  ptr++;
+	  write_mask = grub_strtoul (ptr, (char **) &ptr, 16);
+	  if (grub_errno)
+	    return grub_errno;
+	  write_mask = 0xffffffff;
+	}
+      regwrite &= write_mask;
+    }
+
+  if (write_mask && varname)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT,
+		       "Option -v isn't valid for writes.");
+
+  grub_pci_iterate (grub_setpci_iter);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(setpci)
+{
+  cmd = grub_register_extcmd ("setpci", grub_cmd_setpci, GRUB_COMMAND_FLAG_BOTH,
+			      "setpci [-s POSITION] [-d DEVICE] [-v VAR] "
+			      "[REGISTER][=VALUE[:MASK]]",
+			      "Manipulate PCI devices.", options);
+}
+
+GRUB_MOD_FINI(setpci)
+{
+  grub_unregister_extcmd (cmd);
+}

commands/terminal.c

@@ -1,6 +1,6 @@
 /*
  *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2009  Free Software Foundation, Inc.
+ *  Copyright (C) 2009,2010  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
@@ -112,10 +112,11 @@ grub_cmd_terminal_input (grub_command_t cmd __attribute__ ((unused)),
 	      break;
 	  if (term)
 	    {
+              if (term->init && term->init () != GRUB_ERR_NONE)
+                return grub_errno;
+
 	      grub_list_remove (GRUB_AS_LIST_P (&(grub_term_inputs_disabled)),
 				GRUB_AS_LIST (term));
-	      if (term->init)
-		term->init ();
 	      grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs),
 			      GRUB_AS_LIST (term));
 	    }
@@ -152,10 +153,11 @@ grub_cmd_terminal_input (grub_command_t cmd __attribute__ ((unused)),
 	  break;
       if (term)
 	{
+	  if (term->init && term->init () != GRUB_ERR_NONE)
+	    return grub_errno;
+
 	  grub_list_remove (GRUB_AS_LIST_P (&(grub_term_inputs_disabled)),
 			    GRUB_AS_LIST (term));
-	  if (term->init)
-	    term->init ();
 	  grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs),
 			  GRUB_AS_LIST (term));
 	}	
@@ -269,10 +271,11 @@ grub_cmd_terminal_output (grub_command_t cmd __attribute__ ((unused)),
 	      break;
 	  if (term)
 	    {
+              if (term->init && term->init () != GRUB_ERR_NONE)
+                return grub_errno;
+
 	      grub_list_remove (GRUB_AS_LIST_P (&(grub_term_outputs_disabled)),
 				GRUB_AS_LIST (term));
-	      if (term->init)
-		term->init ();
 	      grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs),
 			      GRUB_AS_LIST (term));
 	    }
@@ -310,10 +313,11 @@ grub_cmd_terminal_output (grub_command_t cmd __attribute__ ((unused)),
 	  break;
       if (term)
 	{
+	  if (term->init && term->init () != GRUB_ERR_NONE)
+	    return grub_errno;
+
 	  grub_list_remove (GRUB_AS_LIST_P (&(grub_term_outputs_disabled)),
 			    GRUB_AS_LIST (term));
-	  if (term->init)
-	    term->init ();
 	  grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs),
 			  GRUB_AS_LIST (term));
 	}	

commands/videotest.c

@@ -31,9 +31,7 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
                     int argc __attribute__ ((unused)),
                     char **args __attribute__ ((unused)))
 {
-  if (grub_video_set_mode ("1024x768;800x600;640x480", 0) != GRUB_ERR_NONE)
+  grub_err_t err;
-    return grub_errno;
-
   grub_video_color_t color;
   unsigned int x;
   unsigned int y;
@@ -50,6 +48,10 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
   const char *str;
   int texty;
 
+  err = grub_video_set_mode ("auto", GRUB_VIDEO_MODE_TYPE_PURE_TEXT, 0);
+  if (err)
+    return err;
+
   grub_video_get_viewport (&x, &y, &width, &height);
 
   grub_video_create_render_target (&text_layer, width, height,
@@ -67,9 +69,9 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
   color = grub_video_map_rgb (0, 255, 255);
   grub_video_fill_rect (color, 100, 100, 100, 100);
 
-  sansbig = grub_font_get ("Helvetica Bold 24");
+  sansbig = grub_font_get ("Unknown Regular 16");
-  sans = grub_font_get ("Helvetica Bold 14");
+  sans = grub_font_get ("Unknown Regular 16");
-  sanssmall = grub_font_get ("Helvetica 8");
+  sanssmall = grub_font_get ("Unknown Regular 16");
   fixed = grub_font_get ("Fixed 20");
   if (! sansbig || ! sans || ! sanssmall || ! fixed)
     return grub_error (GRUB_ERR_BAD_FONT, "no font loaded");
@@ -124,11 +126,6 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
   grub_font_draw_string (str, fixed, color, 16, texty);
   texty += grub_font_get_descent (fixed) + grub_font_get_leading (fixed);
 
-  /* Some character don't exist in the Helvetica font, so the font engine
-     will fall back to using glyphs from another font that does contain them.
-     TODO The font engine should be smart about selecting a replacement font
-     and prioritize fonts with similar sizes.  */
-
   texty += grub_font_get_ascent(sansbig);
   grub_font_draw_string (str, sansbig, color, 16, texty);
   texty += grub_font_get_descent (sansbig) + grub_font_get_leading (sansbig);
@@ -153,12 +150,13 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
 
   grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY);
 
-  for (i = 0; i < 255; i++)
+  for (i = 0; i < 5; i++)
     {
       color = grub_video_map_rgb (i, 33, 77);
       grub_video_fill_rect (color, 0, 0, width, height);
       grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, 0, 0,
                                      0, 0, width, height);
+      grub_video_swap_buffers ();
     }
 
   grub_getkey ();

commands/xnu_uuid.c

@@ -61,7 +61,7 @@ grub_cmd_xnu_uuid (grub_command_t cmd __attribute__ ((unused)),
   GRUB_MD_MD5->final (&ctx);
   xnu_uuid = GRUB_MD_MD5->read (&ctx);
 
-  grub_sprintf (uuid_string,
+  grub_snprintf (uuid_string, sizeof (uuid_string),
 		"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 		(unsigned int) xnu_uuid[0], (unsigned int) xnu_uuid[1],
 		(unsigned int) xnu_uuid[2], (unsigned int) xnu_uuid[3],

conf/any-emu.rmk

@@ -30,7 +30,7 @@ grub_emu_SOURCES = commands/minicmd.c commands/cat.c commands/cmp.c	\
 	normal/completion.c normal/main.c normal/color.c		\
 	normal/menu.c normal/menu_entry.c		\
 	normal/menu_text.c normal/crypto.c normal/term.c		\
-	commands/terminal.c lib/charset.c \
+	commands/terminal.c normal/context.c lib/charset.c \
 	script/main.c script/execute.c script/function.c		\
 	script/lexer.c script/script.c grub_script.tab.c		\
 	partmap/amiga.c	partmap/apple.c partmap/msdos.c partmap/sun.c	\
@@ -42,6 +42,20 @@ grub_emu_SOURCES = commands/minicmd.c commands/cat.c commands/cmp.c	\
 	fs/ufs.c fs/ufs2.c fs/xfs.c fs/afs.c fs/afs_be.c		\
 	fs/befs.c fs/befs_be.c fs/tar.c					\
 	\
+	video/video.c video/fb/video_fb.c video/fb/fbblit.c             \
+        video/fb/fbfill.c video/fb/fbutil.c commands/videotest.c        \
+	video/bitmap.c video/bitmap_scale.c video/readers/tga.c 	\
+	video/readers/jpeg.c video/readers/png.c font/font_cmd.c 	\
+	font/font.c term/gfxterm.c io/bufio.c				\
+	\
+	gfxmenu/gfxmenu.c gfxmenu/model.c gfxmenu/view.c 		\
+	gfxmenu/icon_manager.c gfxmenu/theme_loader.c 			\
+	gfxmenu/widget-box.c gfxmenu/gui_canvas.c 			\
+	gfxmenu/gui_circular_progress.c gfxmenu/gui_box.c 		\
+	gfxmenu/gui_label.c gfxmenu/gui_list.c gfxmenu/gui_image.c 	\
+	gfxmenu/gui_progress_bar.c gfxmenu/gui_util.c 			\
+	gfxmenu/gui_string_util.c gfxmenu/named_colors.c trigtables.c   \
+	\
 	util/console.c util/hostfs.c util/grub-emu.c util/misc.c	\
 	util/hostdisk.c util/getroot.c					\
 	\
@@ -65,6 +79,11 @@ grub_emu_SOURCES += disk/usbms.c util/usb.c bus/usb/usb.c	\
 grub_emu_LDFLAGS += $(LIBCURSES) $(LIBUSB)
 endif
 
+ifeq ($(enable_grub_emu_sdl), yes)
+grub_emu_SOURCES += util/sdl.c
+grub_emu_LDFLAGS += $(LIBSDL)
+endif
+
 ifeq ($(enable_grub_emu_pci), yes)
 grub_emu_SOURCES += util/pci.c commands/lspci.c
 grub_emu_LDFLAGS += $(LIBPCIACCESS)
@@ -87,6 +106,13 @@ DISTCLEANFILES += grub_emu_init.c
 
 # FIXME: this could be shared with common.rmk
 
+trigtables.c: gentrigtables
+	./gentrigtables > $@
+DISTCLEANFILES += trigtables.c
+gentrigtables: gentrigtables.c
+	$(CC) -o $@ $^ $(CPPFLAGS) -lm
+DISTCLEANFILES += gentrigtables
+
 # For grub-mkfont.
 ifeq ($(enable_grub_mkfont), yes)
 bin_UTILITIES += grub-mkfont
@@ -98,3 +124,6 @@ endif
 grub_script.tab.c grub_script.tab.h: script/parser.y
 	$(YACC) -d -p grub_script_yy -b grub_script $(srcdir)/script/parser.y
 DISTCLEANFILES += grub_script.tab.c grub_script.tab.h
+
+bin_UTILITIES += grub-bin2h
+grub_bin2h_SOURCES = gnulib/progname.c util/bin2h.c

conf/common.rmk

@@ -88,11 +88,36 @@ endif
 bin_UTILITIES += grub-mkrelpath
 grub_mkrelpath_SOURCES = gnulib/progname.c util/grub-mkrelpath.c util/misc.c
 
+bin_UTILITIES += grub-bin2h
+grub_bin2h_SOURCES = gnulib/progname.c util/bin2h.c
+
+# For grub-script-check.
+bin_UTILITIES += grub-script-check
+util/grub-script-check.c_DEPENDENCIES = grub_script_check_init.h
+grub_script_check_SOURCES = gnulib/progname.c gnulib/getdelim.c gnulib/getline.c \
+	util/grub-script-check.c util/misc.c \
+	script/main.c script/script.c script/function.c script/lexer.c \
+	kern/handler.c kern/err.c kern/parser.c kern/list.c \
+	kern/misc.c kern/env.c grub_script_check_init.c grub_script.tab.c
+
 # For the parser.
 grub_script.tab.c grub_script.tab.h: script/parser.y
 	$(YACC) -d -p grub_script_yy -b grub_script $(srcdir)/script/parser.y
 DISTCLEANFILES += grub_script.tab.c grub_script.tab.h
 
+# For grub-script-check.
+grub_script_check_init.lst: geninit.sh $(filter-out grub_script_check_init.c,$(grub_script_check_SOURCES))
+	rm -f $@; grep GRUB_MOD_INIT $(filter %.c,$^) /dev/null > $@
+DISTCLEANFILES += grub_script_check_init.lst
+
+grub_script_check_init.h: grub_script_check_init.lst $(filter-out grub_script_check_init.c,$(grub_script_check_SOURCES)) geninitheader.sh
+	rm -f $@; sh $(srcdir)/geninitheader.sh $< > $@
+DISTCLEANFILES += grub_script_check_init.h
+
+grub_script_check_init.c: grub_script_check_init.lst $(filter-out grub_script_check_init.c,$(grub_script_check_SOURCES)) geninit.sh
+	rm -f $@; sh $(srcdir)/geninit.sh $< $(filter %.c,$^) > $@
+DISTCLEANFILES += grub_script_check_init.c
+
 # For grub-probe.
 grub_probe_init.lst: geninit.sh $(filter-out grub_probe_init.c,$(grub_probe_SOURCES))
 	rm -f $@; grep GRUB_MOD_INIT $(filter %.c,$^) /dev/null > $@
@@ -427,6 +452,28 @@ hello_mod_SOURCES = hello/hello.c
 hello_mod_CFLAGS = $(COMMON_CFLAGS)
 hello_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+# For gfxmenu.mod.
+pkglib_MODULES += gfxmenu.mod
+gfxmenu_mod_SOURCES = \
+	gfxmenu/gfxmenu.c \
+	gfxmenu/model.c \
+	gfxmenu/view.c \
+	gfxmenu/icon_manager.c \
+	gfxmenu/theme_loader.c \
+	gfxmenu/widget-box.c \
+	gfxmenu/gui_canvas.c \
+	gfxmenu/gui_circular_progress.c \
+	gfxmenu/gui_box.c \
+	gfxmenu/gui_label.c \
+	gfxmenu/gui_list.c \
+	gfxmenu/gui_image.c \
+	gfxmenu/gui_progress_bar.c \
+	gfxmenu/gui_util.c \
+	gfxmenu/gui_string_util.c \
+	gfxmenu/named_colors.c
+gfxmenu_mod_CFLAGS = $(COMMON_CFLAGS)
+gfxmenu_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
 # For parttool.mod.
 parttool_mod_SOURCES = commands/parttool.c
 parttool_mod_CFLAGS = $(COMMON_CFLAGS)
@@ -564,7 +611,7 @@ normal_mod_SOURCES = normal/main.c normal/cmdline.c normal/dyncmd.c \
 	normal/auth.c normal/autofs.c normal/handler.c \
 	normal/color.c normal/completion.c normal/datetime.c normal/menu.c \
 	normal/menu_entry.c normal/menu_text.c \
-	normal/misc.c normal/crypto.c normal/term.c
+	normal/misc.c normal/crypto.c normal/term.c normal/context.c
 normal_mod_CFLAGS = $(COMMON_CFLAGS)
 normal_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
@@ -574,57 +621,78 @@ sh_mod_SOURCES = script/main.c script/script.c script/execute.c \
 sh_mod_CFLAGS = $(COMMON_CFLAGS)
 sh_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+ifneq (, $(FONT_SOURCE))
+font/font.c_DEPENDENCIES = ascii.h
+endif
+
 # Common Video Subsystem specific modules.
-pkglib_MODULES += video.mod videotest.mod bitmap.mod tga.mod jpeg.mod	\
+# On Yeeloong it's part of kernel
-	png.mod	font.mod gfxterm.mod video_fb.mod
+ifneq ($(platform), yeeloong)
 
 # For video.mod.
+pkglib_MODULES += video.mod
 video_mod_SOURCES = video/video.c
 video_mod_CFLAGS = $(COMMON_CFLAGS)
 video_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+pkglib_MODULES += video_fb.mod
 video_fb_mod_SOURCES = video/fb/video_fb.c video/fb/fbblit.c \
 		  video/fb/fbfill.c video/fb/fbutil.c
 video_fb_mod_CFLAGS = $(COMMON_CFLAGS)
 video_fb_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
-# For videotest.mod.
-videotest_mod_SOURCES = commands/videotest.c
-videotest_mod_CFLAGS = $(COMMON_CFLAGS)
-videotest_mod_LDFLAGS = $(COMMON_LDFLAGS)
-
 # For bitmap.mod
+pkglib_MODULES += bitmap.mod
 bitmap_mod_SOURCES = video/bitmap.c
 bitmap_mod_CFLAGS = $(COMMON_CFLAGS)
 bitmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
-# For tga.mod
+# For bitmap_scale.mod
-tga_mod_SOURCES = video/readers/tga.c
+pkglib_MODULES += bitmap_scale.mod
-tga_mod_CFLAGS = $(COMMON_CFLAGS)
+bitmap_scale_mod_SOURCES = video/bitmap_scale.c
-tga_mod_LDFLAGS = $(COMMON_LDFLAGS)
+bitmap_scale_mod_CFLAGS = $(COMMON_CFLAGS)
+bitmap_scale_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
-# For jpeg.mod.
+pkglib_MODULES += font.mod
-jpeg_mod_SOURCES = video/readers/jpeg.c
-jpeg_mod_CFLAGS = $(COMMON_CFLAGS)
-jpeg_mod_LDFLAGS = $(COMMON_LDFLAGS)
-
-# For png.mod.
-png_mod_SOURCES = video/readers/png.c
-png_mod_CFLAGS = $(COMMON_CFLAGS)
-png_mod_LDFLAGS = $(COMMON_LDFLAGS)
-
-# For font.mod.
 font_mod_SOURCES = font/font_cmd.c font/font.c
 font_mod_CFLAGS = $(COMMON_CFLAGS)
 font_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For gfxterm.mod.
+pkglib_MODULES += gfxterm.mod
 gfxterm_mod_SOURCES = term/gfxterm.c
 gfxterm_mod_CFLAGS = $(COMMON_CFLAGS)
 gfxterm_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+endif
+
+# For videotest.mod.
+pkglib_MODULES += videotest.mod
+videotest_mod_SOURCES = commands/videotest.c
+videotest_mod_CFLAGS = $(COMMON_CFLAGS)
+videotest_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For tga.mod
+pkglib_MODULES += tga.mod
+tga_mod_SOURCES = video/readers/tga.c
+tga_mod_CFLAGS = $(COMMON_CFLAGS)
+tga_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For jpeg.mod.
+pkglib_MODULES += jpeg.mod
+jpeg_mod_SOURCES = video/readers/jpeg.c
+jpeg_mod_CFLAGS = $(COMMON_CFLAGS)
+jpeg_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For png.mod.
+pkglib_MODULES += png.mod
+png_mod_SOURCES = video/readers/png.c
+png_mod_CFLAGS = $(COMMON_CFLAGS)
+png_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+
 # Misc.
-pkglib_MODULES += gzio.mod bufio.mod elf.mod
+pkglib_MODULES += gzio.mod elf.mod
 
 # For elf.mod.
 elf_mod_SOURCES = kern/elf.c
@@ -636,10 +704,14 @@ gzio_mod_SOURCES = io/gzio.c
 gzio_mod_CFLAGS = $(COMMON_CFLAGS)
 gzio_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+# On Yeeloong it's part of kernel
+ifneq ($(platform), yeeloong)
 # For bufio.mod.
+pkglib_MODULES += bufio.mod
 bufio_mod_SOURCES = io/bufio.c
 bufio_mod_CFLAGS = $(COMMON_CFLAGS)
 bufio_mod_LDFLAGS = $(COMMON_LDFLAGS)
+endif
 
 # For gettext.mod.
 pkglib_MODULES += gettext.mod
@@ -655,6 +727,18 @@ xnu_uuid_mod_SOURCES = commands/xnu_uuid.c
 xnu_uuid_mod_CFLAGS = $(COMMON_CFLAGS)
 xnu_uuid_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+pkglib_MODULES += trig.mod
+trig_mod_SOURCES = trigtables.c
+trig_mod_CFLAGS = $(COMMON_CFLAGS)
+trig_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+trigtables.c: gentrigtables
+	./gentrigtables > $@
+DISTCLEANFILES += trigtables.c
+gentrigtables: gentrigtables.c
+	$(CC) -o $@ $^ $(CPPFLAGS) -lm
+DISTCLEANFILES += gentrigtables
+
 pkglib_MODULES += setjmp.mod
 setjmp_mod_SOURCES = lib/$(target_cpu)/setjmp.S
 setjmp_mod_ASFLAGS = $(COMMON_ASFLAGS)
@@ -692,7 +776,7 @@ password_pbkdf2_mod_CFLAGS = $(COMMON_CFLAGS)
 password_pbkdf2_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 bin_UTILITIES += grub-mkpasswd-pbkdf2
-grub_mkpasswd_pbkdf2_SOURCES = gnulib/progname.c util/grub-mkpasswd-pbkdf2.c lib/crypto.c lib/libgcrypt-grub/cipher/sha512.c lib/pbkdf2.c util/misc.c kern/err.c
+grub_mkpasswd_pbkdf2_SOURCES = gnulib/progname.c gnulib/getdelim.c gnulib/getline.c util/grub-mkpasswd-pbkdf2.c lib/crypto.c lib/libgcrypt-grub/cipher/sha512.c lib/pbkdf2.c util/misc.c kern/err.c
 grub_mkpasswd_pbkdf2_CFLAGS += -Wno-missing-field-initializers -Wno-error -I$(srcdir)/lib/libgcrypt_wrap -DGRUB_MKPASSWD=1
 
 include $(srcdir)/conf/gcry.mk

conf/i386-coreboot.rmk

@@ -35,7 +35,8 @@ kernel_img_HEADERS = boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
 	env.h err.h file.h fs.h kernel.h loader.h misc.h mm.h net.h parser.h \
 	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
 	machine/boot.h machine/console.h machine/init.h \
-	machine/memory.h machine/loader.h list.h handler.h command.h i18n.h
+	machine/memory.h machine/loader.h list.h handler.h command.h i18n.h \
+	env_private.h
 kernel_img_CFLAGS = $(COMMON_CFLAGS)
 kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
 kernel_img_LDFLAGS = $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,$(GRUB_KERNEL_MACHINE_LINK_ADDR),-Bstatic
@@ -53,9 +54,11 @@ boot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)$(GRUB_BOOT_MACHINE_LI
 boot_img_FORMAT = binary
 
 bin_UTILITIES += grub-mkimage
-grub_mkimage_SOURCES = util/i386/pc/grub-mkimage.c util/misc.c \
+grub_mkimage_SOURCES = util/grub-mkrawimage.c util/misc.c \
 	util/resolve.c gnulib/progname.c
 grub_mkimage_CFLAGS = -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(GRUB_KERNEL_MACHINE_LINK_ADDR)
+util/grub-mkrawimage.c_DEPENDENCIES = Makefile
+
 
 pkglib_IMAGES += kernel.img
 kernel_img_SOURCES = kern/i386/qemu/startup.S \
@@ -79,7 +82,8 @@ kernel_img_HEADERS = boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
 	env.h err.h file.h fs.h kernel.h loader.h misc.h mm.h net.h parser.h \
 	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
 	machine/boot.h machine/console.h machine/init.h \
-	machine/memory.h machine/loader.h list.h handler.h command.h i18n.h
+	machine/memory.h machine/loader.h list.h handler.h command.h i18n.h \
+	env_private.h
 kernel_img_CFLAGS = $(COMMON_CFLAGS) -DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_MACHINE_LINK_ADDR)
 kernel_img_ASFLAGS = $(COMMON_ASFLAGS) -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(GRUB_KERNEL_MACHINE_LINK_ADDR)
 kernel_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)$(GRUB_KERNEL_MACHINE_LINK_ADDR)
@@ -136,7 +140,7 @@ halt_mod_CFLAGS = $(COMMON_CFLAGS)
 halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For serial.mod.
-serial_mod_SOURCES = term/i386/pc/serial.c
+serial_mod_SOURCES = term/serial.c
 serial_mod_CFLAGS = $(COMMON_CFLAGS)
 serial_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
@@ -173,7 +177,7 @@ lspci_mod_CFLAGS = $(COMMON_CFLAGS)
 lspci_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For datetime.mod
-datetime_mod_SOURCES = lib/i386/datetime.c
+datetime_mod_SOURCES = lib/cmos_datetime.c
 datetime_mod_CFLAGS = $(COMMON_CFLAGS)
 datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
 

conf/i386-efi.rmk

@@ -30,13 +30,14 @@ sbin_SCRIPTS = grub-install
 grub_install_SOURCES = util/i386/efi/grub-install.in
 
 # Modules.
-pkglib_MODULES = kernel.img chain.mod appleldr.mod \
+pkglib_PROGRAMS = kernel.img
+pkglib_MODULES = chain.mod appleldr.mod \
 	linux.mod halt.mod reboot.mod pci.mod lspci.mod \
 	datetime.mod date.mod datehook.mod loadbios.mod \
 	fixvideo.mod mmap.mod acpi.mod
 
 # For kernel.img.
-kernel_img_EXPORTS = no
+kernel_img_RELOCATABLE = yes
 kernel_img_SOURCES = kern/i386/efi/startup.S kern/main.c kern/device.c \
 	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
 	kern/misc.c kern/mm.c kern/term.c \
@@ -51,7 +52,8 @@ kernel_img_SOURCES = kern/i386/efi/startup.S kern/main.c kern/device.c \
 kernel_img_HEADERS = boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
 	env.h err.h file.h fs.h kernel.h loader.h misc.h mm.h net.h parser.h \
 	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
-	efi/efi.h efi/time.h efi/disk.h i386/pit.h list.h handler.h command.h i18n.h
+	efi/efi.h efi/time.h efi/disk.h i386/pit.h list.h handler.h command.h \
+	i18n.h env_private.h
 kernel_img_CFLAGS = $(COMMON_CFLAGS)
 kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
 kernel_img_LDFLAGS = $(COMMON_LDFLAGS)

conf/i386-ieee1275.rmk

@@ -33,7 +33,7 @@ kernel_img_HEADERS = cache.h device.h disk.h dl.h elf.h elfload.h \
 	env.h err.h file.h fs.h kernel.h loader.h misc.h mm.h net.h parser.h \
 	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
 	ieee1275/ieee1275.h machine/kernel.h machine/loader.h machine/memory.h \
-	list.h handler.h command.h i18n.h
+	list.h handler.h command.h i18n.h env_private.h
 kernel_img_CFLAGS = $(COMMON_CFLAGS)
 kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
 kernel_img_LDFLAGS = $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,0x10000,-Bstatic
@@ -92,7 +92,7 @@ halt_mod_CFLAGS = $(COMMON_CFLAGS)
 halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For serial.mod.
-serial_mod_SOURCES = term/i386/pc/serial.c
+serial_mod_SOURCES = term/serial.c
 serial_mod_CFLAGS = $(COMMON_CFLAGS)
 serial_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
@@ -122,7 +122,7 @@ lspci_mod_CFLAGS = $(COMMON_CFLAGS)
 lspci_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For datetime.mod
-datetime_mod_SOURCES = lib/i386/datetime.c
+datetime_mod_SOURCES = lib/cmos_datetime.c
 datetime_mod_CFLAGS = $(COMMON_CFLAGS)
 datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
 

conf/i386-pc.rmk

@@ -64,7 +64,8 @@ kernel_img_HEADERS = boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
 	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
 	machine/biosdisk.h machine/boot.h machine/console.h machine/init.h \
 	machine/memory.h machine/loader.h machine/vga.h machine/vbe.h \
-	machine/kernel.h machine/pxe.h i386/pit.h list.h handler.h command.h i18n.h
+	machine/kernel.h machine/pxe.h i386/pit.h list.h handler.h command.h \
+	i18n.h env_private.h
 kernel_img_CFLAGS = $(COMMON_CFLAGS)  $(TARGET_IMG_CFLAGS)
 kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
 kernel_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)$(GRUB_KERNEL_MACHINE_LINK_ADDR) $(COMMON_CFLAGS)
@@ -84,10 +85,10 @@ bin_UTILITIES = grub-mkimage
 sbin_UTILITIES = grub-setup
 
 # For grub-mkimage.
-grub_mkimage_SOURCES = gnulib/progname.c util/i386/pc/grub-mkimage.c util/misc.c \
+grub_mkimage_SOURCES = gnulib/progname.c util/grub-mkrawimage.c util/misc.c \
 	util/resolve.c lib/LzmaEnc.c lib/LzFind.c
 grub_mkimage_CFLAGS = -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(GRUB_KERNEL_MACHINE_LINK_ADDR)
-util/i386/pc/grub-mkimage.c_DEPENDENCIES = Makefile
+util/grub-mkrawimage.c_DEPENDENCIES = Makefile
 
 # For grub-setup.
 util/i386/pc/grub-setup.c_DEPENDENCIES = grub_setup_init.h
@@ -197,7 +198,7 @@ halt_mod_CFLAGS = $(COMMON_CFLAGS)
 halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For serial.mod.
-serial_mod_SOURCES = term/i386/pc/serial.c
+serial_mod_SOURCES = term/serial.c
 serial_mod_CFLAGS = $(COMMON_CFLAGS)
 serial_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
@@ -293,7 +294,7 @@ pxecmd_mod_CFLAGS = $(COMMON_CFLAGS)
 pxecmd_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For datetime.mod
-datetime_mod_SOURCES = lib/i386/datetime.c
+datetime_mod_SOURCES = lib/cmos_datetime.c
 datetime_mod_CFLAGS = $(COMMON_CFLAGS)
 datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
 

conf/i386.rmk

@@ -6,7 +6,7 @@ cpuid_mod_CFLAGS = $(COMMON_CFLAGS)
 cpuid_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 pkglib_MODULES += at_keyboard.mod
-at_keyboard_mod_SOURCES = term/i386/pc/at_keyboard.c
+at_keyboard_mod_SOURCES = term/at_keyboard.c
 at_keyboard_mod_CFLAGS = $(COMMON_CFLAGS)
 at_keyboard_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
@@ -26,6 +26,12 @@ ata_mod_SOURCES = disk/ata.c
 ata_mod_CFLAGS = $(COMMON_CFLAGS)
 ata_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+# For setpci.mod
+pkglib_MODULES += setpci.mod
+setpci_mod_SOURCES = commands/setpci.c
+setpci_mod_CFLAGS = $(COMMON_CFLAGS)
+setpci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
 pkglib_MODULES += multiboot.mod
 multiboot_mod_SOURCES = loader/i386/multiboot.c \
 			loader/i386/multiboot_mbi.c \

conf/mips-qemu-mips.rmk

@@ -0,0 +1,23 @@
+# -*- makefile -*-
+LINK_BASE = 0x80010000
+target_machine=qemu-mips
+COMMON_CFLAGS += -march=mips3
+COMMON_ASFLAGS += -march=mips3
+include $(srcdir)/conf/mips.mk
+
+pkglib_IMAGES = kernel.img
+kernel_img_SOURCES = kern/$(target_cpu)/startup.S \
+	kern/main.c kern/device.c kern/$(target_cpu)/init.c \
+	kern/$(target_cpu)/$(target_machine)/init.c 		\
+	kern/disk.c kern/dl.c kern/err.c kern/file.c kern/fs.c 		\
+	kern/misc.c kern/mm.c kern/term.c 	\
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/list.c kern/handler.c kern/command.c kern/corecmd.c	\
+	kern/parser.c kern/partition.c kern/env.c kern/$(target_cpu)/dl.c 	\
+	kern/generic/millisleep.c kern/generic/rtc_get_time_ms.c kern/time.c    \
+	symlist.c kern/$(target_cpu)/cache.S
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS = $(COMMON_LDFLAGS) -static-libgcc -lgcc \
+	-Wl,-N,-S,-Ttext,$(LINK_BASE),-Bstatic
+kernel_img_FORMAT = binary

conf/mips-yeeloong.rmk

@@ -0,0 +1,87 @@
+# -*- makefile -*-
+LINK_BASE = 0x80200000
+target_machine=yeeloong
+COMMON_CFLAGS += -march=mips3
+COMMON_ASFLAGS += -march=mips3
+
+kernel_img_HEADERS += bitmap.h video.h gfxterm.h font.h bitmap_scale.h bufio.h
+
+include $(srcdir)/conf/mips.mk
+
+pkglib_IMAGES = kernel.img
+kernel_img_SOURCES = kern/$(target_cpu)/startup.S \
+	kern/main.c kern/device.c kern/$(target_cpu)/init.c \
+	kern/$(target_cpu)/$(target_machine)/init.c 		\
+	kern/disk.c kern/dl.c kern/err.c kern/file.c kern/fs.c 		\
+	kern/misc.c kern/mm.c kern/term.c 	\
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/list.c kern/handler.c kern/command.c kern/corecmd.c	\
+	kern/parser.c kern/partition.c kern/env.c kern/$(target_cpu)/dl.c 	\
+	kern/generic/millisleep.c kern/generic/rtc_get_time_ms.c kern/time.c    \
+	kern/$(target_cpu)/cache.S \
+	\
+	term/at_keyboard.c \
+	font/font_cmd.c font/font.c io/bufio.c \
+	video/video.c video/fb/video_fb.c video/fb/fbblit.c \
+	video/fb/fbfill.c video/fb/fbutil.c video/bitmap.c \
+	video/bitmap_scale.c video/sm712.c bus/pci.c bus/bonito.c \
+	term/gfxterm.c commands/extcmd.c lib/arg.c \
+	symlist.c
+kernel_img_CFLAGS = $(COMMON_CFLAGS) -DUSE_ASCII_FAILBACK
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS = $(COMMON_LDFLAGS) -static-libgcc -lgcc \
+	-Wl,-N,-S,-Ttext,$(LINK_BASE),-Bstatic
+kernel_img_FORMAT = binary
+
+# For ata.mod.
+pkglib_MODULES += ata.mod
+ata_mod_SOURCES = disk/ata.c
+ata_mod_CFLAGS = $(COMMON_CFLAGS)
+ata_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For lspci.mod
+pkglib_MODULES += lspci.mod
+lspci_mod_SOURCES = commands/lspci.c
+lspci_mod_CFLAGS = $(COMMON_CFLAGS)
+lspci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ata_pthru.mod.
+pkglib_MODULES += ata_pthru.mod
+ata_pthru_mod_SOURCES = disk/ata_pthru.c
+ata_pthru_mod_CFLAGS = $(COMMON_CFLAGS)
+ata_pthru_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For mmap.mod.
+pkglib_MODULES += mmap.mod
+mmap_mod_SOURCES = mmap/mmap.c mmap/mips/yeeloong/uppermem.c
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+mmap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For datetime.mod
+pkglib_MODULES += datetime.mod
+datetime_mod_SOURCES = lib/cmos_datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For date.mod
+pkglib_MODULES += date.mod
+date_mod_SOURCES = commands/date.c
+date_mod_CFLAGS = $(COMMON_CFLAGS)
+date_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For datehook.mod
+pkglib_MODULES += datehook.mod
+datehook_mod_SOURCES = hook/datehook.c
+datehook_mod_CFLAGS = $(COMMON_CFLAGS)
+datehook_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += linux.mod
+linux_mod_SOURCES = loader/$(target_cpu)/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_ASFLAGS = $(COMMON_ASFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+sbin_SCRIPTS += grub-install
+grub_install_SOURCES = util/grub-install.in
+

conf/mips.rmk

@@ -0,0 +1,76 @@
+
+# -*- makefile -*-
+
+COMMON_ASFLAGS += -nostdinc
+COMMON_CFLAGS += -ffreestanding -mexplicit-relocs -mflush-func=grub_cpu_flush_cache
+COMMON_LDFLAGS += -nostdlib
+
+# Used by various components.  These rules need to precede them.
+script/lexer.c_DEPENDENCIES = grub_script.tab.h
+
+# Images.
+
+MOSTLYCLEANFILES += symlist.c kernel_syms.lst
+DEFSYMFILES += kernel_syms.lst
+
+kernel_img_HEADERS += boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
+	env.h err.h file.h fs.h kernel.h misc.h mm.h net.h parser.h reader.h \
+	symbol.h term.h time.h types.h loader.h partition.h \
+	msdos_partition.h machine/kernel.h handler.h list.h \
+	command.h machine/memory.h cpu/libgcc.h cpu/cache.h i18n.h env_private.h
+
+ifeq ($(platform), yeeloong)
+kernel_img_HEADERS += pci.h
+endif
+
+symlist.c: $(addprefix include/grub/,$(kernel_img_HEADERS)) config.h gensymlist.sh
+	/bin/sh gensymlist.sh $(filter %.h,$^) > $@ || (rm -f $@; exit 1)
+
+kernel_syms.lst: $(addprefix include/grub/,$(kernel_img_HEADERS)) config.h genkernsyms.sh
+	/bin/sh genkernsyms.sh $(filter %.h,$^) > $@ || (rm -f $@; exit 1)
+
+# Scripts.
+sbin_SCRIPTS = 
+bin_SCRIPTS = 
+
+# For grub-mkimage.
+bin_UTILITIES += grub-mkimage
+grub_mkimage_SOURCES = gnulib/progname.c util/grub-mkrawimage.c util/misc.c \
+	util/resolve.c lib/LzmaEnc.c lib/LzFind.c
+grub_mkimage_CFLAGS = -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(LINK_BASE)
+util/grub-mkrawimage.c_DEPENDENCIES = Makefile
+
+# Modules.
+pkglib_MODULES = memdisk.mod \
+	lsmmap.mod
+
+# For boot.mod.
+pkglib_MODULES += boot.mod 
+boot_mod_SOURCES = commands/boot.c lib/i386/pc/biosnum.c
+boot_mod_CFLAGS = $(COMMON_CFLAGS)
+boot_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For memdisk.mod.
+memdisk_mod_SOURCES = disk/memdisk.c
+memdisk_mod_CFLAGS = $(COMMON_CFLAGS)
+memdisk_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For lsmmap.mod
+lsmmap_mod_SOURCES = commands/lsmmap.c
+lsmmap_mod_CFLAGS = $(COMMON_CFLAGS)
+lsmmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For serial.mod.
+pkglib_MODULES += serial.mod
+serial_mod_SOURCES = term/serial.c
+serial_mod_CFLAGS = $(COMMON_CFLAGS)
+serial_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For relocator.mod.
+pkglib_MODULES += relocator.mod
+relocator_mod_SOURCES = lib/$(target_cpu)/relocator.c lib/$(target_cpu)/relocator_asm.S
+relocator_mod_CFLAGS = $(COMMON_CFLAGS)
+relocator_mod_ASFLAGS = $(COMMON_ASFLAGS)
+relocator_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+include $(srcdir)/conf/common.mk

conf/powerpc-ieee1275.rmk

@@ -17,7 +17,7 @@ kernel_img_HEADERS = boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
 	env.h err.h file.h fs.h kernel.h misc.h mm.h net.h parser.h reader.h \
 	symbol.h term.h time.h types.h powerpc/libgcc.h loader.h partition.h \
 	msdos_partition.h ieee1275/ieee1275.h machine/kernel.h handler.h list.h \
-	command.h i18n.h
+	command.h i18n.h env_private.h
 
 symlist.c: $(addprefix include/grub/,$(kernel_img_HEADERS)) config.h gensymlist.sh
 	/bin/sh gensymlist.sh $(filter %.h,$^) > $@ || (rm -f $@; exit 1)

conf/sparc64-ieee1275.rmk

@@ -31,7 +31,7 @@ kernel_img_HEADERS = boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
 	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
 	list.h handler.h command.h i18n.h \
 	sparc64/libgcc.h ieee1275/ieee1275.h machine/kernel.h \
-	sparc64/ieee1275/ieee1275.h
+	sparc64/ieee1275/ieee1275.h env_private.h
 kernel_img_SOURCES = kern/sparc64/ieee1275/crt0.S kern/ieee1275/cmain.c	\
 	kern/ieee1275/ieee1275.c kern/main.c kern/device.c		\
 	kern/disk.c kern/dl.c kern/err.c kern/file.c kern/fs.c		\

conf/x86_64-efi.rmk

@@ -29,13 +29,14 @@ sbin_SCRIPTS = grub-install
 grub_install_SOURCES = util/i386/efi/grub-install.in
 
 # Modules.
-pkglib_MODULES = kernel.img chain.mod appleldr.mod 	\
+pkglib_PROGRAMS = kernel.img
+pkglib_MODULES = chain.mod appleldr.mod 	\
 	halt.mod reboot.mod linux.mod pci.mod lspci.mod \
 	datetime.mod date.mod datehook.mod loadbios.mod \
 	fixvideo.mod mmap.mod acpi.mod
 
 # For kernel.img.
-kernel_img_EXPORTS = no
+kernel_img_RELOCATABLE = yes
 kernel_img_SOURCES = kern/x86_64/efi/startup.S kern/x86_64/efi/callwrap.S \
 	kern/main.c kern/device.c \
 	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
@@ -51,7 +52,7 @@ kernel_img_HEADERS = boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
 	env.h err.h file.h fs.h kernel.h loader.h misc.h mm.h net.h parser.h \
 	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
 	efi/efi.h efi/time.h efi/disk.h machine/loader.h i386/pit.h list.h \
-	handler.h command.h i18n.h
+	handler.h command.h i18n.h env_private.h
 kernel_img_CFLAGS = $(COMMON_CFLAGS)
 kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
 kernel_img_LDFLAGS = $(COMMON_LDFLAGS)

configure.ac

@@ -31,7 +31,7 @@ dnl (such as TARGET_CC, TARGET_CFLAGS, etc.) are used for the target
 dnl type.
 
 
-AC_INIT([GRUB],[1.97],[bug-grub@gnu.org])
+AC_INIT([GRUB],[1.98],[bug-grub@gnu.org])
 AM_INIT_AUTOMAKE()
 AC_PREREQ(2.60)
 AC_CONFIG_SRCDIR([include/grub/dl.h])
@@ -51,7 +51,18 @@ fi
 
 case "$target_cpu" in
   i[[3456]]86)	target_cpu=i386 ;;
+  amd64)	target_cpu=x86_64 ;;
   sparc)	target_cpu=sparc64 ;;
+  mipsel|mips64el)
+                target_cpu=mips;    
+		TARGET_CFLAGS="$TARGET_CFLAGS -DGRUB_CPU_MIPSEL=1"; 
+		CFLAGS="$CFLAGS -DGRUB_CPU_MIPSEL=1";
+		;;
+  mips|mips64)
+                target_cpu=mips;    
+		TARGET_CFLAGS="$TARGET_CFLAGS -DGRUB_CPU_MIPS=1"; 
+		CFLAGS="$CFLAGS -DGRUB_CPU_MIPS=1";
+		;;
 esac
 
 # Specify the platform (such as firmware).
@@ -69,6 +80,7 @@ if test "x$with_platform" = x; then
     powerpc-*) platform=ieee1275 ;;
     powerpc64-*) platform=ieee1275 ;;
     sparc64-*) platform=ieee1275 ;;
+    mips-*) platform=yeeloong ;;
     *) AC_MSG_ERROR([unsupported CPU: "$target_cpu"]) ;;
   esac
 else
@@ -95,6 +107,8 @@ case "$target_cpu"-"$platform" in
   i386-qemu) ;;
   powerpc-ieee1275) ;;
   sparc64-ieee1275) ;;
+  mips-qemu-mips) ;;
+  mips-yeeloong) ;;
   *-emu) ;;
   *) AC_MSG_ERROR([platform "$platform" is not supported for target CPU "$target_cpu"]) ;;
 esac
@@ -125,6 +139,8 @@ case "$platform" in
   qemu)		machine_CFLAGS="-DGRUB_MACHINE_QEMU=1" ;;
   pc)		machine_CFLAGS="-DGRUB_MACHINE_PCBIOS=1" ;;
   emu)		machine_CFLAGS="-DGRUB_MACHINE_EMU=1" ;;
+  yeeloong)	machine_CFLAGS="-DGRUB_MACHINE_MIPS_YEELOONG=1 -DGRUB_MACHINE_MIPS=1 -DGRUB_MACHINE_MIPS_BONITO=1" ;;
+  qemu-mips)	machine_CFLAGS="-DGRUB_MACHINE_MIPS_QEMU_MIPS=1 -DGRUB_MACHINE_MIPS=1 -DGRUB_MACHINE_MIPS_BONITO=1" ;;
 esac
 CFLAGS="$CFLAGS $machine_CFLAGS"
 TARGET_ASFLAGS="$TARGET_ASFLAGS $machine_CFLAGS"
@@ -153,7 +169,7 @@ if test "x$YACC" = x; then
   AC_MSG_ERROR([bison is not found])
 fi
 
-for file in /usr/src/unifont.bdf /usr/share/fonts/X11/misc/unifont.pcf.gz ; do
+for file in /usr/src/unifont.bdf /usr/share/fonts/X11/misc/unifont.pcf.gz /usr/share/fonts/unifont/unifont.pcf.gz; do
   if test -e $file ; then
     AC_SUBST([FONT_SOURCE], [$file])
     break
@@ -206,7 +222,7 @@ AC_HEADER_MAJOR
 AC_HEADER_DIRENT
 AC_CHECK_FUNCS(memmove sbrk strdup lstat getuid getgid)
 AC_CHECK_HEADERS(sys/mkdev.h sys/sysmacros.h malloc.h termios.h sys/types.h)
-AC_CHECK_HEADERS(unistd.h string.h strings.h sys/stat.h sys/fcntl.h)
+AC_CHECK_HEADERS(unistd.h string.h strings.h sys/stat.h sys/fcntl.h limits.h)
 
 #
 # Check for target programs.
@@ -423,18 +439,26 @@ AC_SUBST(TARGET_ASFLAGS)
 AC_SUBST(TARGET_CPPFLAGS)
 AC_SUBST(TARGET_LDFLAGS)
 
-# Check for libgcc symbols (must be performed before we add -nostdlib to LDFLAGS)
-AC_CHECK_FUNCS(__bswapsi2 __bswapdi2 __ashldi3 __ashrdi3 __lshrdi3 __trampoline_setup __ucmpdi2)
-
 # Set them to their new values for the tests below.
 CC="$TARGET_CC"
+if test "x$TARGET_APPLE_CC" = x1 ; then
+CFLAGS="$TARGET_CFLAGS -nostdlib -Wno-error"
+else
+CFLAGS="$TARGET_CFLAGS -nostdlib -Wl,--defsym,___main=0x8100 -Wl,--defsym,abort=main -Wno-error"
+fi
+CPPFLAGS="$TARGET_CPPFLAGS"
+LDFLAGS="$TARGET_LDFLAGS"
+LIBS=-lgcc
+
+# Check for libgcc symbols
+AC_CHECK_FUNCS(__bswapsi2 __bswapdi2 __ashldi3 __ashrdi3 __lshrdi3 __trampoline_setup __ucmpdi2 _restgpr_14_x)
+
 if test "x$TARGET_APPLE_CC" = x1 ; then
 CFLAGS="$TARGET_CFLAGS -nostdlib"
 else
 CFLAGS="$TARGET_CFLAGS -nostdlib -Wl,--defsym,___main=0x8100"
 fi
-CPPFLAGS="$TARGET_CPPFLAGS"
+LIBS=""
-LDFLAGS="$TARGET_LDFLAGS"
 
 # Defined in aclocal.m4.
 grub_PROG_TARGET_CC
@@ -493,6 +517,19 @@ enable_efiemu=no
 fi
 AC_SUBST([enable_efiemu])
 
+AC_CACHE_CHECK([whether -nostdinc -isystem works], [grub_cv_cc_isystem], [
+  SAVED_CPPFLAGS="$CPPFLAGS"
+  CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
+  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
+int va_arg_func (int fixed, va_list args);]], [[]])],
+      [grub_cv_cc_isystem=yes],
+      [grub_cv_cc_isystem=no])
+  CPPFLAGS="$SAVED_CPPFLAGS"
+])
+
+if test x"$grub_cv_cc_isystem" = xyes ; then
+  TARGET_CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
+fi
 
 # Restore the flags.
 CC="$tmp_CC"
@@ -516,6 +553,10 @@ AC_ARG_ENABLE([grub-emu-usb],
 	      [AS_HELP_STRING([--enable-grub-emu-usb],
                              [build and install the `grub-emu' debugging utility with USB support (default=guessed)])])
 
+AC_ARG_ENABLE([grub-emu-sdl],
+	      [AS_HELP_STRING([--enable-grub-emu-sdl],
+                             [build and install the `grub-emu' debugging utility with SDL support (default=guessed)])])
+
 AC_ARG_ENABLE([grub-emu-pci],
 	      [AS_HELP_STRING([--enable-grub-emu-pci],
                              [build and install the `grub-emu' debugging utility with PCI support (potentially dangerous) (default=no)])])
@@ -566,6 +607,31 @@ else
 enable_grub_emu_usb=no
 fi
 
+if test x"$enable_grub_emu_sdl" = xno ; then
+  grub_emu_sdl_excuse="explicitely disabled"
+fi
+[if [ x"$grub_emu_sdl_excuse" = x ]; then
+    # Check for libSDL libraries.]
+AC_CHECK_LIB([SDL], [SDL_Init], [LIBSDL="-lSDL"],
+    [grub_emu_sdl_excuse=["libSDL libraries are required to build \`grub-emu' with SDL support"]])
+    AC_SUBST([LIBSDL])
+[fi]
+
+[if [ x"$grub_emu_sdl_excuse" = x ]; then
+    # Check for headers.]
+    AC_CHECK_HEADERS([SDL/SDL.h], [],
+      [grub_emu_sdl_excuse=["libSDL header file is required to build \`grub-emu' with SDL support"]])
+[fi]
+
+if test x"enable_grub_emu_sdl" = xyes && test x"$grub_emu_sdl_excuse" != x ; then
+  AC_MSG_ERROR([SDL support for grub-emu was explicitely requested but can't be compiled])
+fi
+if test x"$grub_emu_sdl_excuse" = x ; then
+enable_grub_emu_sdl=yes
+else
+enable_grub_emu_sdl=no
+fi
+
 if test x"$enable_grub_emu_pci" != xyes ; then
    grub_emu_pci_excuse="not enabled"
 fi
@@ -589,9 +655,11 @@ fi
 if test x"$grub_emu_pci_excuse" = x ; then
 enable_grub_emu_pci=yes
 else
+
 enable_grub_emu_pci=no
 fi
 
+AC_SUBST([enable_grub_emu_sdl])
 AC_SUBST([enable_grub_emu_usb])
 AC_SUBST([enable_grub_emu_pci])
 fi
@@ -625,6 +693,16 @@ if test x"$grub_mkfont_excuse" = x ; then
   freetype_cflags=`freetype-config --cflags`
   freetype_libs=`freetype-config --libs`
 fi
+
+if test x"$grub_mkfont_excuse" = x ; then
+  # Check for freetype libraries.
+  SAVED_CPPFLAGS="$CPPFLAGS"
+  CPPFLAGS="$CPPFLAGS $freetype_cflags"
+  AC_CHECK_HEADERS([ft2build.h], [],
+  	[grub_mkfont_excuse=["need freetype2 headers"]])
+  CPPFLAGS="$SAVED_CPPFLAGS"
+fi
+
 if test x"$enable_grub_mkfont" = xyes && test x"$grub_mkfont_excuse" != x ; then
   AC_MSG_ERROR([grub-mkfont was explicitly requested but can't be compiled])
 fi
@@ -668,6 +746,11 @@ echo USB support for grub-emu: Yes
 else
 echo USB support for grub-emu: No "($grub_emu_usb_excuse)"
 fi
+if [ x"$grub_emu_sdl_excuse" = x ]; then
+echo SDL support for grub-emu: Yes
+else
+echo SDL support for grub-emu: No "($grub_emu_sdl_excuse)"
+fi
 if [ x"$grub_emu_pci_excuse" = x ]; then
 echo PCI support for grub-emu: Yes
 else

disk/ata.c

@@ -26,8 +26,8 @@
 #include <grub/scsi.h>
 
 /* At the moment, only two IDE ports are supported.  */
-static const int grub_ata_ioaddress[] = { 0x1f0, 0x170 };
+static const grub_port_t grub_ata_ioaddress[] = { 0x1f0, 0x170 };
-static const int grub_ata_ioaddress2[] = { 0x3f6, 0x376 };
+static const grub_port_t grub_ata_ioaddress2[] = { 0x3f6, 0x376 };
 
 static struct grub_ata_device *grub_ata_devices;
 
@@ -347,8 +347,8 @@ grub_ata_device_initialize (int port, int device, int addr, int addr2)
   /* Setup the device information.  */
   dev->port = port;
   dev->device = device;
-  dev->ioaddress = addr;
+  dev->ioaddress = addr + GRUB_MACHINE_PCI_IO_BASE;
-  dev->ioaddress2 = addr2;
+  dev->ioaddress2 = addr2 + GRUB_MACHINE_PCI_IO_BASE;
   dev->next = NULL;
 
   grub_ata_regset (dev, GRUB_ATA_REG_DISK, dev->device << 4);
@@ -389,7 +389,7 @@ grub_ata_device_initialize (int port, int device, int addr, int addr2)
 
 static int NESTED_FUNC_ATTR
 grub_ata_pciinit (grub_pci_device_t dev,
-		  grub_pci_id_t pciid __attribute__((unused)))
+		  grub_pci_id_t pciid)
 {
   static int compat_use[2] = { 0 };
   grub_pci_address_t addr;
@@ -400,19 +400,34 @@ grub_ata_pciinit (grub_pci_device_t dev,
   int regb;
   int i;
   static int controller = 0;
+  int cs5536 = 0;
+  int nports = 2;
 
   /* Read class.  */
-  addr = grub_pci_make_address (dev, 2);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
   class = grub_pci_read (addr);
 
+  /* AMD CS5536 Southbridge.  */
+  if (pciid == 0x208f1022)
+    {
+      cs5536 = 1;
+      nports = 1;
+    }
+
   /* Check if this class ID matches that of a PCI IDE Controller.  */
-  if (class >> 16 != 0x0101)
+  if (!cs5536 && (class >> 16 != 0x0101))
     return 0;
 
-  for (i = 0; i < 2; i++)
+  for (i = 0; i < nports; i++)
     {
       /* Set to 0 when the channel operated in compatibility mode.  */
-      int compat = (class >> (8 + 2 * i)) & 1;
+      int compat;
+
+      /* We don't support non-compatibility mode for CS5536.  */
+      if (cs5536)
+	compat = 0;
+      else
+	compat = (class >> (8 + 2 * i)) & 1;
 
       rega = 0;
       regb = 0;
@@ -429,9 +444,12 @@ grub_ata_pciinit (grub_pci_device_t dev,
 	{
 	  /* Read the BARs, which either contain a mmapped IO address
 	     or the IO port address.  */
-	  addr = grub_pci_make_address (dev, 4 + 2 * i);
+	  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESSES
+					+ sizeof (grub_uint64_t) * i);
 	  bar1 = grub_pci_read (addr);
-	  addr = grub_pci_make_address (dev, 5 + 2 * i);
+	  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESSES
+					+ sizeof (grub_uint64_t) * i
+					+ sizeof (grub_uint32_t));
 	  bar2 = grub_pci_read (addr);
 
 	  /* Check if the BARs describe an IO region.  */
@@ -485,7 +503,6 @@ grub_ata_initialize (void)
   return 0;
 }
 
-
 static void
 grub_ata_setlba (struct grub_ata_device *dev, grub_disk_addr_t sector,
 		 grub_size_t size)
@@ -648,12 +665,14 @@ grub_ata_iterate (int (*hook) (const char *name))
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[5];
+      char devname[10];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
 
       if (dev->atapi)
 	continue;
 
+      grub_snprintf (devname, sizeof (devname), 
+		     "ata%d", dev->port * 2 + dev->device);
+
       if (hook (devname))
 	return 1;
     }
@@ -668,8 +687,9 @@ grub_ata_open (const char *name, grub_disk_t disk)
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[5];
+      char devname[10];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
+      grub_snprintf (devname, sizeof (devname),
+		     "ata%d", dev->port * 2 + dev->device);
       if (grub_strcmp (name, devname) == 0)
 	break;
     }
@@ -735,8 +755,9 @@ grub_atapi_iterate (int (*hook) (const char *name, int luns))
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[7];
+      char devname[10];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
+      grub_snprintf (devname, sizeof (devname),
+		     "ata%d", dev->port * 2 + dev->device);
 
       if (! dev->atapi)
 	continue;
@@ -808,8 +829,9 @@ grub_atapi_open (const char *name, struct grub_scsi *scsi)
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[7];
+      char devname[10];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
+      grub_snprintf (devname, sizeof (devname),
+		     "ata%d", dev->port * 2 + dev->device);
 
       if (!grub_strcmp (devname, name))
 	{

disk/efi/efidisk.c

@@ -440,7 +440,7 @@ grub_efidisk_iterate (int (*hook) (const char *name))
 
   for (d = fd_devices, count = 0; d; d = d->next, count++)
     {
-      grub_sprintf (buf, "fd%d", count);
+      grub_snprintf (buf, sizeof (buf), "fd%d", count);
       grub_dprintf ("efidisk", "iterating %s\n", buf);
       if (hook (buf))
 	return 1;
@@ -448,7 +448,7 @@ grub_efidisk_iterate (int (*hook) (const char *name))
 
   for (d = hd_devices, count = 0; d; d = d->next, count++)
     {
-      grub_sprintf (buf, "hd%d", count);
+      grub_snprintf (buf, sizeof (buf), "hd%d", count);
       grub_dprintf ("efidisk", "iterating %s\n", buf);
       if (hook (buf))
 	return 1;
@@ -456,7 +456,7 @@ grub_efidisk_iterate (int (*hook) (const char *name))
 
   for (d = cd_devices, count = 0; d; d = d->next, count++)
     {
-      grub_sprintf (buf, "cd%d", count);
+      grub_snprintf (buf, sizeof (buf), "cd%d", count);
       grub_dprintf ("efidisk", "iterating %s\n", buf);
       if (hook (buf))
 	return 1;
@@ -805,18 +805,10 @@ grub_efidisk_get_device_name (grub_efi_handle_t *handle)
 	  return 0;
 	}
 
-      device_name = grub_malloc (grub_strlen (parent->name) + 1
+      device_name = grub_xasprintf ("%s,%s", parent->name, partition_name);
-				 + grub_strlen (partition_name) + 1);
-      if (! device_name)
-	{
-	  grub_free (partition_name);
-	  grub_disk_close (parent);
-	  return 0;
-	}
-
-      grub_sprintf (device_name, "%s,%s", parent->name, partition_name);
       grub_free (partition_name);
       grub_disk_close (parent);
+
       return device_name;
     }
   else
@@ -833,7 +825,7 @@ grub_efidisk_get_device_name (grub_efi_handle_t *handle)
 	  if (! disk)
 	    return 1;
 
-	  if (disk->id == GRUB_DISK_DEVICE_EFIDISK_ID)
+	  if (disk->dev->id == GRUB_DISK_DEVICE_EFIDISK_ID)
 	    {
 	      struct grub_efidisk_data *d;
 

disk/i386/pc/biosdisk.c

@@ -56,7 +56,8 @@ grub_biosdisk_call_hook (int (*hook) (const char *name), int drive)
 {
   char name[10];
 
-    grub_sprintf (name, (drive & 0x80) ? "hd%d" : "fd%d", drive & (~0x80));
+  grub_snprintf (name, sizeof (name),
+		 (drive & 0x80) ? "hd%d" : "fd%d", drive & (~0x80));
   return hook (name);
 }
 
@@ -306,8 +307,17 @@ grub_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
   while (size)
     {
       grub_size_t len;
+      grub_size_t cdoff = 0;
 
       len = get_safe_sectors (sector, data->sectors);
+
+      if (data->flags & GRUB_BIOSDISK_FLAG_CDROM)
+	{
+	  cdoff = (sector & 3) << GRUB_DISK_SECTOR_BITS;
+	  len = ALIGN_UP (sector + len, 4) - (sector & ~3);
+	  sector &= ~3;
+	}
+
       if (len > size)
 	len = size;
 
@@ -315,7 +325,7 @@ grub_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
 			    GRUB_MEMORY_MACHINE_SCRATCH_SEG))
 	return grub_errno;
 
-      grub_memcpy (buf, (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR,
+      grub_memcpy (buf, (void *) (GRUB_MEMORY_MACHINE_SCRATCH_ADDR + cdoff),
 		   len << GRUB_DISK_SECTOR_BITS);
       buf += len << GRUB_DISK_SECTOR_BITS;
       sector += len;
@@ -331,6 +341,9 @@ grub_biosdisk_write (grub_disk_t disk, grub_disk_addr_t sector,
 {
   struct grub_biosdisk_data *data = disk->data;
 
+  if (data->flags & GRUB_BIOSDISK_FLAG_CDROM)
+    return grub_error (GRUB_ERR_IO, "can't write to CDROM");
+
   while (size)
     {
       grub_size_t len;

disk/ieee1275/ofdisk.c

@@ -118,7 +118,7 @@ grub_ofdisk_iterate (int (*hook) (const char *name))
 static char *
 compute_dev_path (const char *name)
 {
-  char *devpath = grub_malloc (grub_strlen (name) + 2);
+  char *devpath = grub_malloc (grub_strlen (name) + 3);
   char *p, c;
 
   if (!devpath)
@@ -172,16 +172,6 @@ grub_ofdisk_open (const char *name, grub_disk_t disk)
 
   grub_dprintf ("disk", "Opening `%s'.\n", op->devpath);
 
-  grub_ieee1275_open (op->devpath, &dev_ihandle);
-  if (! dev_ihandle)
-    {
-      grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't open device");
-      goto fail;
-    }
-
-  grub_dprintf ("disk", "Opened `%s' as handle %p.\n", op->devpath,
-		(void *) (unsigned long) dev_ihandle);
-
   if (grub_ieee1275_finddevice (op->devpath, &dev))
     {
       grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't read device properties");
@@ -201,6 +191,16 @@ grub_ofdisk_open (const char *name, grub_disk_t disk)
       goto fail;
     }
 
+  grub_ieee1275_open (op->devpath, &dev_ihandle);
+  if (! dev_ihandle)
+    {
+      grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't open device");
+      goto fail;
+    }
+
+  grub_dprintf ("disk", "Opened `%s' as handle %p.\n", op->devpath,
+		(void *) (unsigned long) dev_ihandle);
+
   /* XXX: There is no property to read the number of blocks.  There
      should be a property `#blocks', but it is not there.  Perhaps it
      is possible to use seek for this.  */
@@ -234,21 +234,17 @@ grub_ofdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
   grub_ssize_t status, actual;
   unsigned long long pos;
 
-  grub_dprintf ("disk",
-		"Reading handle %p: sector 0x%llx, size 0x%lx, buf %p.\n",
-		(void *) disk->data, (long long) sector, (long) size, buf);
-
   pos = sector * 512UL;
 
   grub_ieee1275_seek ((grub_ieee1275_ihandle_t) (unsigned long) disk->data,
-		      (int) (pos >> 32), (int) pos & 0xFFFFFFFFUL, &status);
+		      pos, &status);
   if (status < 0)
     return grub_error (GRUB_ERR_READ_ERROR,
 		       "seek error, can't seek block %llu",
 		       (long long) sector);
   grub_ieee1275_read ((grub_ieee1275_ihandle_t) (unsigned long) disk->data,
 		      buf, size * 512UL, &actual);
-  if (actual != actual)
+  if (actual != (grub_ssize_t) (size * 512UL))
     return grub_error (GRUB_ERR_READ_ERROR, "read error on block: %llu",
 		       (long long) sector);
 

disk/raid.c

@@ -556,7 +556,7 @@ insert_array (grub_disk_t disk, struct grub_raid_array *new_array,
             }
         }
 
-      array->name = grub_malloc (13);
+      array->name = grub_xasprintf ("md%d", array->number);
       if (! array->name)
         {
           grub_free (array->uuid);
@@ -565,8 +565,6 @@ insert_array (grub_disk_t disk, struct grub_raid_array *new_array,
           return grub_errno;
         }
 
-      grub_sprintf (array->name, "md%d", array->number);
-
       grub_dprintf ("raid", "Found array %s (%s)\n", array->name,
                     scanner_name);
 

disk/scsi.c

@@ -197,7 +197,6 @@ grub_scsi_iterate (int (*hook) (const char *name))
 
   int scsi_iterate (const char *name, int luns)
     {
-      char sname[40];
       int i;
 
       /* In case of a single LUN, just return `usbX'.  */
@@ -208,8 +207,14 @@ grub_scsi_iterate (int (*hook) (const char *name))
 	 distinguish it.  */
       for (i = 0; i < luns; i++)
 	{
-	  grub_sprintf (sname, "%s%c", name, 'a' + i);
+	  char *sname;
-	  if (hook (sname))
+	  int ret;
+	  sname = grub_xasprintf ("%s%c", name, 'a' + i);
+	  if (!sname)
+	    return 1;
+	  ret = hook (sname);
+	  grub_free (sname);
+	  if (ret)
 	    return 1;
 	}
       return 0;

disk/usbms.c

@@ -200,11 +200,15 @@ grub_usbms_iterate (int (*hook) (const char *name, int luns))
 
   for (p = grub_usbms_dev_list; p; p = p->next)
     {
-      char devname[20];
+      char *devname;
-      grub_sprintf (devname, "usb%d", cnt);
+      devname = grub_xasprintf ("usb%d", cnt);
 
       if (hook (devname, p->luns))
-	return 1;
+	{
+	  grub_free (devname);
+	  return 1;
+	}
+      grub_free (devname);
       cnt++;
     }
 

docs/grub.texi

@@ -1126,6 +1126,7 @@ you forget a command, you can run the command @command{help}
 * insmod::                      Insert a module
 * keystatus::                   Check key modifier status
 * ls::                          List devices or files
+* play::                        Play a tune
 * reboot::                      Reboot your computer
 * set::                         Set an environment variable
 * unset::                       Unset an environment variable
@@ -1364,6 +1365,24 @@ name syntax}), then list the contents of that directory.
 @end deffn
 
 
+@node play
+@subsection play
+
+@deffn Command play file | tempo [pitch1 duration1] [pitch2 duration2] ...
+Plays a tune
+
+If the argument is a file name (@pxref{File name syntax}), play the tune
+recorded in it.  The file format is first the tempo as an unsigned 32bit
+little-endian number, then pairs of unsigned 16bit little-endian numbers for
+pitch and duration pairs.
+
+If the arguments are a series of numbers, play the inline tune.
+
+The tempo is the base for all note durations. 60 gives a 1-second base, 120
+gives a half-second base, etc.  Pitches are Hz.
+@end deffn
+
+
 @node reboot
 @subsection reboot
 

efiemu/main.c

@@ -255,12 +255,11 @@ grub_efiemu_autocore (void)
 
   suffix = grub_efiemu_get_default_core_name ();
 
-  filename = grub_malloc (grub_strlen (prefix) + grub_strlen (suffix) + 2);
+  filename = grub_xasprintf ("%s/%s", prefix, suffix);
   if (! filename)
     return grub_error (GRUB_ERR_OUT_OF_MEMORY,
 		       "couldn't allocate temporary space");
 
-  grub_sprintf (filename, "%s/%s", prefix, suffix);
 
   err = grub_efiemu_load_file (filename);
   grub_free (filename);

font/font.c

@@ -1,7 +1,7 @@
 /* font.c - Font API and font file loader.  */
 /*
  *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2003,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
+ *  Copyright (C) 2003,2005,2006,2007,2008,2009,2010  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
@@ -26,6 +26,11 @@
 #include <grub/types.h>
 #include <grub/video.h>
 #include <grub/bitmap.h>
+#include <grub/fontformat.h>
+
+#ifdef USE_ASCII_FAILBACK
+#include "ascii.h"
+#endif
 
 #ifndef FONT_DEBUG
 #define FONT_DEBUG 0
@@ -43,6 +48,7 @@ struct char_index_entry
 
 #define FONT_WEIGHT_NORMAL 100
 #define FONT_WEIGHT_BOLD 200
+#define ASCII_BITMAP_SIZE 16
 
 struct grub_font
 {
@@ -58,6 +64,7 @@ struct grub_font
   short leading;
   grub_uint32_t num_chars;
   struct char_index_entry *char_index;
+  grub_uint16_t *bmp_idx;
 };
 
 /* Definition of font registry.  */
@@ -83,19 +90,6 @@ struct font_file_section
   int eof;
 };
 
-/* Font file format constants.  */
-static const char pff2_magic[4] = { 'P', 'F', 'F', '2' };
-static const char section_names_file[4] = { 'F', 'I', 'L', 'E' };
-static const char section_names_font_name[4] = { 'N', 'A', 'M', 'E' };
-static const char section_names_point_size[4] = { 'P', 'T', 'S', 'Z' };
-static const char section_names_weight[4] = { 'W', 'E', 'I', 'G' };
-static const char section_names_max_char_width[4] = { 'M', 'A', 'X', 'W' };
-static const char section_names_max_char_height[4] = { 'M', 'A', 'X', 'H' };
-static const char section_names_ascent[4] = { 'A', 'S', 'C', 'E' };
-static const char section_names_descent[4] = { 'D', 'E', 'S', 'C' };
-static const char section_names_char_index[4] = { 'C', 'H', 'I', 'X' };
-static const char section_names_data[4] = { 'D', 'A', 'T', 'A' };
-
 /* Replace unknown glyphs with a rounded question mark.  */
 static grub_uint8_t unknown_glyph_bitmap[] =
 {
@@ -129,6 +123,48 @@ static struct grub_font null_font;
 /* Flag to ensure module is initialized only once.  */
 static grub_uint8_t font_loader_initialized;
 
+#ifdef USE_ASCII_FAILBACK
+static struct grub_font_glyph *ascii_font_glyph[0x80];
+#endif
+
+static struct grub_font_glyph *
+ascii_glyph_lookup (grub_uint32_t code)
+{
+#ifdef USE_ASCII_FAILBACK 
+  static int ascii_failback_initialized = 0;
+
+  if (code >= 0x80)
+    return unknown_glyph;
+
+  if (ascii_failback_initialized == 0)
+    {
+      int current;
+      for (current = 0; current < 0x80; current++)
+        {
+	  ascii_font_glyph[current] = grub_malloc(sizeof(struct grub_font_glyph)
+	  			+ ASCII_BITMAP_SIZE);
+
+          ascii_font_glyph[current]->width = 8;
+          ascii_font_glyph[current]->height = 16; 
+          ascii_font_glyph[current]->offset_x = 0; 
+          ascii_font_glyph[current]->offset_y = -2; 
+	  ascii_font_glyph[current]->device_width = 8;
+
+	  grub_memcpy (ascii_font_glyph[current]->bitmap,
+		       &ascii_bitmaps[(0x7f - current) * ASCII_BITMAP_SIZE],
+		       ASCII_BITMAP_SIZE);
+	}
+
+      ascii_failback_initialized = 1;
+    }
+
+  return ascii_font_glyph[code];
+#else
+  (void) code;
+  return unknown_glyph;
+#endif
+}
+
 void
 grub_font_loader_init (void)
 {
@@ -180,6 +216,7 @@ font_init (grub_font_t font)
   font->descent = 0;
   font->num_chars = 0;
   font->char_index = 0;
+  font->bmp_idx = 0;
 }
 
 /* Open the next section in the file.
@@ -273,6 +310,14 @@ load_font_index (grub_file_t file, grub_uint32_t sect_length, struct
                                   * sizeof (struct char_index_entry));
   if (! font->char_index)
     return 1;
+  font->bmp_idx = grub_malloc (0x10000 * sizeof (grub_uint16_t));
+  if (! font->bmp_idx)
+    {
+      grub_free (font->char_index);
+      return 1;
+    }
+  grub_memset (font->bmp_idx, 0xff, 0x10000 * sizeof (grub_uint16_t));
+
 
 #if FONT_DEBUG >= 2
   grub_printf("num_chars=%d)\n", font->num_chars);
@@ -299,6 +344,9 @@ load_font_index (grub_file_t file, grub_uint32_t sect_length, struct
           return 1;
         }
 
+      if (entry->code < 0x10000)
+	font->bmp_idx[entry->code] = i;
+
       last_code = entry->code;
 
       /* Read storage flags byte.  */
@@ -400,7 +448,8 @@ grub_font_load (const char *filename)
 #if FONT_DEBUG >= 3
   grub_printf("opened FILE section\n");
 #endif
-  if (grub_memcmp (section.name, section_names_file, 4) != 0)
+  if (grub_memcmp (section.name, FONT_FORMAT_SECTION_NAMES_FILE,
+  		   sizeof(FONT_FORMAT_SECTION_NAMES_FILE) - 1) != 0)
     {
       grub_error (GRUB_ERR_BAD_FONT,
                   "font file format error: 1st section must be FILE");
@@ -429,7 +478,7 @@ grub_font_load (const char *filename)
   grub_printf("read magic ok\n");
 #endif
 
-  if (grub_memcmp (magic, pff2_magic, 4) != 0)
+  if (grub_memcmp (magic, FONT_FORMAT_PFF2_MAGIC, 4) != 0)
     {
       grub_error (GRUB_ERR_BAD_FONT, "invalid font magic %x %x %x %x",
                   magic[0], magic[1], magic[2], magic[3]);
@@ -469,18 +518,22 @@ grub_font_load (const char *filename)
                   section.name[2], section.name[3]);
 #endif
 
-      if (grub_memcmp (section.name, section_names_font_name, 4) == 0)
+      if (grub_memcmp (section.name, FONT_FORMAT_SECTION_NAMES_FONT_NAME,
+      		       sizeof(FONT_FORMAT_SECTION_NAMES_FONT_NAME) - 1) == 0)
         {
           font->name = read_section_as_string (&section);
           if (!font->name)
             goto fail;
         }
-      else if (grub_memcmp (section.name, section_names_point_size, 4) == 0)
+      else if (grub_memcmp (section.name,
+      			    FONT_FORMAT_SECTION_NAMES_POINT_SIZE,
+			    sizeof(FONT_FORMAT_SECTION_NAMES_POINT_SIZE) - 1) == 0)
         {
           if (read_section_as_short (&section, &font->point_size) != 0)
             goto fail;
         }
-      else if (grub_memcmp (section.name, section_names_weight, 4) == 0)
+      else if (grub_memcmp (section.name, FONT_FORMAT_SECTION_NAMES_WEIGHT,
+      			    sizeof(FONT_FORMAT_SECTION_NAMES_WEIGHT) - 1) == 0)
         {
           char *wt;
           wt = read_section_as_string (&section);
@@ -493,32 +546,42 @@ grub_font_load (const char *filename)
             font->weight = FONT_WEIGHT_BOLD;
           grub_free (wt);
         }
-      else if (grub_memcmp (section.name, section_names_max_char_width, 4) == 0)
+      else if (grub_memcmp (section.name,
+      	       FONT_FORMAT_SECTION_NAMES_MAX_CHAR_WIDTH,
+	       sizeof(FONT_FORMAT_SECTION_NAMES_MAX_CHAR_WIDTH) - 1) == 0)
         {
           if (read_section_as_short (&section, &font->max_char_width) != 0)
             goto fail;
         }
-      else if (grub_memcmp (section.name, section_names_max_char_height, 4) == 0)
+      else if (grub_memcmp (section.name,
+      	       FONT_FORMAT_SECTION_NAMES_MAX_CHAR_HEIGHT,
+	       sizeof(FONT_FORMAT_SECTION_NAMES_MAX_CHAR_HEIGHT) - 1) == 0)
         {
           if (read_section_as_short (&section, &font->max_char_height) != 0)
             goto fail;
         }
-      else if (grub_memcmp (section.name, section_names_ascent, 4) == 0)
+      else if (grub_memcmp (section.name,
+      	       FONT_FORMAT_SECTION_NAMES_ASCENT,
+	       sizeof(FONT_FORMAT_SECTION_NAMES_ASCENT) - 1) == 0)
         {
           if (read_section_as_short (&section, &font->ascent) != 0)
             goto fail;
         }
-      else if (grub_memcmp (section.name, section_names_descent, 4) == 0)
+      else if (grub_memcmp (section.name, FONT_FORMAT_SECTION_NAMES_DESCENT,
+      			    sizeof(FONT_FORMAT_SECTION_NAMES_DESCENT) - 1) == 0)
         {
           if (read_section_as_short (&section, &font->descent) != 0)
             goto fail;
         }
-      else if (grub_memcmp (section.name, section_names_char_index, 4) == 0)
+      else if (grub_memcmp (section.name,
+      			    FONT_FORMAT_SECTION_NAMES_CHAR_INDEX,
+			    sizeof(FONT_FORMAT_SECTION_NAMES_CHAR_INDEX) - 1) == 0)
         {
           if (load_font_index (file, section.length, font) != 0)
             goto fail;
         }
-      else if (grub_memcmp (section.name, section_names_data, 4) == 0)
+      else if (grub_memcmp (section.name, FONT_FORMAT_SECTION_NAMES_DATA,
+      			    sizeof(FONT_FORMAT_SECTION_NAMES_DATA) - 1) == 0)
         {
           /* When the DATA section marker is reached, we stop reading.  */
           break;
@@ -594,7 +657,7 @@ read_be_int16 (grub_file_t file, grub_int16_t * value)
 
 /* Return a pointer to the character index entry for the glyph corresponding to
    the codepoint CODE in the font FONT.  If not found, return zero.  */
-static struct char_index_entry *
+static inline struct char_index_entry *
 find_glyph (const grub_font_t font, grub_uint32_t code)
 {
   struct char_index_entry *table;
@@ -602,8 +665,17 @@ find_glyph (const grub_font_t font, grub_uint32_t code)
   grub_size_t hi;
   grub_size_t mid;
 
-  /* Do a binary search in `char_index', which is ordered by code point.  */
   table = font->char_index;
+
+  /* Use BMP index if possible.  */
+  if (code < 0x10000 && font->bmp_idx)
+    {
+      if (font->bmp_idx[code] == 0xffff)
+	return 0;
+      return &table[font->bmp_idx[code]];
+    }
+
+  /* Do a binary search in `char_index', which is ordered by code point.  */
   lo = 0;
   hi = font->num_chars - 1;
 
@@ -790,7 +862,7 @@ grub_font_get (const char *font_name)
     return &null_font;
 }
 
-/* Get the full name of the font.  For instance, "Helvetica Bold 12".  */
+/* Get the full name of the font.  */
 const char *
 grub_font_get_name (grub_font_t font)
 {
@@ -865,15 +937,18 @@ grub_font_get_string_width (grub_font_t font, const char *str)
 }
 
 /* Get the glyph for FONT corresponding to the Unicode code point CODE.
-   Returns a pointer to an glyph indicating there is no glyph available
+   Returns the ASCII glyph for the code if no other fonts are available. 
-   if CODE does not exist in the font.  The glyphs are cached once loaded.  */
+   The glyphs are cached once loaded.  */
 struct grub_font_glyph *
 grub_font_get_glyph (grub_font_t font, grub_uint32_t code)
 {
-  struct grub_font_glyph *glyph;
+  struct grub_font_glyph *glyph = 0;
-  glyph = grub_font_get_glyph_internal (font, code);
+  if (font)
+    glyph = grub_font_get_glyph_internal (font, code);
   if (glyph == 0)
-    glyph = unknown_glyph;
+    {
+      glyph = ascii_glyph_lookup (code);
+    }
   return glyph;
 }
 
@@ -968,8 +1043,8 @@ grub_font_get_glyph_with_fallback (grub_font_t font, grub_uint32_t code)
   if (best_glyph)
     return best_glyph;
   else
-    /* Glyph not available in any font.  Return unknown glyph.  */
+    /* Glyph not available in any font.  Return ASCII failback.  */
-    return unknown_glyph;
+    return ascii_glyph_lookup (code);
 }
 
 

fs/cpio.c

@@ -280,8 +280,10 @@ grub_cpio_open (grub_file_t file, const char *name)
 
       /* Compare NAME and FN by hand in order to cope with duplicate
 	 slashes.  */
-      i = 1;
+      i = 0;
       j = 0;
+      while (name[i] == '/')
+	i++;
       while (1)
 	{
 	  if (name[i] != fn[j])
@@ -290,13 +292,16 @@ grub_cpio_open (grub_file_t file, const char *name)
 	  if (name[i] == '\0')
 	    break;
 
-	  if (name[i] == '/' && name[i+1] == '/')
+	  while (name[i] == '/' && name[i+1] == '/')
 	    i++;
 
 	  i++;
 	  j++;
 	}
 
+      if (name[i] != fn[j])
+	goto no_match;
+
       file->data = data;
       file->size = data->size;
       grub_free (fn);

fs/ext2.c

@@ -436,7 +436,8 @@ grub_ext2_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
       grub_uint32_t indir[blksz / 4];
 
       if (grub_disk_read (data->disk,
-			  grub_le_to_cpu32 (inode->blocks.indir_block)
+			  ((grub_disk_addr_t)
+			   grub_le_to_cpu32 (inode->blocks.indir_block))
 			  << log2_blksz,
 			  0, blksz, indir))
 	return grub_errno;
@@ -452,13 +453,15 @@ grub_ext2_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
       grub_uint32_t indir[blksz / 4];
 
       if (grub_disk_read (data->disk,
-			  grub_le_to_cpu32 (inode->blocks.double_indir_block)
+			  ((grub_disk_addr_t)
+			   grub_le_to_cpu32 (inode->blocks.double_indir_block))
 			  << log2_blksz,
 			  0, blksz, indir))
 	return grub_errno;
 
       if (grub_disk_read (data->disk,
-			  grub_le_to_cpu32 (indir[rblock / perblock])
+			  ((grub_disk_addr_t)
+			   grub_le_to_cpu32 (indir[rblock / perblock]))
 			  << log2_blksz,
 			  0, blksz, indir))
 	return grub_errno;
@@ -875,12 +878,15 @@ grub_ext2_uuid (grub_device_t device, char **uuid)
   data = grub_ext2_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (40 + sizeof ('\0'));
+      *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
-      grub_sprintf (*uuid, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+			     grub_be_to_cpu16 (data->sblock.uuid[0]),
-		    grub_be_to_cpu16 (data->sblock.uuid[0]), grub_be_to_cpu16 (data->sblock.uuid[1]),
+			     grub_be_to_cpu16 (data->sblock.uuid[1]),
-		    grub_be_to_cpu16 (data->sblock.uuid[2]), grub_be_to_cpu16 (data->sblock.uuid[3]),
+			     grub_be_to_cpu16 (data->sblock.uuid[2]),
-		    grub_be_to_cpu16 (data->sblock.uuid[4]), grub_be_to_cpu16 (data->sblock.uuid[5]),
+			     grub_be_to_cpu16 (data->sblock.uuid[3]),
-		    grub_be_to_cpu16 (data->sblock.uuid[6]), grub_be_to_cpu16 (data->sblock.uuid[7]));
+			     grub_be_to_cpu16 (data->sblock.uuid[4]),
+			     grub_be_to_cpu16 (data->sblock.uuid[5]),
+			     grub_be_to_cpu16 (data->sblock.uuid[6]),
+			     grub_be_to_cpu16 (data->sblock.uuid[7]));
     }
   else
     *uuid = NULL;

fs/fat.c

@@ -592,6 +592,7 @@ grub_fat_iterate_dir (grub_disk_t disk, struct grub_fat_data *data,
     }
 
   grub_free (filename);
+  grub_free (unibuf);
 
   return grub_errno;
 }
@@ -833,9 +834,9 @@ grub_fat_uuid (grub_device_t device, char **uuid)
   data = grub_fat_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (sizeof ("xxxx-xxxx"));
+      *uuid = grub_xasprintf ("%04x-%04x",
-      grub_sprintf (*uuid, "%04x-%04x", (grub_uint16_t) (data->uuid >> 16),
+			     (grub_uint16_t) (data->uuid >> 16),
-		    (grub_uint16_t) data->uuid);
+			     (grub_uint16_t) data->uuid);
     }
   else
     *uuid = NULL;

fs/hfs.c

@@ -1082,10 +1082,9 @@ grub_hfs_uuid (grub_device_t device, char **uuid)
   data = grub_hfs_mount (device->disk);
   if (data && data->sblock.num_serial != 0)
     {
-      *uuid = grub_malloc (16 + sizeof ('\0'));
+      *uuid = grub_xasprintf ("%016llx",
-      grub_sprintf (*uuid, "%016llx",
+			     (unsigned long long)
-		    (unsigned long long)
+			     grub_be_to_cpu64 (data->sblock.num_serial));
-		    grub_be_to_cpu64 (data->sblock.num_serial));
     }
   else
     *uuid = NULL;

fs/hfsplus.c

@@ -995,10 +995,9 @@ grub_hfsplus_uuid (grub_device_t device, char **uuid)
   data = grub_hfsplus_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (16 + sizeof ('\0'));
+      *uuid = grub_xasprintf ("%016llx",
-      grub_sprintf (*uuid, "%016llx",
+			     (unsigned long long)
-		    (unsigned long long)
+			     grub_be_to_cpu64 (data->volheader.num_serial));
-		    grub_be_to_cpu64 (data->volheader.num_serial));
     }
   else
     *uuid = NULL;

fs/i386/pc/pxe.c

@@ -173,12 +173,15 @@ static struct grub_disk_dev grub_pxe_dev =
   };
 
 static grub_err_t
-grub_pxefs_dir (grub_device_t device __attribute__ ((unused)),
+grub_pxefs_dir (grub_device_t device,
 		const char *path  __attribute__ ((unused)),
 		int (*hook) (const char *filename,
 			     const struct grub_dirhook_info *info)
 		__attribute__ ((unused)))
 {
+  if (device->disk->dev->id != GRUB_DISK_DEVICE_PXE_ID)
+    return grub_error (GRUB_ERR_IO, "not a pxe disk");
+
   return GRUB_ERR_NONE;
 }
 
@@ -194,6 +197,9 @@ grub_pxefs_open (struct grub_file *file, const char *name)
   struct grub_pxe_disk_data *disk_data = file->device->disk->data;
   grub_file_t file_int, bufio;
 
+  if (file->device->disk->dev->id != GRUB_DISK_DEVICE_PXE_ID)
+    return grub_error (GRUB_ERR_IO, "not a pxe disk");
+
   if (curr_file != 0)
     {
       grub_pxe_call (GRUB_PXENV_TFTP_CLOSE, &c.c2);
@@ -356,7 +362,8 @@ set_mac_env (grub_uint8_t *mac_addr, grub_size_t mac_len)
 
   for (i = 0; i < mac_len; i++)
     {
-      grub_sprintf (ptr, "%02x:", mac_addr[i] & 0xff);
+      grub_snprintf (ptr, sizeof (buf) - (ptr - buf),
+		     "%02x:", mac_addr[i] & 0xff);
       ptr += (sizeof ("XX:") - 1);
     }
   if (mac_len)
@@ -483,8 +490,8 @@ set_ip_env (char *varname, grub_uint32_t ip)
 {
   char buf[sizeof ("XXX.XXX.XXX.XXX")];
 
-  grub_sprintf (buf, "%d.%d.%d.%d", (ip & 0xff),
+  grub_snprintf (buf, sizeof (buf), "%d.%d.%d.%d", (ip & 0xff),
-		(ip >> 8) & 0xff, (ip >> 16) & 0xff, (ip >> 24) & 0xff);
+		 (ip >> 8) & 0xff, (ip >> 16) & 0xff, (ip >> 24) & 0xff);
   grub_env_set (varname, buf);
 }
 
@@ -500,15 +507,13 @@ write_ip_env (grub_uint32_t *ip, const char *val)
     return 0;
 
   /* Normalize the IP.  */
-  buf = grub_malloc (sizeof ("XXX.XXX.XXX.XXX"));
+  buf = grub_xasprintf ("%d.%d.%d.%d", (newip & 0xff), (newip >> 8) & 0xff,
+		       (newip >> 16) & 0xff, (newip >> 24) & 0xff);
   if (!buf)
     return 0;
 
   *ip = newip;
 
-  grub_sprintf (buf, "%d.%d.%d.%d", (newip & 0xff), (newip >> 8) & 0xff,
-		(newip >> 16) & 0xff, (newip >> 24) & 0xff);
-
   return buf; 
 }
 
@@ -544,11 +549,10 @@ grub_env_write_pxe_blocksize (struct grub_env_var *var __attribute__ ((unused)),
   else if (size > GRUB_PXE_MAX_BLKSIZE)
     size = GRUB_PXE_MAX_BLKSIZE;
   
-  buf = grub_malloc (sizeof ("XXXXXX XXXXXX"));
+  buf = grub_xasprintf ("%d", size);
   if (!buf)
     return 0;
 
-  grub_sprintf (buf, "%d", size);
   grub_pxe_blksize = size;
   
   return buf;
@@ -562,25 +566,23 @@ GRUB_MOD_INIT(pxe)
     {
       char *buf;
 
-      buf = grub_malloc (sizeof ("XXXXXX XXXXXX"));
+      buf = grub_xasprintf ("%d", grub_pxe_blksize);
       if (buf)
-	{
+	grub_env_set ("pxe_blksize", buf);
-	  grub_sprintf (buf, "%d", grub_pxe_blksize);
+      grub_free (buf);
-	  grub_env_set ("net_pxe_blksize", buf);
-	}
 
       set_ip_env ("pxe_default_server", grub_pxe_default_server_ip);
       set_ip_env ("pxe_default_gateway", grub_pxe_default_gateway_ip);
       set_ip_env ("net_pxe_ip", grub_pxe_your_ip);
-      grub_register_variable_hook ("net_pxe_default_server", 0,
+      grub_register_variable_hook ("pxe_default_server", 0,
 				   grub_env_write_pxe_default_server);
-      grub_register_variable_hook ("net_pxe_default_gateway", 0,
+      grub_register_variable_hook ("pxe_default_gateway", 0,
 				   grub_env_write_pxe_default_gateway);
 
       /* XXX: Is it possible to change IP in PXE?  */
       grub_register_variable_hook ("net_pxe_ip", 0,
 				   grub_env_write_readonly);
-      grub_register_variable_hook ("net_pxe_blksize", 0,
+      grub_register_variable_hook ("pxe_blksize", 0,
 				   grub_env_write_pxe_blocksize);
       grub_disk_dev_register (&grub_pxe_dev);
       grub_fs_register (&grub_pxefs_fs);

fs/iso9660.c

@@ -136,7 +136,6 @@ struct grub_iso9660_data
   struct grub_iso9660_primary_voldesc voldesc;
   grub_disk_t disk;
   unsigned int first_sector;
-  unsigned int length;
   int rockridge;
   int susp_skip;
   int joliet;
@@ -630,12 +629,16 @@ grub_iso9660_iterate_dir (grub_fshelp_node_t dir,
 
         if (dir->data->joliet)
           {
-            char *oldname;
+            char *oldname, *semicolon;
 
             oldname = filename;
             filename = grub_iso9660_convert_string
                   ((grub_uint16_t *) oldname, dirent.namelen >> 1);
 
+	    semicolon = grub_strrchr (filename, ';');
+	    if (semicolon)
+	      *semicolon = '\0';
+
             if (filename_alloc)
               grub_free (oldname);
 
@@ -744,7 +747,6 @@ grub_iso9660_open (struct grub_file *file, const char *name)
     goto fail;
 
   data->first_sector = foundnode->blk;
-  data->length = foundnode->size;
 
   file->data = data;
   file->size = foundnode->size;
@@ -840,16 +842,23 @@ grub_iso9660_uuid (grub_device_t device, char **uuid)
 	}
       else
 	{
-	  *uuid = grub_malloc (sizeof ("YYYY-MM-DD-HH-mm-ss-hh"));
+	  *uuid = grub_xasprintf ("%c%c%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c",
-	  grub_sprintf (*uuid, "%c%c%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c",
+				 data->voldesc.modified.year[0],
-			data->voldesc.modified.year[0], data->voldesc.modified.year[1],
+				 data->voldesc.modified.year[1],
-			data->voldesc.modified.year[2], data->voldesc.modified.year[3],
+				 data->voldesc.modified.year[2],
-			data->voldesc.modified.month[0], data->voldesc.modified.month[1],
+				 data->voldesc.modified.year[3],
-			data->voldesc.modified.day[0], data->voldesc.modified.day[1],
+				 data->voldesc.modified.month[0],
-			data->voldesc.modified.hour[0], data->voldesc.modified.hour[1],
+				 data->voldesc.modified.month[1],
-			data->voldesc.modified.minute[0], data->voldesc.modified.minute[1],
+				 data->voldesc.modified.day[0],
-			data->voldesc.modified.second[0], data->voldesc.modified.second[1],
+				 data->voldesc.modified.day[1],
-			data->voldesc.modified.hundredth[0], data->voldesc.modified.hundredth[1]);
+				 data->voldesc.modified.hour[0],
+				 data->voldesc.modified.hour[1],
+				 data->voldesc.modified.minute[0],
+				 data->voldesc.modified.minute[1],
+				 data->voldesc.modified.second[0],
+				 data->voldesc.modified.second[1],
+				 data->voldesc.modified.hundredth[0],
+				 data->voldesc.modified.hundredth[1]);
 	}
     }
   else

fs/jfs.c

@@ -842,17 +842,16 @@ grub_jfs_uuid (grub_device_t device, char **uuid)
   data = grub_jfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (40 + sizeof ('\0'));
+      *uuid = grub_xasprintf ("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
-
+			     "%02x%02x%02x%02x%02x%02x",
-      grub_sprintf (*uuid, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+			     data->sblock.uuid[0], data->sblock.uuid[1],
-		    data->sblock.uuid[0], data->sblock.uuid[1],
+			     data->sblock.uuid[2], data->sblock.uuid[3],
-		    data->sblock.uuid[2], data->sblock.uuid[3],
+			     data->sblock.uuid[4], data->sblock.uuid[5],
-		    data->sblock.uuid[4], data->sblock.uuid[5],
+			     data->sblock.uuid[6], data->sblock.uuid[7],
-		    data->sblock.uuid[6], data->sblock.uuid[7],
+			     data->sblock.uuid[8], data->sblock.uuid[9],
-		    data->sblock.uuid[8], data->sblock.uuid[9],
+			     data->sblock.uuid[10], data->sblock.uuid[11],
-		    data->sblock.uuid[10], data->sblock.uuid[11],
+			     data->sblock.uuid[12], data->sblock.uuid[13],
-		    data->sblock.uuid[12], data->sblock.uuid[13],
+			     data->sblock.uuid[14], data->sblock.uuid[15]);
-		    data->sblock.uuid[14], data->sblock.uuid[15]);
     }
   else
     *uuid = NULL;

fs/ntfs.c

@@ -1072,8 +1072,7 @@ grub_ntfs_uuid (grub_device_t device, char **uuid)
   data = grub_ntfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (16 + sizeof ('\0'));
+      *uuid = grub_xasprintf ("%016llx", (unsigned long long) data->uuid);
-      grub_sprintf (*uuid, "%016llx", (unsigned long long) data->uuid);
     }
   else
     *uuid = NULL;

fs/reiserfs.c

@@ -1189,7 +1189,8 @@ grub_reiserfs_read (grub_file_t file, char *buf, grub_size_t len)
 		(unsigned long long) (current_position - initial_position),
 		(unsigned long) len);
   return current_position - initial_position;
-/*
+
+#if 0
   switch (found.type)
     {
       case GRUB_REISERFS_DIRECT:
@@ -1232,7 +1233,8 @@ grub_reiserfs_read (grub_file_t file, char *buf, grub_size_t len)
         goto fail;
     }
 
-  return read_length;*/
+  return read_length;
+#endif
 
  fail:
   grub_free (indirect_block_ptr);
@@ -1335,12 +1337,15 @@ grub_reiserfs_uuid (grub_device_t device, char **uuid)
   data = grub_reiserfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (sizeof ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"));
+      *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
-      grub_sprintf (*uuid, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+			     grub_be_to_cpu16 (data->superblock.uuid[0]),
-		    grub_be_to_cpu16 (data->superblock.uuid[0]), grub_be_to_cpu16 (data->superblock.uuid[1]),
+			     grub_be_to_cpu16 (data->superblock.uuid[1]),
-		    grub_be_to_cpu16 (data->superblock.uuid[2]), grub_be_to_cpu16 (data->superblock.uuid[3]),
+			     grub_be_to_cpu16 (data->superblock.uuid[2]),
-		    grub_be_to_cpu16 (data->superblock.uuid[4]), grub_be_to_cpu16 (data->superblock.uuid[5]),
+			     grub_be_to_cpu16 (data->superblock.uuid[3]),
-		    grub_be_to_cpu16 (data->superblock.uuid[6]), grub_be_to_cpu16 (data->superblock.uuid[7]));
+			     grub_be_to_cpu16 (data->superblock.uuid[4]),
+			     grub_be_to_cpu16 (data->superblock.uuid[5]),
+			     grub_be_to_cpu16 (data->superblock.uuid[6]),
+			     grub_be_to_cpu16 (data->superblock.uuid[7]));
     }
   else
     *uuid = NULL;

fs/ufs.c

@@ -732,12 +732,9 @@ grub_ufs_uuid (grub_device_t device, char **uuid)
 
   data = grub_ufs_mount (disk);
   if (data && (data->sblock.uuidhi != 0 || data->sblock.uuidlow != 0))
-    {
+    *uuid = grub_xasprintf ("%08x%08x",
-      *uuid = grub_malloc (16 + sizeof ('\0'));
+			   (unsigned) grub_le_to_cpu32 (data->sblock.uuidhi),
-      grub_sprintf (*uuid, "%08x%08x",
+			   (unsigned) grub_le_to_cpu32 (data->sblock.uuidlow));
-		    (unsigned) grub_le_to_cpu32 (data->sblock.uuidhi),
-		    (unsigned) grub_le_to_cpu32 (data->sblock.uuidlow));
-    }
   else
     *uuid = NULL;
 

fs/xfs.c

@@ -777,12 +777,15 @@ grub_xfs_uuid (grub_device_t device, char **uuid)
   data = grub_xfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (sizeof ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"));
+      *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
-      grub_sprintf (*uuid, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+			     grub_be_to_cpu16 (data->sblock.uuid[0]),
-		    grub_be_to_cpu16 (data->sblock.uuid[0]), grub_be_to_cpu16 (data->sblock.uuid[1]),
+			     grub_be_to_cpu16 (data->sblock.uuid[1]),
-		    grub_be_to_cpu16 (data->sblock.uuid[2]), grub_be_to_cpu16 (data->sblock.uuid[3]),
+			     grub_be_to_cpu16 (data->sblock.uuid[2]),
-		    grub_be_to_cpu16 (data->sblock.uuid[4]), grub_be_to_cpu16 (data->sblock.uuid[5]),
+			     grub_be_to_cpu16 (data->sblock.uuid[3]),
-		    grub_be_to_cpu16 (data->sblock.uuid[6]), grub_be_to_cpu16 (data->sblock.uuid[7]));
+			     grub_be_to_cpu16 (data->sblock.uuid[4]),
+			     grub_be_to_cpu16 (data->sblock.uuid[5]),
+			     grub_be_to_cpu16 (data->sblock.uuid[6]),
+			     grub_be_to_cpu16 (data->sblock.uuid[7]));
     }
   else
     *uuid = NULL;

genkernsyms.sh.in

@@ -14,7 +14,7 @@
 ### The configure script will replace these variables.
 
 : ${srcdir=@srcdir@}
-: ${CC=@CC@}
+: ${CC=@TARGET_CC@}
 
 u=
 grep "^#define HAVE_ASM_USCORE" config.h >/dev/null 2>&1 && u="_"

genmk.rb

@@ -68,7 +68,7 @@ MOSTLYCLEAN_IMAGE_TARGETS += mostlyclean-image-#{@name}.#{@rule_count}
 
 ifneq ($(TARGET_APPLE_CC),1)
 #{@name}: #{exe}
-	$(OBJCOPY) -O $(#{prefix}_FORMAT) --strip-unneeded -R .note -R .comment -R .note.gnu.build-id $< $@
+	$(OBJCOPY) -O $(#{prefix}_FORMAT) --strip-unneeded -R .note -R .comment -R .note.gnu.build-id -R .reginfo -R .rel.dyn $< $@
 else
 ifneq (#{exe},kernel.exec)
 #{@name}: #{exe} ./grub-macho2img
@@ -132,13 +132,11 @@ clean-module-#{@name}.#{@rule_count}:
 
 CLEAN_MODULE_TARGETS += clean-module-#{@name}.#{@rule_count}
 
-ifneq ($(#{prefix}_EXPORTS),no)
 clean-module-#{@name}-symbol.#{@rule_count}:
 	rm -f #{defsym}
 
 CLEAN_MODULE_TARGETS += clean-module-#{@name}-symbol.#{@rule_count}
 DEFSYMFILES += #{defsym}
-endif
 mostlyclean-module-#{@name}.#{@rule_count}:
 	rm -f #{deps_str}
 
@@ -170,7 +168,6 @@ endif
 #{mod_src}: $(builddir)/moddep.lst $(srcdir)/genmodsrc.sh
 	sh $(srcdir)/genmodsrc.sh '#{mod_name}' $< > $@ || (rm -f $@; exit 1)
 
-ifneq ($(#{prefix}_EXPORTS),no)
 ifneq ($(TARGET_APPLE_CC),1)
 #{defsym}: #{pre_obj}
 	$(NM) -g --defined-only -P -p $< | sed 's/^\\([^ ]*\\).*/\\1 #{mod_name}/' > $@
@@ -178,7 +175,6 @@ else
 #{defsym}: #{pre_obj}
 	$(NM) -g -P -p $< | grep -E '^[a-zA-Z0-9_]* [TDS]'  | sed 's/^\\([^ ]*\\).*/\\1 #{mod_name}/' > $@
 endif
-endif
 
 #{undsym}: #{pre_obj}
 	echo '#{mod_name}' > $@
@@ -205,7 +201,7 @@ endif
 -include #{dep}
 
 clean-module-#{extra_target}.#{@rule_count}:
-	rm -f #{command} #{fs} #{partmap} #{handler} #{parttool} #{video}
+	rm -f #{command} #{fs} #{partmap} #{handler} #{parttool} #{video} #{terminal}
 
 CLEAN_MODULE_TARGETS += clean-module-#{extra_target}.#{@rule_count}
 
@@ -331,8 +327,15 @@ class Program
     "CLEANFILES += #{@name} #{objs_str}
 MOSTLYCLEANFILES += #{deps_str}
 
+ifeq ($(#{prefix}_RELOCATABLE),yes)
+#{@name}: $(#{prefix}_DEPENDENCIES) #{objs_str}
+	$(TARGET_CC) -Wl,-r,-d -o $@ #{objs_str} $(TARGET_LDFLAGS) $(#{prefix}_LDFLAGS)
+	$(STRIP) --strip-unneeded -K start -R .note -R .comment $@
+else
 #{@name}: $(#{prefix}_DEPENDENCIES) #{objs_str}
 	$(TARGET_CC) -o $@ #{objs_str} $(TARGET_LDFLAGS) $(#{prefix}_LDFLAGS)
+	$(STRIP) -R .rel.dyn -R .reginfo -R .note -R .comment $@
+endif
 
 " + objs.collect_with_index do |obj, i|
       src = sources[i]
@@ -344,6 +347,7 @@ MOSTLYCLEANFILES += #{deps_str}
 
       "#{obj}: #{src} $(#{src}_DEPENDENCIES)
 	$(TARGET_CC) -I#{dir} -I$(srcdir)/#{dir} $(TARGET_CPPFLAGS) #{extra_flags} $(TARGET_#{flag}) $(#{prefix}_#{flag}) -MD -c -o $@ $<
+
 -include #{dep}
 
 "
@@ -370,8 +374,7 @@ class Script
     "CLEANFILES += #{@name}
 
 #{@name}: #{src} $(#{src}_DEPENDENCIES) config.status
-	./config.status --file=#{name}:#{src}
+	./config.status --file=-:#{src} | sed -e 's,@pkglib_DATA@,$(pkglib_DATA),g' > $@
-	sed -i -e 's,@pkglib_DATA@,$(pkglib_DATA),g' $@
 	chmod +x $@
 
 "

genmoddep.awk

@@ -29,7 +29,7 @@ FNR == 1 {
   if ($1 in symtab) {
     modtab[module] = modtab[module] " " symtab[$1];
   }
-  else {
+  else if ($1 != "__gnu_local_gp") {
     printf "%s in %s is not defined\n", $1, module >"/dev/stderr";
     error++;
     exit;

gensymlist.sh.in

@@ -14,7 +14,7 @@
 ### The configure script will replace these variables.
 
 : ${srcdir=@srcdir@}
-: ${CC=@CC@}
+: ${CC=@TARGET_CC@}
 
 
 cat <<EOF

gentrigtables.c

@@ -0,0 +1,48 @@
+/* Generate trigonometric function tables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008, 2009  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/>.
+ */
+
+#define _GNU_SOURCE 1
+
+#include <grub/trig.h>
+#include <math.h>
+#include <stdio.h>
+
+int
+main ()
+{
+  int i;
+
+  printf ("#include <grub/types.h>\n");
+
+#define TAB(op) \
+  printf ("grub_int16_t grub_trig_" #op "tab[] =\n{"); \
+  for (i = 0; i < GRUB_TRIG_ANGLE_MAX; i++) \
+    { \
+      double x = i * 2 * M_PI / GRUB_TRIG_ANGLE_MAX; \
+      if (i % 10 == 0) \
+	printf ("\n    "); \
+      printf ("%d,", (int) (round (op (x) * GRUB_TRIG_FRACTION_SCALE))); \
+    } \
+  printf ("\n};\n")
+
+  TAB(sin);
+  TAB(cos);
+
+  return 0;
+}

gettext/gettext.c

@@ -279,21 +279,19 @@ grub_gettext_init_ext (const char *lang)
 
   /* mo_file e.g.: /boot/grub/locale/ca.mo   */
 
-  mo_file =
+  mo_file = grub_xasprintf ("%s/%s.mo", locale_dir, lang);
-    grub_malloc (grub_strlen (locale_dir) + grub_strlen ("/") +
+  if (!mo_file)
-		 grub_strlen (lang) + grub_strlen (".mo") + 1);
+    return;
-
-  /* Warning: if changing some paths in the below line, change the grub_malloc
-     contents below.  */
-
-  grub_sprintf (mo_file, "%s/%s.mo", locale_dir, lang);
 
   fd_mo = grub_mofile_open (mo_file);
 
   /* Will try adding .gz as well.  */
   if (fd_mo == NULL)
     {
-      grub_sprintf (mo_file, "%s.gz", mo_file);
+      grub_free (mo_file);
+      mo_file = grub_xasprintf ("%s.gz", mo_file);
+      if (!mo_file)
+	return;
       fd_mo = grub_mofile_open (mo_file);
     }
 

gfxmenu/gfxmenu.c

@@ -0,0 +1,144 @@
+/* gfxmenu.c - Graphical menu interface controller. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/video.h>
+#include <grub/gfxterm.h>
+#include <grub/bitmap.h>
+#include <grub/bitmap_scale.h>
+#include <grub/term.h>
+#include <grub/env.h>
+#include <grub/normal.h>
+#include <grub/gfxwidgets.h>
+#include <grub/menu.h>
+#include <grub/menu_viewer.h>
+#include <grub/gfxmenu_model.h>
+#include <grub/gfxmenu_view.h>
+#include <grub/time.h>
+
+grub_gfxmenu_view_t cached_view;
+
+static void 
+grub_gfxmenu_viewer_fini (void *data __attribute__ ((unused)))
+{
+}
+
+/* FIXME: Previously 't' changed to text menu is it necessary?  */
+static grub_err_t
+grub_gfxmenu_try (int entry, grub_menu_t menu, int nested)
+{
+  grub_gfxmenu_view_t view = NULL;
+  const char *theme_path;
+  struct grub_menu_viewer *instance;
+  grub_err_t err;
+  struct grub_video_mode_info mode_info;
+
+  theme_path = grub_env_get ("theme");
+  if (! theme_path)
+    {
+      grub_error_push ();
+      grub_gfxterm_fullscreen ();
+      grub_error_pop ();
+      return grub_error (GRUB_ERR_FILE_NOT_FOUND, "no theme specified");
+    }
+
+  instance = grub_zalloc (sizeof (*instance));
+  if (!instance)
+    {
+      grub_error_push ();
+      grub_gfxterm_fullscreen ();
+      grub_error_pop ();
+      return grub_errno;
+    }
+
+  err = grub_video_get_info (&mode_info);
+  if (err)
+    {
+      grub_error_push ();
+      grub_gfxterm_fullscreen ();
+      grub_error_pop ();
+      return err;
+    }
+
+  if (!cached_view || grub_strcmp (cached_view->theme_path, theme_path) != 0
+      || cached_view->screen.width != mode_info.width
+      || cached_view->screen.height != mode_info.height)
+    {
+      grub_free (cached_view);
+      /* Create the view.  */
+      cached_view = grub_gfxmenu_view_new (theme_path, mode_info.width,
+					   mode_info.height);
+    }
+
+  if (! cached_view)
+    {
+      grub_free (instance);
+      grub_error_push ();
+      grub_gfxterm_fullscreen ();
+      grub_error_pop ();
+      return grub_errno;
+    }
+
+  view = cached_view;
+
+  view->double_repaint = (mode_info.mode_type
+			  & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED)
+    && !(mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP);
+  view->selected = entry;
+  view->menu = menu;
+  view->nested = nested;
+  view->first_timeout = -1;
+
+  grub_gfxmenu_view_draw (view);
+
+  instance->data = view;
+  instance->set_chosen_entry = grub_gfxmenu_set_chosen_entry;
+  instance->fini = grub_gfxmenu_viewer_fini;
+  instance->print_timeout = grub_gfxmenu_print_timeout;
+  instance->clear_timeout = grub_gfxmenu_clear_timeout;
+
+  grub_menu_register_viewer (instance);
+
+  return GRUB_ERR_NONE;
+}
+
+GRUB_MOD_INIT (gfxmenu)
+{
+  struct grub_term_output *term;
+
+  FOR_ACTIVE_TERM_OUTPUTS(term)
+    if (grub_gfxmenu_try_hook && grub_strcmp (term->name, "gfxterm") == 0)
+      {
+	grub_gfxterm_fullscreen ();
+	break;
+      }
+
+  grub_gfxmenu_try_hook = grub_gfxmenu_try;
+}
+
+GRUB_MOD_FINI (gfxmenu)
+{
+  grub_gfxmenu_view_destroy (cached_view);
+  grub_gfxmenu_try_hook = NULL;
+}

gfxmenu/gui_box.c

@@ -0,0 +1,412 @@
+/* gui_box.c - GUI container that stack components. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/gui_string_util.h>
+
+struct component_node
+{
+  grub_gui_component_t component;
+  struct component_node *next;
+  struct component_node *prev;
+};
+
+typedef struct grub_gui_box *grub_gui_box_t;
+
+typedef void (*layout_func_t) (grub_gui_box_t self, int modify_layout,
+                               unsigned *minimal_width,
+			       unsigned *minimal_height);
+
+struct grub_gui_box
+{
+  struct grub_gui_container container;
+
+  grub_gui_container_t parent;
+  grub_video_rect_t bounds;
+  char *id;
+
+  /* Doubly linked list of components with dummy head & tail nodes.  */
+  struct component_node chead;
+  struct component_node ctail;
+
+  /* The layout function: differs for vertical and horizontal boxes.  */
+  layout_func_t layout_func;
+};
+
+static void
+box_destroy (void *vself)
+{
+  grub_gui_box_t self = vself;
+  struct component_node *cur;
+  struct component_node *next;
+  for (cur = self->chead.next; cur != &self->ctail; cur = next)
+    {
+      /* Copy the 'next' pointer, since we need it for the next iteration,
+         and we're going to free the memory it is stored in.  */
+      next = cur->next;
+      /* Destroy the child component.  */
+      cur->component->ops->destroy (cur->component);
+      /* Free the linked list node.  */
+      grub_free (cur);
+    }
+  grub_free (self);
+}
+
+static const char *
+box_get_id (void *vself)
+{
+  grub_gui_box_t self = vself;
+  return self->id;
+}
+
+static int
+box_is_instance (void *vself __attribute__((unused)), const char *type)
+{
+  return (grub_strcmp (type, "component") == 0
+          || grub_strcmp (type, "container") == 0);
+}
+
+static void
+layout_horizontally (grub_gui_box_t self, int modify_layout,
+                     unsigned *min_width, unsigned *min_height)
+{
+  /* Start at the left (chead) and set the x coordinates as we go right.  */
+  /* All components have their width set to the box's width.  */
+
+  struct component_node *cur;
+  unsigned w = 0, mwfrac = 0, h = 0, x = 0;
+  grub_fixed_signed_t wfrac = 0;
+  int bogus_frac = 0;
+
+  for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
+    {
+      grub_gui_component_t c = cur->component;
+      unsigned mw = 0, mh = 0;
+
+      if (c->ops->get_minimal_size)
+	c->ops->get_minimal_size (c, &mw, &mh);
+
+      if (c->h > (signed) h)
+	h = c->h;
+      if (mh > h)
+	h = mh;
+      wfrac += c->wfrac;
+      w += c->w;
+      if (mw - c->w > 0)
+	mwfrac += mw - c->w;
+    }
+  if (wfrac > GRUB_FIXED_1 || (w > 0 && wfrac == GRUB_FIXED_1))
+    bogus_frac = 1;
+
+  if (min_width)
+    {
+      if (wfrac < GRUB_FIXED_1)
+	*min_width = grub_fixed_sfs_divide (w, GRUB_FIXED_1 - wfrac);
+      else
+	*min_width = w;
+      if (*min_width < w + mwfrac)
+	*min_width = w + mwfrac;
+    }
+  if (min_height)
+    *min_height = h;
+
+  if (!modify_layout)
+    return;
+
+  for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
+    {
+      grub_video_rect_t r;
+      grub_gui_component_t c = cur->component;
+      unsigned mw = 0, mh = 0;
+
+      r.x = x;
+      r.y = 0;
+      r.height = h;
+
+      if (c->ops->get_minimal_size)
+	c->ops->get_minimal_size (c, &mw, &mh);
+
+      r.width = c->w;
+      if (!bogus_frac)
+	r.width += grub_fixed_sfs_multiply (self->bounds.width, c->wfrac);
+
+      if (r.width < mw)
+	r.width = mw;
+
+      c->ops->set_bounds (c, &r);
+
+      x += r.width;
+    }
+}
+
+static void
+layout_vertically (grub_gui_box_t self, int modify_layout,
+                     unsigned *min_width, unsigned *min_height)
+{
+  /* Start at the top (chead) and set the y coordinates as we go rdown.  */
+  /* All components have their height set to the box's height.  */
+
+  struct component_node *cur;
+  unsigned h = 0, mhfrac = 0, w = 0, y = 0;
+  grub_fixed_signed_t hfrac = 0;
+  int bogus_frac = 0;
+
+  for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
+    {
+      grub_gui_component_t c = cur->component;
+      unsigned mw = 0, mh = 0;
+
+      if (c->ops->get_minimal_size)
+	c->ops->get_minimal_size (c, &mw, &mh);
+
+      if (c->w > (signed) w)
+	w = c->w;
+      if (mw > w)
+	w = mw;
+      hfrac += c->hfrac;
+      h += c->h;
+      if (mh - c->h > 0)
+	mhfrac += mh - c->h;
+    }
+  if (hfrac > GRUB_FIXED_1 || (h > 0 && hfrac == GRUB_FIXED_1))
+    bogus_frac = 1;
+
+  if (min_height)
+    {
+      if (hfrac < GRUB_FIXED_1)
+	*min_height = grub_fixed_sfs_divide (h, GRUB_FIXED_1 - hfrac);
+      else
+	*min_height = h;
+      if (*min_height < h + mhfrac)
+	*min_height = h + mhfrac;
+    }
+  if (min_width)
+    *min_width = w;
+
+  if (!modify_layout)
+    return;
+
+  for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
+    {
+      grub_video_rect_t r;
+      grub_gui_component_t c = cur->component;
+      unsigned mw = 0, mh = 0;
+
+      r.x = 0;
+      r.y = y;
+      r.width = w;
+
+      if (c->ops->get_minimal_size)
+	c->ops->get_minimal_size (c, &mw, &mh);
+
+      r.height = c->h;
+      if (!bogus_frac)
+	r.height += grub_fixed_sfs_multiply (self->bounds.height, c->hfrac);
+
+      if (r.height < mh)
+	r.height = mh;
+
+      c->ops->set_bounds (c, &r);
+
+      y += r.height;
+    }
+}
+
+static void
+box_paint (void *vself, const grub_video_rect_t *region)
+{
+  grub_gui_box_t self = vself;
+  struct component_node *cur;
+  grub_video_rect_t vpsave;
+
+  grub_gui_set_viewport (&self->bounds, &vpsave);
+  for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
+    {
+      grub_gui_component_t comp = cur->component;
+      comp->ops->paint (comp, region);
+    }
+  grub_gui_restore_viewport (&vpsave);
+}
+
+static void
+box_set_parent (void *vself, grub_gui_container_t parent)
+{
+  grub_gui_box_t self = vself;
+  self->parent = parent;
+}
+
+static grub_gui_container_t
+box_get_parent (void *vself)
+{
+  grub_gui_box_t self = vself;
+  return self->parent;
+}
+
+static void
+box_set_bounds (void *vself, const grub_video_rect_t *bounds)
+{
+  grub_gui_box_t self = vself;
+  self->bounds = *bounds;
+  self->layout_func (self, 1, 0, 0);   /* Relayout the children.  */
+}
+
+static void
+box_get_bounds (void *vself, grub_video_rect_t *bounds)
+{
+  grub_gui_box_t self = vself;
+  *bounds = self->bounds;
+}
+
+/* The box's preferred size is based on the preferred sizes
+   of its children.  */
+static void
+box_get_minimal_size (void *vself, unsigned *width, unsigned *height)
+{
+  grub_gui_box_t self = vself;
+  self->layout_func (self, 0, width, height);   /* Just calculate the size.  */
+}
+
+static grub_err_t
+box_set_property (void *vself, const char *name, const char *value)
+{
+  grub_gui_box_t self = vself;
+  if (grub_strcmp (name, "id") == 0)
+    {
+      grub_free (self->id);
+      if (value)
+        {
+          self->id = grub_strdup (value);
+          if (! self->id)
+            return grub_errno;
+        }
+      else
+        self->id = 0;
+    }
+
+  return grub_errno;
+}
+
+static void
+box_add (void *vself, grub_gui_component_t comp)
+{
+  grub_gui_box_t self = vself;
+  struct component_node *node;
+  node = grub_malloc (sizeof (*node));
+  if (! node)
+    return;   /* Note: probably should handle the error.  */
+  node->component = comp;
+  /* Insert the node before the tail.  */
+  node->prev = self->ctail.prev;
+  node->prev->next = node;
+  node->next = &self->ctail;
+  node->next->prev = node;
+
+  comp->ops->set_parent (comp, (grub_gui_container_t) self);
+  self->layout_func (self, 1, 0, 0);   /* Relayout the children.  */
+}
+
+static void
+box_remove (void *vself, grub_gui_component_t comp)
+{
+  grub_gui_box_t self = vself;
+  struct component_node *cur;
+  for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
+    {
+      if (cur->component == comp)
+        {
+          /* Unlink 'cur' from the list.  */
+          cur->prev->next = cur->next;
+          cur->next->prev = cur->prev;
+          /* Free the node's memory (but don't destroy the component).  */
+          grub_free (cur);
+          /* Must not loop again, since 'cur' would be dereferenced!  */
+          return;
+        }
+    }
+}
+
+static void
+box_iterate_children (void *vself,
+                      grub_gui_component_callback cb, void *userdata)
+{
+  grub_gui_box_t self = vself;
+  struct component_node *cur;
+  for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
+    cb (cur->component, userdata);
+}
+
+static struct grub_gui_component_ops box_comp_ops =
+  {
+    .destroy = box_destroy,
+    .get_id = box_get_id,
+    .is_instance = box_is_instance,
+    .paint = box_paint,
+    .set_parent = box_set_parent,
+    .get_parent = box_get_parent,
+    .set_bounds = box_set_bounds,
+    .get_bounds = box_get_bounds,
+    .get_minimal_size = box_get_minimal_size,
+    .set_property = box_set_property
+  };
+
+static struct grub_gui_container_ops box_ops =
+{
+  .add = box_add,
+  .remove = box_remove,
+  .iterate_children = box_iterate_children
+};
+
+/* Box constructor.  Specify the appropriate layout function to create
+   a horizontal or vertical stacking box.  */
+static grub_gui_box_t
+box_new (layout_func_t layout_func)
+{
+  grub_gui_box_t box;
+  box = grub_zalloc (sizeof (*box));
+  if (! box)
+    return 0;
+  box->container.ops = &box_ops;
+  box->container.component.ops = &box_comp_ops;
+  box->chead.next = &box->ctail;
+  box->ctail.prev = &box->chead;
+  box->layout_func = layout_func;
+  return box;
+}
+
+/* Create a new container that stacks its child components horizontally,
+   from left to right.  Each child get a width corresponding to its
+   preferred width.  The height of each child is set the maximum of the
+   preferred heights of all children.  */
+grub_gui_container_t
+grub_gui_hbox_new (void)
+{
+  return (grub_gui_container_t) box_new (layout_horizontally);
+}
+
+/* Create a new container that stacks its child components verticallyj,
+   from top to bottom.  Each child get a height corresponding to its
+   preferred height.  The width of each child is set the maximum of the
+   preferred widths of all children.  */
+grub_gui_container_t
+grub_gui_vbox_new (void)
+{
+  return (grub_gui_container_t) box_new (layout_vertically);
+}

gfxmenu/gui_canvas.c

@@ -0,0 +1,267 @@
+/* gui_canvas.c - GUI container allowing manually placed components. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/gui_string_util.h>
+
+/* TODO Add layering so that components can be properly overlaid. */
+
+struct component_node
+{
+  grub_gui_component_t component;
+  struct component_node *next;
+};
+
+struct grub_gui_canvas
+{
+  struct grub_gui_container container;
+
+  grub_gui_container_t parent;
+  grub_video_rect_t bounds;
+  char *id;
+  /* Component list (dummy head node).  */
+  struct component_node components;
+};
+
+typedef struct grub_gui_canvas *grub_gui_canvas_t;
+
+static void
+canvas_destroy (void *vself)
+{
+  grub_gui_canvas_t self = vself;
+  struct component_node *cur;
+  struct component_node *next;
+  for (cur = self->components.next; cur; cur = next)
+    {
+      /* Copy the 'next' pointer, since we need it for the next iteration,
+         and we're going to free the memory it is stored in.  */
+      next = cur->next;
+      /* Destroy the child component.  */
+      cur->component->ops->destroy (cur->component);
+      /* Free the linked list node.  */
+      grub_free (cur);
+    }
+  grub_free (self);
+}
+
+static const char *
+canvas_get_id (void *vself)
+{
+  grub_gui_canvas_t self = vself;
+  return self->id;
+}
+
+static int
+canvas_is_instance (void *vself __attribute__((unused)), const char *type)
+{
+  return (grub_strcmp (type, "component") == 0
+          || grub_strcmp (type, "container") == 0);
+}
+
+static void
+canvas_paint (void *vself, const grub_video_rect_t *region)
+{
+  grub_gui_canvas_t self = vself;
+  struct component_node *cur;
+  grub_video_rect_t vpsave;
+
+  grub_gui_set_viewport (&self->bounds, &vpsave);
+  for (cur = self->components.next; cur; cur = cur->next)
+    {
+      grub_video_rect_t r;
+      grub_gui_component_t comp;
+      signed x, y, w, h;
+
+      comp = cur->component;
+
+      w = grub_fixed_sfs_multiply (self->bounds.width, comp->wfrac) + comp->w;
+      h = grub_fixed_sfs_multiply (self->bounds.height, comp->hfrac) + comp->h;
+      x = grub_fixed_sfs_multiply (self->bounds.width, comp->xfrac) + comp->x;
+      y = grub_fixed_sfs_multiply (self->bounds.height, comp->yfrac) + comp->y;
+
+      if (comp->ops->get_minimal_size)
+	{
+	  unsigned mw;
+	  unsigned mh;
+	  comp->ops->get_minimal_size (comp, &mw, &mh);
+	  if (w < (signed) mw)
+	    w = mw;
+	  if (h < (signed) mh)
+	    h = mh;
+	}
+
+      /* Sanity checks.  */
+      if (w <= 0)
+	w = 32;
+      if (h <= 0)
+	h = 32;
+
+      if (x >= (signed) self->bounds.width)
+	x = self->bounds.width - 32;
+      if (y >= (signed) self->bounds.height)
+	y = self->bounds.height - 32;
+
+      if (x < 0)
+	x = 0;
+      if (y < 0)
+	y = 0;
+
+      if (x + w >= (signed) self->bounds.width)
+	w = self->bounds.width - x;
+      if (y + h >= (signed) self->bounds.height)
+	h = self->bounds.height - y;
+
+      r.x = x;
+      r.y = y;
+      r.width = w;
+      r.height = h;
+      comp->ops->set_bounds (comp, &r);
+
+      /* Paint the child.  */
+      if (grub_video_have_common_points (region, &r))
+	comp->ops->paint (comp, region);
+    }
+  grub_gui_restore_viewport (&vpsave);
+}
+
+static void
+canvas_set_parent (void *vself, grub_gui_container_t parent)
+{
+  grub_gui_canvas_t self = vself;
+  self->parent = parent;
+}
+
+static grub_gui_container_t
+canvas_get_parent (void *vself)
+{
+  grub_gui_canvas_t self = vself;
+  return self->parent;
+}
+
+static void
+canvas_set_bounds (void *vself, const grub_video_rect_t *bounds)
+{
+  grub_gui_canvas_t self = vself;
+  self->bounds = *bounds;
+}
+
+static void
+canvas_get_bounds (void *vself, grub_video_rect_t *bounds)
+{
+  grub_gui_canvas_t self = vself;
+  *bounds = self->bounds;
+}
+
+static grub_err_t
+canvas_set_property (void *vself, const char *name, const char *value)
+{
+  grub_gui_canvas_t self = vself;
+  if (grub_strcmp (name, "id") == 0)
+    {
+      grub_free (self->id);
+      if (value)
+        {
+          self->id = grub_strdup (value);
+          if (! self->id)
+            return grub_errno;
+        }
+      else
+        self->id = 0;
+    }
+  return grub_errno;
+}
+
+static void
+canvas_add (void *vself, grub_gui_component_t comp)
+{
+  grub_gui_canvas_t self = vself;
+  struct component_node *node;
+  node = grub_malloc (sizeof (*node));
+  if (! node)
+    return;   /* Note: probably should handle the error.  */
+  node->component = comp;
+  node->next = self->components.next;
+  self->components.next = node;
+  comp->ops->set_parent (comp, (grub_gui_container_t) self);
+}
+
+static void
+canvas_remove (void *vself, grub_gui_component_t comp)
+{
+  grub_gui_canvas_t self = vself;
+  struct component_node *cur;
+  struct component_node *prev;
+  prev = &self->components;
+  for (cur = self->components.next; cur; prev = cur, cur = cur->next)
+    {
+      if (cur->component == comp)
+        {
+          /* Unlink 'cur' from the list.  */
+          prev->next = cur->next;
+          /* Free the node's memory (but don't destroy the component).  */
+          grub_free (cur);
+          /* Must not loop again, since 'cur' would be dereferenced!  */
+          return;
+        }
+    }
+}
+
+static void
+canvas_iterate_children (void *vself,
+                         grub_gui_component_callback cb, void *userdata)
+{
+  grub_gui_canvas_t self = vself;
+  struct component_node *cur;
+  for (cur = self->components.next; cur; cur = cur->next)
+    cb (cur->component, userdata);
+}
+
+static struct grub_gui_component_ops canvas_comp_ops =
+{
+  .destroy = canvas_destroy,
+  .get_id = canvas_get_id,
+  .is_instance = canvas_is_instance,
+  .paint = canvas_paint,
+  .set_parent = canvas_set_parent,
+  .get_parent = canvas_get_parent,
+  .set_bounds = canvas_set_bounds,
+  .get_bounds = canvas_get_bounds,
+  .set_property = canvas_set_property
+};
+
+static struct grub_gui_container_ops canvas_ops =
+{
+  .add = canvas_add,
+  .remove = canvas_remove,
+  .iterate_children = canvas_iterate_children
+};
+
+grub_gui_container_t
+grub_gui_canvas_new (void)
+{
+  grub_gui_canvas_t canvas;
+  canvas = grub_zalloc (sizeof (*canvas));
+  if (! canvas)
+    return 0;
+  canvas->container.ops = &canvas_ops;
+  canvas->container.component.ops = &canvas_comp_ops;
+  return (grub_gui_container_t) canvas;
+}

gfxmenu/gui_circular_progress.c

@@ -0,0 +1,302 @@
+/* gui_circular_process.c - GUI circular progress indicator component.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/font.h>
+#include <grub/gui_string_util.h>
+#include <grub/gfxmenu_view.h>
+#include <grub/gfxwidgets.h>
+#include <grub/trig.h>
+
+struct grub_gui_circular_progress
+{
+  struct grub_gui_progress progress;
+
+  grub_gui_container_t parent;
+  grub_video_rect_t bounds;
+  char *id;
+  int visible;
+  int start;
+  int end;
+  int value;
+  int num_ticks;
+  int start_angle;
+  int ticks_disappear;
+  char *theme_dir;
+  int need_to_load_pixmaps;
+  char *center_file;
+  char *tick_file;
+  struct grub_video_bitmap *center_bitmap;
+  struct grub_video_bitmap *tick_bitmap;
+};
+
+typedef struct grub_gui_circular_progress *circular_progress_t;
+
+static void
+circprog_destroy (void *vself)
+{
+  circular_progress_t self = vself;
+  grub_free (self);
+}
+
+static const char *
+circprog_get_id (void *vself)
+{
+  circular_progress_t self = vself;
+  return self->id;
+}
+
+static int
+circprog_is_instance (void *vself __attribute__((unused)), const char *type)
+{
+  return grub_strcmp (type, "component") == 0;
+}
+
+static struct grub_video_bitmap *
+load_bitmap (const char *dir, const char *file)
+{
+  struct grub_video_bitmap *bitmap;
+  char *abspath;
+
+  /* Check arguments.  */
+  if (! dir || ! file)
+    return 0;
+
+  /* Resolve to an absolute path.  */
+  abspath = grub_resolve_relative_path (dir, file);
+  if (! abspath)
+    return 0;
+
+  /* Load the image.  */
+  grub_errno = GRUB_ERR_NONE;
+  grub_video_bitmap_load (&bitmap, abspath);
+  grub_errno = GRUB_ERR_NONE;
+
+  grub_free (abspath);
+  return bitmap;
+}
+
+static int
+check_pixmaps (circular_progress_t self)
+{
+  if (self->need_to_load_pixmaps)
+    {
+      if (self->center_bitmap)
+        grub_video_bitmap_destroy (self->center_bitmap);
+      self->center_bitmap = load_bitmap (self->theme_dir, self->center_file);
+      self->tick_bitmap = load_bitmap (self->theme_dir, self->tick_file);
+      self->need_to_load_pixmaps = 0;
+    }
+
+  return (self->center_bitmap != 0 && self->tick_bitmap != 0);
+}
+
+static void
+circprog_paint (void *vself, const grub_video_rect_t *region)
+{
+  circular_progress_t self = vself;
+
+  if (! self->visible)
+    return;
+
+  if (!grub_video_have_common_points (region, &self->bounds))
+    return;
+
+  if (! check_pixmaps (self))
+    return;
+
+  grub_video_rect_t vpsave;
+  grub_gui_set_viewport (&self->bounds, &vpsave);
+
+  int width = self->bounds.width;
+  int height = self->bounds.height;
+  int center_width = grub_video_bitmap_get_width (self->center_bitmap);
+  int center_height = grub_video_bitmap_get_height (self->center_bitmap);
+  int tick_width = grub_video_bitmap_get_width (self->tick_bitmap);
+  int tick_height = grub_video_bitmap_get_height (self->tick_bitmap);
+  grub_video_blit_bitmap (self->center_bitmap, GRUB_VIDEO_BLIT_BLEND,
+                          (width - center_width) / 2,
+                          (height - center_height) / 2, 0, 0,
+                          center_width, center_height);
+
+  int radius = width / 2 - tick_width / 2 - 1;
+  int nticks;
+  int tick_begin;
+  int tick_end;
+  if (self->end == self->start)
+    nticks = 0;
+  else
+    nticks = (self->num_ticks
+	      * (self->value - self->start)
+	      / (self->end - self->start));
+  /* Do ticks appear or disappear as the value approached the end?  */
+  if (self->ticks_disappear)
+    {
+      tick_begin = nticks;
+      tick_end = self->num_ticks - 1;
+    }
+  else
+    {
+      tick_begin = 0;
+      tick_end = nticks - 1;
+    }
+
+  int i;
+  for (i = tick_begin; i < tick_end; i++)
+    {
+       int x;
+       int y;
+       int angle;
+
+       /* Calculate the location of the tick.  */
+       angle = self->start_angle + i * GRUB_TRIG_ANGLE_MAX / self->num_ticks;
+       x = width / 2 + (grub_cos (angle) * radius / GRUB_TRIG_FRACTION_SCALE);
+       y = height / 2 + (grub_sin (angle) * radius / GRUB_TRIG_FRACTION_SCALE);
+
+       /* Adjust (x,y) so the tick is centered.  */
+       x -= tick_width / 2;
+       y -= tick_height / 2;
+
+       /* Draw the tick.  */
+       grub_video_blit_bitmap (self->tick_bitmap, GRUB_VIDEO_BLIT_BLEND,
+                               x, y, 0, 0, tick_width, tick_height);
+    }
+
+  grub_gui_restore_viewport (&vpsave);
+}
+
+static void
+circprog_set_parent (void *vself, grub_gui_container_t parent)
+{
+  circular_progress_t self = vself;
+  self->parent = parent;
+}
+
+static grub_gui_container_t
+circprog_get_parent (void *vself)
+{
+  circular_progress_t self = vself;
+  return self->parent;
+}
+
+static void
+circprog_set_bounds (void *vself, const grub_video_rect_t *bounds)
+{
+  circular_progress_t self = vself;
+  self->bounds = *bounds;
+}
+
+static void
+circprog_get_bounds (void *vself, grub_video_rect_t *bounds)
+{
+  circular_progress_t self = vself;
+  *bounds = self->bounds;
+}
+
+static grub_err_t
+circprog_set_property (void *vself, const char *name, const char *value)
+{
+  circular_progress_t self = vself;
+  if (grub_strcmp (name, "num_ticks") == 0)
+    {
+      self->num_ticks = grub_strtol (value, 0, 10);
+    }
+  else if (grub_strcmp (name, "start_angle") == 0)
+    {
+      self->start_angle = grub_strtol (value, 0, 10);
+    }
+  else if (grub_strcmp (name, "ticks_disappear") == 0)
+    {
+      self->ticks_disappear = grub_strcmp (value, "false") != 0;
+    }
+  else if (grub_strcmp (name, "center_bitmap") == 0)
+    {
+      self->need_to_load_pixmaps = 1;
+      grub_free (self->center_file);
+      self->center_file = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "tick_bitmap") == 0)
+    {
+      self->need_to_load_pixmaps = 1;
+      grub_free (self->tick_file);
+      self->tick_file = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "theme_dir") == 0)
+    {
+      self->need_to_load_pixmaps = 1;
+      grub_free (self->theme_dir);
+      self->theme_dir = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "id") == 0)
+    {
+      grub_free (self->id);
+      if (value)
+        self->id = grub_strdup (value);
+      else
+        self->id = 0;
+    }
+  return grub_errno;
+}
+
+static void
+circprog_set_state (void *vself, int visible, int start,
+		    int current, int end)
+{
+  circular_progress_t self = vself;  
+  self->visible = visible;
+  self->start = start;
+  self->value = current;
+  self->end = end;
+}
+
+static struct grub_gui_component_ops circprog_ops =
+{
+  .destroy = circprog_destroy,
+  .get_id = circprog_get_id,
+  .is_instance = circprog_is_instance,
+  .paint = circprog_paint,
+  .set_parent = circprog_set_parent,
+  .get_parent = circprog_get_parent,
+  .set_bounds = circprog_set_bounds,
+  .get_bounds = circprog_get_bounds,
+  .set_property = circprog_set_property
+};
+
+static struct grub_gui_progress_ops circprog_prog_ops =
+  {
+    .set_state = circprog_set_state
+  };
+
+grub_gui_component_t
+grub_gui_circular_progress_new (void)
+{
+  circular_progress_t self;
+  self = grub_zalloc (sizeof (*self));
+  if (! self)
+    return 0;
+  self->progress.ops = &circprog_prog_ops;
+  self->progress.component.ops = &circprog_ops;
+  self->visible = 1;
+  self->num_ticks = 64;
+  self->start_angle = -64;
+
+  return (grub_gui_component_t) self;
+}

gfxmenu/gui_image.c

@@ -0,0 +1,269 @@
+/* gui_image.c - GUI component to display an image.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/gui_string_util.h>
+#include <grub/bitmap.h>
+#include <grub/bitmap_scale.h>
+
+struct grub_gui_image
+{
+  struct grub_gui_component component;
+
+  grub_gui_container_t parent;
+  grub_video_rect_t bounds;
+  char *id;
+  char *theme_dir;
+  struct grub_video_bitmap *raw_bitmap;
+  struct grub_video_bitmap *bitmap;
+};
+
+typedef struct grub_gui_image *grub_gui_image_t;
+
+static void
+image_destroy (void *vself)
+{
+  grub_gui_image_t self = vself;
+
+  /* Free the scaled bitmap, unless it's a reference to the raw bitmap.  */
+  if (self->bitmap && (self->bitmap != self->raw_bitmap))
+    grub_video_bitmap_destroy (self->bitmap);
+  if (self->raw_bitmap)
+    grub_video_bitmap_destroy (self->raw_bitmap);
+
+  grub_free (self);
+}
+
+static const char *
+image_get_id (void *vself)
+{
+  grub_gui_image_t self = vself;
+  return self->id;
+}
+
+static int
+image_is_instance (void *vself __attribute__((unused)), const char *type)
+{
+  return grub_strcmp (type, "component") == 0;
+}
+
+static void
+image_paint (void *vself, const grub_video_rect_t *region)
+{
+  grub_gui_image_t self = vself;
+  grub_video_rect_t vpsave;
+
+  if (! self->bitmap)
+    return;
+  if (!grub_video_have_common_points (region, &self->bounds))
+    return;
+
+  grub_gui_set_viewport (&self->bounds, &vpsave);
+  grub_video_blit_bitmap (self->bitmap, GRUB_VIDEO_BLIT_BLEND,
+                          0, 0, 0, 0,
+                          grub_video_bitmap_get_width (self->bitmap),
+                          grub_video_bitmap_get_height (self->bitmap));
+  grub_gui_restore_viewport (&vpsave);
+}
+
+static void
+image_set_parent (void *vself, grub_gui_container_t parent)
+{
+  grub_gui_image_t self = vself;
+  self->parent = parent;
+}
+
+static grub_gui_container_t
+image_get_parent (void *vself)
+{
+  grub_gui_image_t self = vself;
+  return self->parent;
+}
+
+static grub_err_t
+rescale_image (grub_gui_image_t self)
+{
+  if (! self->raw_bitmap)
+    {
+      if (self->bitmap)
+        {
+          grub_video_bitmap_destroy (self->bitmap);
+          self->bitmap = 0;
+        }
+      return grub_errno;
+    }
+
+  unsigned width = self->bounds.width;
+  unsigned height = self->bounds.height;
+
+  if (self->bitmap
+      && (grub_video_bitmap_get_width (self->bitmap) == width)
+      && (grub_video_bitmap_get_height (self->bitmap) == height))
+    {
+      /* Nothing to do; already the right size.  */
+      return grub_errno;
+    }
+
+  /* Free any old scaled bitmap,
+     *unless* it's a reference to the raw bitmap.  */
+  if (self->bitmap && (self->bitmap != self->raw_bitmap))
+    grub_video_bitmap_destroy (self->bitmap);
+
+  self->bitmap = 0;
+
+  /* Create a scaled bitmap, unless the requested size is the same
+     as the raw size -- in that case a reference is made.  */
+  if (grub_video_bitmap_get_width (self->raw_bitmap) == width
+      && grub_video_bitmap_get_height (self->raw_bitmap) == height)
+    {
+      self->bitmap = self->raw_bitmap;
+      return grub_errno;
+    }
+
+  /* Don't scale to an invalid size.  */
+  if (width == 0 || height == 0)
+    return grub_errno;
+
+  /* Create the scaled bitmap.  */
+  grub_video_bitmap_create_scaled (&self->bitmap,
+                                   width,
+                                   height,
+                                   self->raw_bitmap,
+                                   GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST);
+  if (grub_errno != GRUB_ERR_NONE)
+    {
+      grub_error_push ();
+      grub_error (grub_errno, "failed to scale bitmap for image component");
+    }
+  return grub_errno;
+}
+
+static void
+image_set_bounds (void *vself, const grub_video_rect_t *bounds)
+{
+  grub_gui_image_t self = vself;
+  self->bounds = *bounds;
+  rescale_image (self);
+}
+
+static void
+image_get_bounds (void *vself, grub_video_rect_t *bounds)
+{
+  grub_gui_image_t self = vself;
+  *bounds = self->bounds;
+}
+
+/* FIXME: inform rendering system it's not forced minimum.  */
+static void
+image_get_minimal_size (void *vself, unsigned *width, unsigned *height)
+{
+  grub_gui_image_t self = vself;
+
+  if (self->raw_bitmap)
+    {
+      *width = grub_video_bitmap_get_width (self->raw_bitmap);
+      *height = grub_video_bitmap_get_height (self->raw_bitmap);
+    }
+  else
+    {
+      *width = 0;
+      *height = 0;
+    }
+}
+
+static grub_err_t
+load_image (grub_gui_image_t self, const char *path)
+{
+  struct grub_video_bitmap *bitmap;
+  if (grub_video_bitmap_load (&bitmap, path) != GRUB_ERR_NONE)
+    return grub_errno;
+
+  if (self->bitmap && (self->bitmap != self->raw_bitmap))
+    grub_video_bitmap_destroy (self->bitmap);
+  if (self->raw_bitmap)
+    grub_video_bitmap_destroy (self->raw_bitmap);
+
+  self->raw_bitmap = bitmap;
+  return rescale_image (self);
+}
+
+static grub_err_t
+image_set_property (void *vself, const char *name, const char *value)
+{
+  grub_gui_image_t self = vself;
+  if (grub_strcmp (name, "theme_dir") == 0)
+    {
+      grub_free (self->theme_dir);
+      self->theme_dir = grub_strdup (value);
+    }
+  else if (grub_strcmp (name, "file") == 0)
+    {
+      char *absvalue;
+      grub_err_t err;
+
+      /* Resolve to an absolute path.  */
+      if (! self->theme_dir)
+	return grub_error (GRUB_ERR_BAD_ARGUMENT, "unspecified theme_dir");
+      absvalue = grub_resolve_relative_path (self->theme_dir, value);
+      if (! absvalue)
+	return grub_errno;
+
+      err = load_image (self, absvalue);
+      grub_free (absvalue);
+
+      return err;
+    }
+  else if (grub_strcmp (name, "id") == 0)
+    {
+      grub_free (self->id);
+      if (value)
+        self->id = grub_strdup (value);
+      else
+        self->id = 0;
+    }
+  return grub_errno;
+}
+
+static struct grub_gui_component_ops image_ops =
+{
+  .destroy = image_destroy,
+  .get_id = image_get_id,
+  .is_instance = image_is_instance,
+  .paint = image_paint,
+  .set_parent = image_set_parent,
+  .get_parent = image_get_parent,
+  .set_bounds = image_set_bounds,
+  .get_bounds = image_get_bounds,
+  .get_minimal_size = image_get_minimal_size,
+  .set_property = image_set_property
+};
+
+grub_gui_component_t
+grub_gui_image_new (void)
+{
+  grub_gui_image_t image;
+  image = grub_zalloc (sizeof (*image));
+  if (! image)
+    return 0;
+  image->component.ops = &image_ops;
+  return (grub_gui_component_t) image;
+}
+

gfxmenu/gui_label.c

@@ -0,0 +1,226 @@
+/* gui_label.c - GUI component to display a line of text.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/font.h>
+#include <grub/gui_string_util.h>
+
+static const char *align_options[] =
+{
+  "left",
+  "center",
+  "right",
+  0
+};
+
+enum align_mode {
+  align_left,
+  align_center,
+  align_right
+};
+
+struct grub_gui_label
+{
+  struct grub_gui_component comp;
+
+  grub_gui_container_t parent;
+  grub_video_rect_t bounds;
+  char *id;
+  int visible;
+  char *text;
+  grub_font_t font;
+  grub_gui_color_t color;
+  enum align_mode align;
+};
+
+typedef struct grub_gui_label *grub_gui_label_t;
+
+static void
+label_destroy (void *vself)
+{
+  grub_gui_label_t self = vself;
+  grub_free (self->text);
+  grub_free (self);
+}
+
+static const char *
+label_get_id (void *vself)
+{
+  grub_gui_label_t self = vself;
+  return self->id;
+}
+
+static int
+label_is_instance (void *vself __attribute__((unused)), const char *type)
+{
+  return grub_strcmp (type, "component") == 0;
+}
+
+static void
+label_paint (void *vself, const grub_video_rect_t *region)
+{
+  grub_gui_label_t self = vself;
+
+  if (! self->visible)
+    return;
+
+  if (!grub_video_have_common_points (region, &self->bounds))
+    return;
+
+  /* Calculate the starting x coordinate.  */
+  int left_x;
+  if (self->align == align_left)
+    left_x = 0;
+  else if (self->align == align_center)
+    left_x = ((self->bounds.width
+               - grub_font_get_string_width (self->font, self->text))
+             ) / 2;
+  else if (self->align == align_right)
+    left_x = (self->bounds.width
+              - grub_font_get_string_width (self->font, self->text));
+  else
+    return;   /* Invalid alignment.  */
+
+  grub_video_rect_t vpsave;
+  grub_gui_set_viewport (&self->bounds, &vpsave);
+  grub_font_draw_string (self->text,
+                         self->font,
+                         grub_gui_map_color (self->color),
+                         left_x,
+                         grub_font_get_ascent (self->font));
+  grub_gui_restore_viewport (&vpsave);
+}
+
+static void
+label_set_parent (void *vself, grub_gui_container_t parent)
+{
+  grub_gui_label_t self = vself;
+  self->parent = parent;
+}
+
+static grub_gui_container_t
+label_get_parent (void *vself)
+{
+  grub_gui_label_t self = vself;
+  return self->parent;
+}
+
+static void
+label_set_bounds (void *vself, const grub_video_rect_t *bounds)
+{
+  grub_gui_label_t self = vself;
+  self->bounds = *bounds;
+}
+
+static void
+label_get_bounds (void *vself, grub_video_rect_t *bounds)
+{
+  grub_gui_label_t self = vself;
+  *bounds = self->bounds;
+}
+
+static void
+label_get_minimal_size (void *vself, unsigned *width, unsigned *height)
+{
+  grub_gui_label_t self = vself;
+  *width = grub_font_get_string_width (self->font, self->text);
+  *height = (grub_font_get_ascent (self->font)
+             + grub_font_get_descent (self->font));
+}
+
+static grub_err_t
+label_set_property (void *vself, const char *name, const char *value)
+{
+  grub_gui_label_t self = vself;
+  if (grub_strcmp (name, "text") == 0)
+    {
+      grub_free (self->text);
+      if (! value)
+        value = "";
+      self->text = grub_strdup (value);
+    }
+  else if (grub_strcmp (name, "font") == 0)
+    {
+      self->font = grub_font_get (value);
+    }
+  else if (grub_strcmp (name, "color") == 0)
+    {
+      grub_gui_parse_color (value, &self->color);
+    }
+  else if (grub_strcmp (name, "align") == 0)
+    {
+      int i;
+      for (i = 0; align_options[i]; i++)
+        {
+          if (grub_strcmp (align_options[i], value) == 0)
+            {
+              self->align = i;   /* Set the alignment mode.  */
+              break;
+            }
+        }
+    }
+  else if (grub_strcmp (name, "visible") == 0)
+    {
+      self->visible = grub_strcmp (value, "false") != 0;
+    }
+  else if (grub_strcmp (name, "id") == 0)
+    {
+      grub_free (self->id);
+      if (value)
+        self->id = grub_strdup (value);
+      else
+        self->id = 0;
+    }
+  return GRUB_ERR_NONE;
+}
+
+static struct grub_gui_component_ops label_ops =
+{
+  .destroy = label_destroy,
+  .get_id = label_get_id,
+  .is_instance = label_is_instance,
+  .paint = label_paint,
+  .set_parent = label_set_parent,
+  .get_parent = label_get_parent,
+  .set_bounds = label_set_bounds,
+  .get_bounds = label_get_bounds,
+  .get_minimal_size = label_get_minimal_size,
+  .set_property = label_set_property
+};
+
+grub_gui_component_t
+grub_gui_label_new (void)
+{
+  grub_gui_label_t label;
+  label = grub_zalloc (sizeof (*label));
+  if (! label)
+    return 0;
+  label->comp.ops = &label_ops;
+  label->visible = 1;
+  label->text = grub_strdup ("");
+  label->font = grub_font_get ("Unknown Regular 16");
+  label->color.red = 0;
+  label->color.green = 0;
+  label->color.blue = 0;
+  label->color.alpha = 255;
+  label->align = align_left;
+  return (grub_gui_component_t) label;
+}

gfxmenu/gui_list.c

@@ -0,0 +1,612 @@
+/* gui_list.c - GUI component to display a selectable list of items.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/gui_string_util.h>
+#include <grub/gfxmenu_view.h>
+#include <grub/gfxwidgets.h>
+
+struct grub_gui_list_impl
+{
+  struct grub_gui_list list;
+
+  grub_gui_container_t parent;
+  grub_video_rect_t bounds;
+  char *id;
+  int visible;
+
+  int icon_width;
+  int icon_height;
+  int item_height;
+  int item_padding;
+  int item_icon_space;
+  int item_spacing;
+  grub_font_t item_font;
+  grub_font_t selected_item_font;
+  grub_gui_color_t item_color;
+  int selected_item_color_set;
+  grub_gui_color_t selected_item_color;
+
+  int draw_scrollbar;
+  int need_to_recreate_scrollbar;
+  char *scrollbar_frame_pattern;
+  char *scrollbar_thumb_pattern;
+  grub_gfxmenu_box_t scrollbar_frame;
+  grub_gfxmenu_box_t scrollbar_thumb;
+  int scrollbar_width;
+
+  int first_shown_index;
+
+  int need_to_recreate_boxes;
+  char *theme_dir;
+  char *menu_box_pattern;
+  char *selected_item_box_pattern;
+  grub_gfxmenu_box_t menu_box;
+  grub_gfxmenu_box_t selected_item_box;
+
+  grub_gfxmenu_icon_manager_t icon_manager;
+
+  grub_gfxmenu_view_t view;
+};
+
+typedef struct grub_gui_list_impl *list_impl_t;
+
+static void
+list_destroy (void *vself)
+{
+  list_impl_t self = vself;
+
+  grub_free (self->theme_dir);
+  grub_free (self->menu_box_pattern);
+  grub_free (self->selected_item_box_pattern);
+  if (self->menu_box)
+    self->menu_box->destroy (self->menu_box);
+  if (self->selected_item_box)
+    self->selected_item_box->destroy (self->selected_item_box);
+  if (self->icon_manager)
+    grub_gfxmenu_icon_manager_destroy (self->icon_manager);
+
+  grub_free (self);
+}
+
+static int
+get_num_shown_items (list_impl_t self)
+{
+  int boxpad = self->item_padding;
+  int item_vspace = self->item_spacing;
+  int item_height = self->item_height;
+  
+  grub_gfxmenu_box_t box = self->menu_box;
+  int box_top_pad = box->get_top_pad (box);
+  int box_bottom_pad = box->get_bottom_pad (box);
+      
+  return (self->bounds.height + item_vspace - 2 * boxpad
+	  - box_top_pad - box_bottom_pad) / (item_height + item_vspace);
+}
+
+static int
+check_boxes (list_impl_t self)
+{
+  if (self->need_to_recreate_boxes)
+    {
+      grub_gui_recreate_box (&self->menu_box,
+                             self->menu_box_pattern,
+                             self->theme_dir);
+
+      grub_gui_recreate_box (&self->selected_item_box,
+                             self->selected_item_box_pattern,
+                             self->theme_dir);
+
+      self->need_to_recreate_boxes = 0;
+    }
+
+  return (self->menu_box != 0 && self->selected_item_box != 0);
+}
+
+static int
+check_scrollbar (list_impl_t self)
+{
+  if (self->need_to_recreate_scrollbar)
+    {
+      grub_gui_recreate_box (&self->scrollbar_frame,
+                             self->scrollbar_frame_pattern,
+                             self->theme_dir);
+
+      grub_gui_recreate_box (&self->scrollbar_thumb,
+                             self->scrollbar_thumb_pattern,
+                             self->theme_dir);
+
+      self->need_to_recreate_scrollbar = 0;
+    }
+
+  return (self->scrollbar_frame != 0 && self->scrollbar_thumb != 0);
+}
+
+static const char *
+list_get_id (void *vself)
+{
+  list_impl_t self = vself;
+  return self->id;
+}
+
+static int
+list_is_instance (void *vself __attribute__((unused)), const char *type)
+{
+  return (grub_strcmp (type, "component") == 0
+          || grub_strcmp (type, "list") == 0);
+}
+
+static struct grub_video_bitmap *
+get_item_icon (list_impl_t self, int item_index)
+{
+  grub_menu_entry_t entry;
+  entry = grub_menu_get_entry (self->view->menu, item_index);
+  if (! entry)
+    return 0;
+
+  return grub_gfxmenu_icon_manager_get_icon (self->icon_manager, entry);
+}
+
+static void
+make_selected_item_visible (list_impl_t self)
+{
+  int selected_index = self->view->selected;
+  if (selected_index < 0)
+    return;   /* No item is selected.  */
+  int num_shown_items = get_num_shown_items (self);
+  int last_shown_index = self->first_shown_index + (num_shown_items - 1);
+  if (selected_index < self->first_shown_index)
+    self->first_shown_index = selected_index;
+  else if (selected_index > last_shown_index)
+    self->first_shown_index = selected_index - (num_shown_items - 1);
+}
+
+/* Draw a scrollbar on the menu.  */
+static void
+draw_scrollbar (list_impl_t self,
+                int value, int extent, int min, int max,
+                int rightx, int topy, int height)
+{
+  grub_gfxmenu_box_t frame = self->scrollbar_frame;
+  grub_gfxmenu_box_t thumb = self->scrollbar_thumb;
+  int frame_vertical_pad = (frame->get_top_pad (frame)
+                            + frame->get_bottom_pad (frame));
+  int frame_horizontal_pad = (frame->get_left_pad (frame)
+                              + frame->get_right_pad (frame));
+  int tracktop = topy + frame->get_top_pad (frame);
+  int tracklen = height - frame_vertical_pad;
+  frame->set_content_size (frame, self->scrollbar_width, tracklen);
+  int thumby = tracktop + tracklen * (value - min) / (max - min);
+  int thumbheight = tracklen * extent / (max - min) + 1;
+  thumb->set_content_size (thumb,
+                           self->scrollbar_width - frame_horizontal_pad,
+                           thumbheight - (thumb->get_top_pad (thumb)
+                                          + thumb->get_bottom_pad (thumb)));
+  frame->draw (frame,
+               rightx - (self->scrollbar_width + frame_horizontal_pad),
+               topy);
+  thumb->draw (thumb,
+               rightx - (self->scrollbar_width - frame->get_right_pad (frame)),
+               thumby);
+}
+
+/* Draw the list of items.  */
+static void
+draw_menu (list_impl_t self, int width, int drawing_scrollbar,
+	   int num_shown_items)
+{
+  if (! self->menu_box || ! self->selected_item_box)
+    return;
+
+  int boxpad = self->item_padding;
+  int icon_text_space = self->item_icon_space;
+  int item_vspace = self->item_spacing;
+
+  int ascent = grub_font_get_ascent (self->item_font);
+  int descent = grub_font_get_descent (self->item_font);
+  int item_height = self->item_height;
+
+  make_selected_item_visible (self);
+
+  int scrollbar_h_space = drawing_scrollbar ? self->scrollbar_width : 0;
+
+  grub_gfxmenu_box_t selbox = self->selected_item_box;
+  int sel_leftpad = selbox->get_left_pad (selbox);
+  int item_top = boxpad;
+  int item_left = boxpad + sel_leftpad;
+  int menu_index;
+  int visible_index;
+
+  for (visible_index = 0, menu_index = self->first_shown_index;
+       visible_index < num_shown_items && menu_index < self->view->menu->size;
+       visible_index++, menu_index++)
+    {
+      int is_selected = (menu_index == self->view->selected);
+
+      if (is_selected)
+        {
+          int sel_toppad = selbox->get_top_pad (selbox);
+          selbox->set_content_size (selbox,
+                                    (width - 2 * boxpad
+                                     - scrollbar_h_space),
+                                    item_height);
+          selbox->draw (selbox,
+                        item_left - sel_leftpad,
+                        item_top - sel_toppad);
+        }
+
+      struct grub_video_bitmap *icon;
+      if ((icon = get_item_icon (self, menu_index)) != 0)
+        grub_video_blit_bitmap (icon, GRUB_VIDEO_BLIT_BLEND,
+                                item_left,
+                                item_top + (item_height - self->icon_height) / 2,
+                                0, 0, self->icon_width, self->icon_height);
+
+      const char *item_title =
+        grub_menu_get_entry (self->view->menu, menu_index)->title;
+      grub_font_t font =
+        (is_selected && self->selected_item_font
+         ? self->selected_item_font
+         : self->item_font);
+      grub_gui_color_t text_color =
+        ((is_selected && self->selected_item_color_set)
+         ? self->selected_item_color
+         : self->item_color);
+      grub_font_draw_string (item_title,
+                             font,
+                             grub_gui_map_color (text_color),
+                             item_left + self->icon_width + icon_text_space,
+                             (item_top + (item_height - (ascent + descent))
+                              / 2 + ascent));
+
+      item_top += item_height + item_vspace;
+    }
+}
+
+static void
+list_paint (void *vself, const grub_video_rect_t *region)
+{
+  list_impl_t self = vself;
+  grub_video_rect_t vpsave;
+
+  if (! self->visible)
+    return;
+  if (!grub_video_have_common_points (region, &self->bounds))
+    return;
+
+  check_boxes (self);
+
+  if (! self->menu_box || ! self->selected_item_box)
+    return;
+
+  grub_gui_set_viewport (&self->bounds, &vpsave);
+  {
+    grub_gfxmenu_box_t box = self->menu_box;
+    int box_left_pad = box->get_left_pad (box);
+    int box_top_pad = box->get_top_pad (box);
+    int box_right_pad = box->get_right_pad (box);
+    int box_bottom_pad = box->get_bottom_pad (box);
+    grub_video_rect_t vpsave2, content_rect;
+    int num_shown_items = get_num_shown_items (self);
+    int drawing_scrollbar = (self->draw_scrollbar
+			     && (num_shown_items < self->view->menu->size)
+			     && check_scrollbar (self));
+
+    content_rect.x = box_left_pad;
+    content_rect.y = box_top_pad;
+    content_rect.width = self->bounds.width - box_left_pad - box_right_pad;
+    content_rect.height = self->bounds.height - box_top_pad - box_bottom_pad;
+
+    box->set_content_size (box, content_rect.width, content_rect.height);
+
+    box->draw (box, 0, 0);
+
+    grub_gui_set_viewport (&content_rect, &vpsave2);
+    draw_menu (self, content_rect.width, drawing_scrollbar, num_shown_items);
+    grub_gui_restore_viewport (&vpsave2);
+
+    if (drawing_scrollbar)
+      draw_scrollbar (self,
+		      self->first_shown_index, num_shown_items,
+		      0, self->view->menu->size,
+		      self->bounds.width - box_right_pad
+		      + self->scrollbar_width,
+		      box_top_pad + self->item_padding,
+		      self->bounds.height - box_top_pad - box_bottom_pad);
+  }
+
+  grub_gui_restore_viewport (&vpsave);
+}
+
+static void
+list_set_parent (void *vself, grub_gui_container_t parent)
+{
+  list_impl_t self = vself;
+  self->parent = parent;
+}
+
+static grub_gui_container_t
+list_get_parent (void *vself)
+{
+  list_impl_t self = vself;
+  return self->parent;
+}
+
+static void
+list_set_bounds (void *vself, const grub_video_rect_t *bounds)
+{
+  list_impl_t self = vself;
+  self->bounds = *bounds;
+}
+
+static void
+list_get_bounds (void *vself, grub_video_rect_t *bounds)
+{
+  list_impl_t self = vself;
+  *bounds = self->bounds;
+}
+
+static void
+list_get_minimal_size (void *vself, unsigned *width, unsigned *height)
+{
+  list_impl_t self = vself;
+
+  if (check_boxes (self))
+    {
+      int boxpad = self->item_padding;
+      int item_vspace = self->item_spacing;
+      int item_height = self->item_height;
+      int num_items = 3;
+
+      grub_gfxmenu_box_t box = self->menu_box;
+      int box_left_pad = box->get_left_pad (box);
+      int box_top_pad = box->get_top_pad (box);
+      int box_right_pad = box->get_right_pad (box);
+      int box_bottom_pad = box->get_bottom_pad (box);
+      unsigned width_s;
+      
+      *width = grub_font_get_string_width (self->item_font, "Typical OS");
+      width_s = grub_font_get_string_width (self->selected_item_font,
+					    "Typical OS");
+      if (*width < width_s)
+	*width = width_s;
+
+      *width += 2 * boxpad + box_left_pad + box_right_pad;
+
+      /* Set the menu box height to fit the items.  */
+      *height = (item_height * num_items
+                 + item_vspace * (num_items - 1)
+                 + 2 * boxpad
+                 + box_top_pad + box_bottom_pad);
+    }
+  else
+    {
+      *width = 0;
+      *height = 0;
+    }
+}
+
+static grub_err_t
+list_set_property (void *vself, const char *name, const char *value)
+{
+  list_impl_t self = vself;
+  if (grub_strcmp (name, "item_font") == 0)
+    {
+      self->item_font = grub_font_get (value);
+    }
+  else if (grub_strcmp (name, "selected_item_font") == 0)
+    {
+      if (! value || grub_strcmp (value, "inherit") == 0)
+        self->selected_item_font = 0;
+      else
+        self->selected_item_font = grub_font_get (value);
+    }
+  else if (grub_strcmp (name, "item_color") == 0)
+    {
+      grub_gui_parse_color (value, &self->item_color);
+    }
+  else if (grub_strcmp (name, "selected_item_color") == 0)
+    {
+      if (! value || grub_strcmp (value, "inherit") == 0)
+        {
+          self->selected_item_color_set = 0;
+        }
+      else
+        {
+          if (grub_gui_parse_color (value, &self->selected_item_color)
+              == GRUB_ERR_NONE)
+            self->selected_item_color_set = 1;
+        }
+    }
+  else if (grub_strcmp (name, "icon_width") == 0)
+    {
+      self->icon_width = grub_strtol (value, 0, 10);
+      grub_gfxmenu_icon_manager_set_icon_size (self->icon_manager,
+                                               self->icon_width,
+                                               self->icon_height);
+    }
+  else if (grub_strcmp (name, "icon_height") == 0)
+    {
+      self->icon_height = grub_strtol (value, 0, 10);
+      grub_gfxmenu_icon_manager_set_icon_size (self->icon_manager,
+                                               self->icon_width,
+                                               self->icon_height);
+    }
+  else if (grub_strcmp (name, "item_height") == 0)
+    {
+      self->item_height = grub_strtol (value, 0, 10);
+    }
+  else if (grub_strcmp (name, "item_padding") == 0)
+    {
+      self->item_padding = grub_strtol (value, 0, 10);
+    }
+  else if (grub_strcmp (name, "item_icon_space") == 0)
+    {
+      self->item_icon_space = grub_strtol (value, 0, 10);
+    }
+  else if (grub_strcmp (name, "item_spacing") == 0)
+    {
+      self->item_spacing = grub_strtol (value, 0, 10);
+    }
+  else if (grub_strcmp (name, "visible") == 0)
+    {
+      self->visible = grub_strcmp (value, "false") != 0;
+    }
+  else if (grub_strcmp (name, "menu_pixmap_style") == 0)
+    {
+      self->need_to_recreate_boxes = 1;
+      grub_free (self->menu_box_pattern);
+      self->menu_box_pattern = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "selected_item_pixmap_style") == 0)
+    {
+      self->need_to_recreate_boxes = 1;
+      grub_free (self->selected_item_box_pattern);
+      self->selected_item_box_pattern = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "scrollbar_frame") == 0)
+    {
+      self->need_to_recreate_scrollbar = 1;
+      grub_free (self->scrollbar_frame_pattern);
+      self->scrollbar_frame_pattern = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "scrollbar_thumb") == 0)
+    {
+      self->need_to_recreate_scrollbar = 1;
+      grub_free (self->scrollbar_thumb_pattern);
+      self->scrollbar_thumb_pattern = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "scrollbar_width") == 0)
+    {
+      self->scrollbar_width = grub_strtol (value, 0, 10);
+    }
+  else if (grub_strcmp (name, "scrollbar") == 0)
+    {
+      self->draw_scrollbar = grub_strcmp (value, "false") != 0;
+    }
+  else if (grub_strcmp (name, "theme_dir") == 0)
+    {
+      self->need_to_recreate_boxes = 1;
+      grub_free (self->theme_dir);
+      self->theme_dir = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "id") == 0)
+    {
+      grub_free (self->id);
+      if (value)
+        self->id = grub_strdup (value);
+      else
+        self->id = 0;
+    }
+  return grub_errno;
+}
+
+/* Set necessary information that the gfxmenu view provides.  */
+static void
+list_set_view_info (void *vself,
+                    grub_gfxmenu_view_t view)
+{
+  list_impl_t self = vself;
+  grub_gfxmenu_icon_manager_set_theme_path (self->icon_manager,
+					    view->theme_path);
+  self->view = view;
+}
+
+static struct grub_gui_component_ops list_comp_ops =
+  {
+    .destroy = list_destroy,
+    .get_id = list_get_id,
+    .is_instance = list_is_instance,
+    .paint = list_paint,
+    .set_parent = list_set_parent,
+    .get_parent = list_get_parent,
+    .set_bounds = list_set_bounds,
+    .get_bounds = list_get_bounds,
+    .get_minimal_size = list_get_minimal_size,
+    .set_property = list_set_property
+  };
+
+static struct grub_gui_list_ops list_ops =
+{
+  .set_view_info = list_set_view_info
+};
+
+grub_gui_component_t
+grub_gui_list_new (void)
+{
+  list_impl_t self;
+  grub_font_t default_font;
+  grub_gui_color_t default_fg_color;
+  grub_gui_color_t default_bg_color;
+
+  self = grub_zalloc (sizeof (*self));
+  if (! self)
+    return 0;
+
+  self->list.ops = &list_ops;
+  self->list.component.ops = &list_comp_ops;
+
+  self->visible = 1;
+
+  default_font = grub_font_get ("Unknown Regular 16");
+  default_fg_color = grub_gui_color_rgb (0, 0, 0);
+  default_bg_color = grub_gui_color_rgb (255, 255, 255);
+
+  self->icon_width = 32;
+  self->icon_height = 32;
+  self->item_height = 42;
+  self->item_padding = 14;
+  self->item_icon_space = 4;
+  self->item_spacing = 16;
+  self->item_font = default_font;
+  self->selected_item_font = 0;    /* Default to using the item_font.  */
+  self->item_color = default_fg_color;
+  self->selected_item_color_set = 0;  /* Default to using the item_color.  */
+  self->selected_item_color = default_fg_color;
+
+  self->draw_scrollbar = 1;
+  self->need_to_recreate_scrollbar = 1;
+  self->scrollbar_frame = 0;
+  self->scrollbar_thumb = 0;
+  self->scrollbar_frame_pattern = 0;
+  self->scrollbar_thumb_pattern = 0;
+  self->scrollbar_width = 16;
+
+  self->first_shown_index = 0;
+
+  self->need_to_recreate_boxes = 0;
+  self->theme_dir = 0;
+  self->menu_box_pattern = 0;
+  self->selected_item_box_pattern = 0;
+  self->menu_box = grub_gfxmenu_create_box (0, 0);
+  self->selected_item_box = grub_gfxmenu_create_box (0, 0);
+
+  self->icon_manager = grub_gfxmenu_icon_manager_new ();
+  if (! self->icon_manager)
+    {
+      self->list.component.ops->destroy (self);
+      return 0;
+    }
+  grub_gfxmenu_icon_manager_set_icon_size (self->icon_manager,
+                                           self->icon_width,
+                                           self->icon_height);
+  return (grub_gui_component_t) self;
+}

gfxmenu/gui_progress_bar.c

@@ -0,0 +1,384 @@
+/* gui_progress_bar.c - GUI progress bar component.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/font.h>
+#include <grub/gui_string_util.h>
+#include <grub/gfxmenu_view.h>
+#include <grub/gfxwidgets.h>
+#include <grub/i18n.h>
+
+struct grub_gui_progress_bar
+{
+  struct grub_gui_progress progress;
+
+  grub_gui_container_t parent;
+  grub_video_rect_t bounds;
+  char *id;
+  int visible;
+  int start;
+  int end;
+  int value;
+  int show_text;
+  char *template;
+  grub_font_t font;
+  grub_gui_color_t text_color;
+  grub_gui_color_t border_color;
+  grub_gui_color_t bg_color;
+  grub_gui_color_t fg_color;
+
+  char *theme_dir;
+  int need_to_recreate_pixmaps;
+  int pixmapbar_available;
+  char *bar_pattern;
+  char *highlight_pattern;
+  grub_gfxmenu_box_t bar_box;
+  grub_gfxmenu_box_t highlight_box;
+};
+
+typedef struct grub_gui_progress_bar *grub_gui_progress_bar_t;
+
+static void
+progress_bar_destroy (void *vself)
+{
+  grub_gui_progress_bar_t self = vself;
+  grub_free (self);
+}
+
+static const char *
+progress_bar_get_id (void *vself)
+{
+  grub_gui_progress_bar_t self = vself;
+  return self->id;
+}
+
+static int
+progress_bar_is_instance (void *vself __attribute__((unused)), const char *type)
+{
+  return grub_strcmp (type, "component") == 0;
+}
+
+static int
+check_pixmaps (grub_gui_progress_bar_t self)
+{
+  if (!self->pixmapbar_available)
+    return 0;
+  if (self->need_to_recreate_pixmaps)
+    {
+      grub_gui_recreate_box (&self->bar_box,
+                             self->bar_pattern,
+                             self->theme_dir);
+
+      grub_gui_recreate_box (&self->highlight_box,
+                             self->highlight_pattern,
+                             self->theme_dir);
+
+      self->need_to_recreate_pixmaps = 0;
+    }
+
+  return (self->bar_box != 0 && self->highlight_box != 0);
+}
+
+static void
+draw_filled_rect_bar (grub_gui_progress_bar_t self)
+{
+  /* Set the progress bar's frame.  */
+  grub_video_rect_t f;
+  f.x = 1;
+  f.y = 1;
+  f.width = self->bounds.width - 2;
+  f.height = self->bounds.height - 2;
+
+  /* Border.  */
+  grub_video_fill_rect (grub_gui_map_color (self->border_color),
+                        f.x - 1, f.y - 1,
+                        f.width + 2, f.height + 2);
+
+  /* Bar background.  */
+  int barwidth = (f.width
+                  * (self->value - self->start)
+                  / (self->end - self->start));
+  grub_video_fill_rect (grub_gui_map_color (self->bg_color),
+                        f.x + barwidth, f.y,
+                        f.width - barwidth, f.height);
+
+  /* Bar foreground.  */
+  grub_video_fill_rect (grub_gui_map_color (self->fg_color),
+                        f.x, f.y,
+                        barwidth, f.height);
+}
+
+static void
+draw_pixmap_bar (grub_gui_progress_bar_t self)
+{
+  grub_gfxmenu_box_t bar = self->bar_box;
+  grub_gfxmenu_box_t hl = self->highlight_box;
+  int w = self->bounds.width;
+  int h = self->bounds.height;
+  int bar_l_pad = bar->get_left_pad (bar);
+  int bar_r_pad = bar->get_right_pad (bar);
+  int bar_t_pad = bar->get_top_pad (bar);
+  int bar_b_pad = bar->get_bottom_pad (bar);
+  int bar_h_pad = bar_l_pad + bar_r_pad;
+  int bar_v_pad = bar_t_pad + bar_b_pad;
+  int tracklen = w - bar_h_pad;
+  int trackheight = h - bar_v_pad;
+  int barwidth;
+
+  bar->set_content_size (bar, tracklen, trackheight);
+
+  barwidth = (tracklen * (self->value - self->start) 
+	      / (self->end - self->start));
+
+  hl->set_content_size (hl, barwidth, h - bar_v_pad);
+
+  bar->draw (bar, 0, 0);
+  hl->draw (hl, bar_l_pad, bar_t_pad);
+}
+
+static void
+draw_text (grub_gui_progress_bar_t self)
+{
+  if (self->template)
+    {
+      grub_font_t font = self->font;
+      grub_video_color_t text_color = grub_gui_map_color (self->text_color);
+      int width = self->bounds.width;
+      int height = self->bounds.height;
+      char *text;
+      text = grub_xasprintf (self->template,
+			     self->value > 0 ? self->value : -self->value);
+      if (!text)
+	{
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  return;
+	}
+      /* Center the text. */
+      int text_width = grub_font_get_string_width (font, text);
+      int x = (width - text_width) / 2;
+      int y = ((height - grub_font_get_descent (font)) / 2
+               + grub_font_get_ascent (font) / 2);
+      grub_font_draw_string (text, font, text_color, x, y);
+    }
+}
+
+static void
+progress_bar_paint (void *vself, const grub_video_rect_t *region)
+{
+  grub_gui_progress_bar_t self = vself;
+  grub_video_rect_t vpsave;
+
+  if (! self->visible)
+    return;
+  if (!grub_video_have_common_points (region, &self->bounds))
+    return;
+
+  if (self->end == self->start)
+    return;
+
+  grub_gui_set_viewport (&self->bounds, &vpsave);
+
+  if (check_pixmaps (self))
+    draw_pixmap_bar (self);
+  else
+    draw_filled_rect_bar (self);
+
+  draw_text (self);
+
+  grub_gui_restore_viewport (&vpsave);
+}
+
+static void
+progress_bar_set_parent (void *vself, grub_gui_container_t parent)
+{
+  grub_gui_progress_bar_t self = vself;
+  self->parent = parent;
+}
+
+static grub_gui_container_t
+progress_bar_get_parent (void *vself)
+{
+  grub_gui_progress_bar_t self = vself;
+  return self->parent;
+}
+
+static void
+progress_bar_set_bounds (void *vself, const grub_video_rect_t *bounds)
+{
+  grub_gui_progress_bar_t self = vself;
+  self->bounds = *bounds;
+}
+
+static void
+progress_bar_get_bounds (void *vself, grub_video_rect_t *bounds)
+{
+  grub_gui_progress_bar_t self = vself;
+  *bounds = self->bounds;
+}
+
+static void
+progress_bar_get_minimal_size (void *vself,
+			       unsigned *width, unsigned *height)
+{
+  unsigned text_width = 0, text_height = 0;
+  grub_gui_progress_bar_t self = vself;
+
+  if (self->template)
+    {
+      text_width = grub_font_get_string_width (self->font, self->template);
+      text_width += grub_font_get_string_width (self->font, "XXXXXXXXXX");
+      text_height = grub_font_get_descent (self->font)
+	+ grub_font_get_ascent (self->font);
+    }
+  *width = 200;
+  if (*width < text_width)
+    *width = text_width;
+  *height = 28;
+  if (*height < text_height)
+    *height = text_height;
+}
+
+static void
+progress_bar_set_state (void *vself, int visible, int start,
+			int current, int end)
+{
+  grub_gui_progress_bar_t self = vself;  
+  self->visible = visible;
+  self->start = start;
+  self->value = current;
+  self->end = end;
+}
+
+static grub_err_t
+progress_bar_set_property (void *vself, const char *name, const char *value)
+{
+  grub_gui_progress_bar_t self = vself;
+  if (grub_strcmp (name, "text") == 0)
+    {
+      grub_free (self->template);
+      if (grub_strcmp (value, "@TIMEOUT_NOTIFICATION_LONG@") == 0)
+	value 
+	  = _("The highlighted entry will be executed automatically in %ds.");
+      else if (grub_strcmp (value, "@TIMEOUT_NOTIFICATION_MIDDLE@") == 0)
+	/* TRANSLATORS:  's' stands for seconds.
+	   It's a standalone timeout notification.
+	   Please use the short form in your language.  */
+	value = _("%ds remaining.");
+      else if (grub_strcmp (value, "@TIMEOUT_NOTIFICATION_SHORT@") == 0)
+	/* TRANSLATORS:  's' stands for seconds.
+	   It's a standalone timeout notification.
+	   Please use the shortest form available in you language.  */
+	value = _("%ds");
+
+      self->template = grub_strdup (value);
+    }
+  else if (grub_strcmp (name, "font") == 0)
+    {
+      self->font = grub_font_get (value);
+    }
+  else if (grub_strcmp (name, "text_color") == 0)
+    {
+      grub_gui_parse_color (value, &self->text_color);
+    }
+  else if (grub_strcmp (name, "border_color") == 0)
+    {
+       grub_gui_parse_color (value, &self->border_color);
+    }
+  else if (grub_strcmp (name, "bg_color") == 0)
+    {
+       grub_gui_parse_color (value, &self->bg_color);
+    }
+  else if (grub_strcmp (name, "fg_color") == 0)
+    {
+      grub_gui_parse_color (value, &self->fg_color);
+    }
+  else if (grub_strcmp (name, "bar_style") == 0)
+    {
+      self->need_to_recreate_pixmaps = 1;
+      self->pixmapbar_available = 1;
+      grub_free (self->bar_pattern);
+      self->bar_pattern = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "highlight_style") == 0)
+    {
+      self->need_to_recreate_pixmaps = 1;
+      self->pixmapbar_available = 1;
+      grub_free (self->highlight_pattern);
+      self->highlight_pattern = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "theme_dir") == 0)
+    {
+      self->need_to_recreate_pixmaps = 1;
+      grub_free (self->theme_dir);
+      self->theme_dir = value ? grub_strdup (value) : 0;
+    }
+  else if (grub_strcmp (name, "id") == 0)
+    {
+      grub_free (self->id);
+      if (value)
+        self->id = grub_strdup (value);
+      else
+        self->id = 0;
+    }
+  return grub_errno;
+}
+
+static struct grub_gui_component_ops progress_bar_ops =
+{
+  .destroy = progress_bar_destroy,
+  .get_id = progress_bar_get_id,
+  .is_instance = progress_bar_is_instance,
+  .paint = progress_bar_paint,
+  .set_parent = progress_bar_set_parent,
+  .get_parent = progress_bar_get_parent,
+  .set_bounds = progress_bar_set_bounds,
+  .get_bounds = progress_bar_get_bounds,
+  .get_minimal_size = progress_bar_get_minimal_size,
+  .set_property = progress_bar_set_property
+};
+
+static struct grub_gui_progress_ops progress_bar_pb_ops =
+  {
+    .set_state = progress_bar_set_state
+  };
+
+grub_gui_component_t
+grub_gui_progress_bar_new (void)
+{
+  grub_gui_progress_bar_t self;
+  self = grub_zalloc (sizeof (*self));
+  if (! self)
+    return 0;
+  self->progress.ops = &progress_bar_pb_ops;
+  self->progress.component.ops = &progress_bar_ops;
+  self->visible = 1;
+  self->font = grub_font_get ("Unknown Regular 16");
+  grub_gui_color_t black = { .red = 0, .green = 0, .blue = 0, .alpha = 255 };
+  grub_gui_color_t gray = { .red = 128, .green = 128, .blue = 128, .alpha = 255 };
+  grub_gui_color_t lightgray = { .red = 200, .green = 200, .blue = 200, .alpha = 255 };
+  self->text_color = black;
+  self->border_color = black;
+  self->bg_color = gray;
+  self->fg_color = lightgray;
+
+  return (grub_gui_component_t) self;
+}

gfxmenu/gui_string_util.c

@@ -0,0 +1,327 @@
+/* gui_string_util.c - String utilities used by the GUI system.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/gui_string_util.h>
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+
+/* Create a new NUL-terminated string on the heap as a substring of BUF.
+   The range of buf included is the half-open interval [START,END).
+   The index START is inclusive, END is exclusive.  */
+char *
+grub_new_substring (const char *buf,
+                    grub_size_t start, grub_size_t end)
+{
+  if (end < start)
+    return 0;
+  grub_size_t len = end - start;
+  char *s = grub_malloc (len + 1);
+  if (! s)
+    return 0;
+  grub_memcpy (s, buf + start, len);
+  s[len] = '\0';
+  return s;
+}
+
+/* Eliminate "." and ".." path elements from PATH.  A new heap-allocated
+   string is returned.  */
+static char *
+canonicalize_path (const char *path)
+{
+  int i;
+  const char *p;
+  char *newpath = 0;
+
+  /* Count the path components in path.  */
+  int components = 1;
+  for (p = path; *p; p++)
+    if (*p == '/')
+      components++;
+
+  char **path_array = grub_malloc (components * sizeof (*path_array));
+  if (! path_array)
+    return 0;
+
+  /* Initialize array elements to NULL pointers; in case once of the
+     allocations fails, the cleanup code can just call grub_free() for all
+     pointers in the array.  */
+  for (i = 0; i < components; i++)
+    path_array[i] = 0;
+
+  /* Parse the path into path_array.  */
+  p = path;
+  for (i = 0; i < components && p; i++)
+    {
+      /* Find the end of the path element.  */
+      const char *end = grub_strchr (p, '/');
+      if (!end)
+        end = p + grub_strlen (p);
+
+      /* Copy the element.  */
+      path_array[i] = grub_new_substring (p, 0, end - p);
+      if (! path_array[i])
+        goto cleanup;
+
+      /* Advance p to point to the start of the next element, or NULL.  */
+      if (*end)
+        p = end + 1;
+      else
+        p = 0;
+    }
+
+  /* Eliminate '.' and '..' elements from the path array.  */
+  int newpath_length = 0;
+  for (i = components - 1; i >= 0; --i)
+    {
+      if (! grub_strcmp (path_array[i], "."))
+        {
+          grub_free (path_array[i]);
+          path_array[i] = 0;
+        }
+      else if (! grub_strcmp (path_array[i], "..")
+               && i > 0)
+        {
+          /* Delete the '..' and the prior path element.  */
+          grub_free (path_array[i]);
+          path_array[i] = 0;
+          --i;
+          grub_free (path_array[i]);
+          path_array[i] = 0;
+        }
+      else
+        {
+          newpath_length += grub_strlen (path_array[i]) + 1;
+        }
+    }
+
+  /* Construct a new path string.  */
+  newpath = grub_malloc (newpath_length + 1);
+  if (! newpath)
+    goto cleanup;
+
+  newpath[0] = '\0';
+  char *newpath_end = newpath;
+  int first = 1;
+  for (i = 0; i < components; i++)
+    {
+      char *element = path_array[i];
+      if (element)
+        {
+          /* For all components but the first, prefix with a slash.  */
+          if (! first)
+            newpath_end = grub_stpcpy (newpath_end, "/");
+          newpath_end = grub_stpcpy (newpath_end, element);
+          first = 0;
+        }
+    }
+
+cleanup:
+  for (i = 0; i < components; i++)
+    grub_free (path_array[i]);
+  grub_free (path_array);
+
+  return newpath;
+}
+
+/* Return a new heap-allocated string representing to absolute path
+   to the file referred to by PATH.  If PATH is an absolute path, then
+   the returned path is a copy of PATH.  If PATH is a relative path, then
+   BASE is with PATH used to construct the absolute path.  */
+char *
+grub_resolve_relative_path (const char *base, const char *path)
+{
+  char *abspath;
+  char *canonpath;
+  char *p;
+  grub_size_t l;
+
+  /* If PATH is an absolute path, then just use it as is.  */
+  if (path[0] == '/' || path[0] == '(')
+    return canonicalize_path (path);
+
+  abspath = grub_malloc (grub_strlen (base) + grub_strlen (path) + 3);
+  if (! abspath)
+    return 0;
+
+  /* Concatenate BASE and PATH.  */
+  p = grub_stpcpy (abspath, base);
+  l = grub_strlen (abspath);
+  if (l == 0 || abspath[l-1] != '/')
+    {
+      *p = '/';
+      p++;
+      *p = 0;
+    }
+  grub_stpcpy (p, path);
+
+  canonpath = canonicalize_path (abspath);
+  if (! canonpath)
+    return abspath;
+
+  grub_free (abspath);
+  return canonpath;
+}
+
+/* Get the path of the directory where the file at FILE_PATH is located.
+   FILE_PATH should refer to a file, not a directory.  The returned path
+   includes a trailing slash.
+   This does not handle GRUB "(hd0,0)" paths properly yet since it only
+   looks at slashes.  */
+char *
+grub_get_dirname (const char *file_path)
+{
+  int i;
+  int last_slash;
+
+  last_slash = -1;
+  for (i = grub_strlen (file_path) - 1; i >= 0; --i)
+    {
+      if (file_path[i] == '/')
+        {
+          last_slash = i;
+          break;
+        }
+    }
+  if (last_slash == -1)
+    return grub_strdup ("/");
+
+  return grub_new_substring (file_path, 0, last_slash + 1);
+}
+
+static __inline int
+my_isxdigit (char c)
+{
+  return ((c >= '0' && c <= '9')
+          || (c >= 'a' && c <= 'f')
+          || (c >= 'A' && c <= 'F'));
+}
+
+static int
+parse_hex_color_component (const char *s, unsigned start, unsigned end)
+{
+  unsigned len;
+  char buf[3];
+
+  len = end - start;
+  /* Check the limits so we don't overrun the buffer.  */
+  if (len < 1 || len > 2)
+    return 0;
+
+  if (len == 1)
+    {
+      buf[0] = s[start];   /* Get the first and only hex digit.  */
+      buf[1] = buf[0];     /* Duplicate the hex digit.  */
+    }
+  else if (len == 2)
+    {
+      buf[0] = s[start];
+      buf[1] = s[start + 1];
+    }
+
+  buf[2] = '\0';
+
+  return grub_strtoul (buf, 0, 16);
+}
+
+/* Parse a color string of the form "r, g, b", "#RGB", "#RGBA",
+   "#RRGGBB", or "#RRGGBBAA".  */
+grub_err_t
+grub_gui_parse_color (const char *s, grub_gui_color_t *color)
+{
+  grub_gui_color_t c;
+
+  /* Skip whitespace.  */
+  while (*s && grub_isspace (*s))
+    s++;
+
+  if (*s == '#')
+    {
+      /* HTML-style.  Number if hex digits:
+         [6] #RRGGBB     [3] #RGB
+         [8] #RRGGBBAA   [4] #RGBA  */
+
+      s++;  /* Skip the '#'.  */
+      /* Count the hexits to determine the format.  */
+      int hexits = 0;
+      const char *end = s;
+      while (my_isxdigit (*end))
+        {
+          end++;
+          hexits++;
+        }
+
+      /* Parse the color components based on the format.  */
+      if (hexits == 3 || hexits == 4)
+        {
+          c.red = parse_hex_color_component (s, 0, 1);
+          c.green = parse_hex_color_component (s, 1, 2);
+          c.blue = parse_hex_color_component (s, 2, 3);
+          if (hexits == 4)
+            c.alpha = parse_hex_color_component (s, 3, 4);
+          else
+            c.alpha = 255;
+        }
+      else if (hexits == 6 || hexits == 8)
+        {
+          c.red = parse_hex_color_component (s, 0, 2);
+          c.green = parse_hex_color_component (s, 2, 4);
+          c.blue = parse_hex_color_component (s, 4, 6);
+          if (hexits == 8)
+            c.alpha = parse_hex_color_component (s, 6, 8);
+          else
+            c.alpha = 255;
+        }
+      else
+        return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                           "invalid HTML-type color string `%s'", s);
+    }
+  else if (grub_isdigit (*s))
+    {
+      /* Comma separated decimal values.  */
+      c.red = grub_strtoul (s, 0, 0);
+      if ((s = grub_strchr (s, ',')) == 0)
+        return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                           "missing 1st comma separator in color `%s'", s);
+      s++;
+      c.green = grub_strtoul (s, 0, 0);
+      if ((s = grub_strchr (s, ',')) == 0)
+        return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                           "missing 2nd comma separator in color `%s'", s);
+      s++;
+      c.blue = grub_strtoul (s, 0, 0);
+      if ((s = grub_strchr (s, ',')) == 0)
+        c.alpha = 255;
+      else
+        {
+          s++;
+          c.alpha = grub_strtoul (s, 0, 0);
+        }
+    }
+  else
+    {
+      if (! grub_gui_get_named_color (s, &c))
+        return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                           "invalid named color `%s'", s);
+    }
+
+  if (grub_errno == GRUB_ERR_NONE)
+    *color = c;
+  return grub_errno;
+}

gfxmenu/gui_util.c

@@ -0,0 +1,101 @@
+/* gui_util.c - GUI utility functions.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/gui.h>
+#include <grub/gui_string_util.h>
+
+
+struct find_by_id_state
+{
+  const char *match_id;
+  grub_gui_component_callback match_callback;
+  void *match_userdata;
+};
+
+static void
+find_by_id_recursively (grub_gui_component_t component, void *userdata)
+{
+  struct find_by_id_state *state;
+  const char *id;
+
+  state = (struct find_by_id_state *) userdata;
+  id = component->ops->get_id (component);
+  if (id && grub_strcmp (id, state->match_id) == 0)
+    state->match_callback (component, state->match_userdata);
+
+  if (component->ops->is_instance (component, "container"))
+    {
+      grub_gui_container_t container;
+      container = (grub_gui_container_t) component;
+      container->ops->iterate_children (container,
+                                        find_by_id_recursively,
+                                        state);
+    }
+}
+
+void
+grub_gui_find_by_id (grub_gui_component_t root,
+                     const char *id,
+                     grub_gui_component_callback cb,
+                     void *userdata)
+{
+  struct find_by_id_state state;
+  state.match_id = id;
+  state.match_callback = cb;
+  state.match_userdata = userdata;
+  find_by_id_recursively (root, &state);
+}
+
+
+struct iterate_recursively_state
+{
+  grub_gui_component_callback callback;
+  void *userdata;
+};
+
+static
+void iterate_recursively_cb (grub_gui_component_t component, void *userdata)
+{
+  struct iterate_recursively_state *state;
+
+  state = (struct iterate_recursively_state *) userdata;
+  state->callback (component, state->userdata);
+
+  if (component->ops->is_instance (component, "container"))
+    {
+      grub_gui_container_t container;
+      container = (grub_gui_container_t) component;
+      container->ops->iterate_children (container,
+                                        iterate_recursively_cb,
+                                        state);
+    }
+}
+
+void
+grub_gui_iterate_recursively (grub_gui_component_t root,
+                              grub_gui_component_callback cb,
+                              void *userdata)
+{
+  struct iterate_recursively_state state;
+  state.callback = cb;
+  state.userdata = userdata;
+  iterate_recursively_cb (root, &state);
+}

gfxmenu/icon_manager.c

@@ -0,0 +1,263 @@
+/* icon_manager.c - gfxmenu icon manager.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/gui_string_util.h>
+#include <grub/bitmap.h>
+#include <grub/bitmap_scale.h>
+#include <grub/menu.h>
+#include <grub/icon_manager.h>
+#include <grub/env.h>
+
+/* Currently hard coded to '.png' extension.  */
+static const char icon_extension[] = ".png";
+
+typedef struct icon_entry
+{
+  char *class_name;
+  struct grub_video_bitmap *bitmap;
+  struct icon_entry *next;
+} *icon_entry_t;
+
+struct grub_gfxmenu_icon_manager
+{
+  char *theme_path;
+  int icon_width;
+  int icon_height;
+
+  /* Icon cache: linked list w/ dummy head node.  */
+  struct icon_entry cache;
+};
+
+
+/* Create a new icon manager and return a point to it.  */
+grub_gfxmenu_icon_manager_t
+grub_gfxmenu_icon_manager_new (void)
+{
+  grub_gfxmenu_icon_manager_t mgr;
+  mgr = grub_malloc (sizeof (*mgr));
+  if (! mgr)
+    return 0;
+
+  mgr->theme_path = 0;
+  mgr->icon_width = 0;
+  mgr->icon_height = 0;
+
+  /* Initialize the dummy head node.  */
+  mgr->cache.class_name = 0;
+  mgr->cache.bitmap = 0;
+  mgr->cache.next = 0;
+
+  return mgr;
+}
+
+/* Destroy the icon manager MGR, freeing all resources used by it.
+
+Note: Any bitmaps returned by grub_gfxmenu_icon_manager_get_icon()
+are destroyed and must not be used by the caller after this function
+is called.  */
+void
+grub_gfxmenu_icon_manager_destroy (grub_gfxmenu_icon_manager_t mgr)
+{
+  grub_gfxmenu_icon_manager_clear_cache (mgr);
+  grub_free (mgr->theme_path);
+  grub_free (mgr);
+}
+
+/* Clear the icon cache.  */
+void
+grub_gfxmenu_icon_manager_clear_cache (grub_gfxmenu_icon_manager_t mgr)
+{
+  icon_entry_t cur;
+  icon_entry_t next;
+  for (cur = mgr->cache.next; cur; cur = next)
+    {
+      next = cur->next;
+      grub_free (cur->class_name);
+      grub_video_bitmap_destroy (cur->bitmap);
+      grub_free (cur);
+    }
+  mgr->cache.next = 0;
+}
+
+/* Set the theme path.  If the theme path is changed, the icon cache
+   is cleared.  */
+void
+grub_gfxmenu_icon_manager_set_theme_path (grub_gfxmenu_icon_manager_t mgr,
+                                          const char *path)
+{
+  /* Clear the cache if the theme path has changed.  */
+  if (((mgr->theme_path == 0) != (path == 0))
+      || (grub_strcmp (mgr->theme_path, path) != 0))
+    grub_gfxmenu_icon_manager_clear_cache (mgr);
+
+  grub_free (mgr->theme_path);
+  mgr->theme_path = path ? grub_strdup (path) : 0;
+}
+
+/* Set the icon size.  When icons are requested from the icon manager,
+   they are scaled to this size before being returned.  If the size is
+   changed, the icon cache is cleared.  */
+void
+grub_gfxmenu_icon_manager_set_icon_size (grub_gfxmenu_icon_manager_t mgr,
+                                         int width, int height)
+{
+  /* If the width or height is changed, we must clear the cache, since the
+     scaled bitmaps are stored in the cache.  */
+  if (width != mgr->icon_width || height != mgr->icon_height)
+    grub_gfxmenu_icon_manager_clear_cache (mgr);
+
+  mgr->icon_width = width;
+  mgr->icon_height = height;
+}
+
+/* Try to load an icon for the specified CLASS_NAME in the directory DIR.
+   Returns 0 if the icon could not be loaded, or returns a pointer to a new
+   bitmap if it was successful.  */
+static struct grub_video_bitmap *
+try_loading_icon (grub_gfxmenu_icon_manager_t mgr,
+                  const char *dir, const char *class_name)
+{
+  char *path;
+  int l;
+
+  path = grub_malloc (grub_strlen (dir) + grub_strlen (class_name)
+		      + grub_strlen (icon_extension) + 3);
+  if (! path)
+    return 0;
+
+  grub_strcpy (path, dir);
+  l = grub_strlen (path);
+  if (path[l-1] != '/')
+    {
+      path[l] = '/';
+      path[l+1] = 0;
+    }
+  grub_strcat (path, class_name);
+  grub_strcat (path, icon_extension);
+
+  struct grub_video_bitmap *raw_bitmap;
+  grub_video_bitmap_load (&raw_bitmap, path);
+  grub_free (path);
+  grub_errno = GRUB_ERR_NONE;  /* Critical to clear the error!!  */
+  if (! raw_bitmap)
+    return 0;
+
+  struct grub_video_bitmap *scaled_bitmap;
+  grub_video_bitmap_create_scaled (&scaled_bitmap,
+                                   mgr->icon_width, mgr->icon_height,
+                                   raw_bitmap,
+                                   GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST);
+  grub_video_bitmap_destroy (raw_bitmap);
+  if (! scaled_bitmap)
+    {
+      grub_error_push ();
+      grub_error (grub_errno, "failed to scale icon");
+      return 0;
+    }
+
+  return scaled_bitmap;
+}
+
+/* Get the icon for the specified class CLASS_NAME.  If an icon for
+   CLASS_NAME already exists in the cache, then a reference to the cached
+   bitmap is returned.  If it is not cached, then it is loaded and cached.
+   If no icon could be could for CLASS_NAME, then 0 is returned.  */
+static struct grub_video_bitmap *
+get_icon_by_class (grub_gfxmenu_icon_manager_t mgr, const char *class_name)
+{
+  /* First check the icon cache.  */
+  icon_entry_t entry;
+  for (entry = mgr->cache.next; entry; entry = entry->next)
+    {
+      if (grub_strcmp (entry->class_name, class_name) == 0)
+        return entry->bitmap;
+    }
+
+  if (! mgr->theme_path)
+    return 0;
+
+  /* Otherwise, we search for an icon to load.  */
+  char *theme_dir = grub_get_dirname (mgr->theme_path);
+  char *icons_dir;
+  struct grub_video_bitmap *icon;
+  icon = 0;
+  /* First try the theme's own icons, from "grub/themes/NAME/icons/"  */
+  icons_dir = grub_resolve_relative_path (theme_dir, "icons/");
+  if (icons_dir)
+    {
+      icon = try_loading_icon (mgr, icons_dir, class_name);
+      grub_free (icons_dir);
+    }
+
+  grub_free (theme_dir);
+  if (! icon)
+    {
+      const char *icondir;
+
+      icondir = grub_env_get ("icondir");
+      if (icondir)
+	icon = try_loading_icon (mgr, icondir, class_name);
+    }
+
+  /* No icon was found.  */
+  /* This should probably be noted in the cache, so that a search is not
+     performed each time an icon for CLASS_NAME is requested.  */
+  if (! icon)
+    return 0;
+
+  /* Insert a new cache entry for this icon.  */
+  entry = grub_malloc (sizeof (*entry));
+  if (! entry)
+    {
+      grub_video_bitmap_destroy (icon);
+      return 0;
+    }
+  entry->class_name = grub_strdup (class_name);
+  entry->bitmap = icon;
+  entry->next = mgr->cache.next;
+  mgr->cache.next = entry;   /* Link it into the cache.  */
+  return entry->bitmap;
+}
+
+/* Get the best available icon for ENTRY.  Beginning with the first class
+   listed in the menu entry and proceeding forward, an icon for each class
+   is searched for.  The first icon found is returned.  The returned icon
+   is scaled to the size specified by
+   grub_gfxmenu_icon_manager_set_icon_size().
+
+     Note:  Bitmaps returned by this function are destroyed when the
+            icon manager is destroyed.
+ */
+struct grub_video_bitmap *
+grub_gfxmenu_icon_manager_get_icon (grub_gfxmenu_icon_manager_t mgr,
+                                    grub_menu_entry_t entry)
+{
+  struct grub_menu_entry_class *c;
+  struct grub_video_bitmap *icon;
+
+  /* Try each class in succession.  */
+  icon = 0;
+  for (c = entry->classes->next; c && ! icon; c = c->next)
+    icon = get_icon_by_class (mgr, c->name);
+  return icon;
+}

gfxmenu/named_colors.c

@@ -0,0 +1,209 @@
+/* named_colors.c - Named color values.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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/>.
+ */
+
+#include <grub/types.h>
+#include <grub/gui.h>
+#include <grub/gui_string_util.h>
+#include <grub/misc.h>
+
+struct named_color
+{
+  const char *name;
+  grub_gui_color_t color;
+};
+
+/*
+   Named color list generated from the list of SVG color keywords from
+   <http://www.w3.org/TR/css3-color/#svg-color>,
+   processed through the following Perl command:
+   perl -ne 'chomp;split;print "{ \"$_[0]\", RGB_COLOR($_[2]) },\n"'
+ */
+
+#define RGB_COLOR(r,g,b) {.red = r, .green = g, .blue = b, .alpha = 255}
+
+static struct named_color named_colors[] =
+{
+    { "aliceblue", RGB_COLOR(240,248,255) },
+    { "antiquewhite", RGB_COLOR(250,235,215) },
+    { "aqua", RGB_COLOR(0,255,255) },
+    { "aquamarine", RGB_COLOR(127,255,212) },
+    { "azure", RGB_COLOR(240,255,255) },
+    { "beige", RGB_COLOR(245,245,220) },
+    { "bisque", RGB_COLOR(255,228,196) },
+    { "black", RGB_COLOR(0,0,0) },
+    { "blanchedalmond", RGB_COLOR(255,235,205) },
+    { "blue", RGB_COLOR(0,0,255) },
+    { "blueviolet", RGB_COLOR(138,43,226) },
+    { "brown", RGB_COLOR(165,42,42) },
+    { "burlywood", RGB_COLOR(222,184,135) },
+    { "cadetblue", RGB_COLOR(95,158,160) },
+    { "chartreuse", RGB_COLOR(127,255,0) },
+    { "chocolate", RGB_COLOR(210,105,30) },
+    { "coral", RGB_COLOR(255,127,80) },
+    { "cornflowerblue", RGB_COLOR(100,149,237) },
+    { "cornsilk", RGB_COLOR(255,248,220) },
+    { "crimson", RGB_COLOR(220,20,60) },
+    { "cyan", RGB_COLOR(0,255,255) },
+    { "darkblue", RGB_COLOR(0,0,139) },
+    { "darkcyan", RGB_COLOR(0,139,139) },
+    { "darkgoldenrod", RGB_COLOR(184,134,11) },
+    { "darkgray", RGB_COLOR(169,169,169) },
+    { "darkgreen", RGB_COLOR(0,100,0) },
+    { "darkgrey", RGB_COLOR(169,169,169) },
+    { "darkkhaki", RGB_COLOR(189,183,107) },
+    { "darkmagenta", RGB_COLOR(139,0,139) },
+    { "darkolivegreen", RGB_COLOR(85,107,47) },
+    { "darkorange", RGB_COLOR(255,140,0) },
+    { "darkorchid", RGB_COLOR(153,50,204) },
+    { "darkred", RGB_COLOR(139,0,0) },
+    { "darksalmon", RGB_COLOR(233,150,122) },
+    { "darkseagreen", RGB_COLOR(143,188,143) },
+    { "darkslateblue", RGB_COLOR(72,61,139) },
+    { "darkslategray", RGB_COLOR(47,79,79) },
+    { "darkslategrey", RGB_COLOR(47,79,79) },
+    { "darkturquoise", RGB_COLOR(0,206,209) },
+    { "darkviolet", RGB_COLOR(148,0,211) },
+    { "deeppink", RGB_COLOR(255,20,147) },
+    { "deepskyblue", RGB_COLOR(0,191,255) },
+    { "dimgray", RGB_COLOR(105,105,105) },
+    { "dimgrey", RGB_COLOR(105,105,105) },
+    { "dodgerblue", RGB_COLOR(30,144,255) },
+    { "firebrick", RGB_COLOR(178,34,34) },
+    { "floralwhite", RGB_COLOR(255,250,240) },
+    { "forestgreen", RGB_COLOR(34,139,34) },
+    { "fuchsia", RGB_COLOR(255,0,255) },
+    { "gainsboro", RGB_COLOR(220,220,220) },
+    { "ghostwhite", RGB_COLOR(248,248,255) },
+    { "gold", RGB_COLOR(255,215,0) },
+    { "goldenrod", RGB_COLOR(218,165,32) },
+    { "gray", RGB_COLOR(128,128,128) },
+    { "green", RGB_COLOR(0,128,0) },
+    { "greenyellow", RGB_COLOR(173,255,47) },
+    { "grey", RGB_COLOR(128,128,128) },
+    { "honeydew", RGB_COLOR(240,255,240) },
+    { "hotpink", RGB_COLOR(255,105,180) },
+    { "indianred", RGB_COLOR(205,92,92) },
+    { "indigo", RGB_COLOR(75,0,130) },
+    { "ivory", RGB_COLOR(255,255,240) },
+    { "khaki", RGB_COLOR(240,230,140) },
+    { "lavender", RGB_COLOR(230,230,250) },
+    { "lavenderblush", RGB_COLOR(255,240,245) },
+    { "lawngreen", RGB_COLOR(124,252,0) },
+    { "lemonchiffon", RGB_COLOR(255,250,205) },
+    { "lightblue", RGB_COLOR(173,216,230) },
+    { "lightcoral", RGB_COLOR(240,128,128) },
+    { "lightcyan", RGB_COLOR(224,255,255) },
+    { "lightgoldenrodyellow", RGB_COLOR(250,250,210) },
+    { "lightgray", RGB_COLOR(211,211,211) },
+    { "lightgreen", RGB_COLOR(144,238,144) },
+    { "lightgrey", RGB_COLOR(211,211,211) },
+    { "lightpink", RGB_COLOR(255,182,193) },
+    { "lightsalmon", RGB_COLOR(255,160,122) },
+    { "lightseagreen", RGB_COLOR(32,178,170) },
+    { "lightskyblue", RGB_COLOR(135,206,250) },
+    { "lightslategray", RGB_COLOR(119,136,153) },
+    { "lightslategrey", RGB_COLOR(119,136,153) },
+    { "lightsteelblue", RGB_COLOR(176,196,222) },
+    { "lightyellow", RGB_COLOR(255,255,224) },
+    { "lime", RGB_COLOR(0,255,0) },
+    { "limegreen", RGB_COLOR(50,205,50) },
+    { "linen", RGB_COLOR(250,240,230) },
+    { "magenta", RGB_COLOR(255,0,255) },
+    { "maroon", RGB_COLOR(128,0,0) },
+    { "mediumaquamarine", RGB_COLOR(102,205,170) },
+    { "mediumblue", RGB_COLOR(0,0,205) },
+    { "mediumorchid", RGB_COLOR(186,85,211) },
+    { "mediumpurple", RGB_COLOR(147,112,219) },
+    { "mediumseagreen", RGB_COLOR(60,179,113) },
+    { "mediumslateblue", RGB_COLOR(123,104,238) },
+    { "mediumspringgreen", RGB_COLOR(0,250,154) },
+    { "mediumturquoise", RGB_COLOR(72,209,204) },
+    { "mediumvioletred", RGB_COLOR(199,21,133) },
+    { "midnightblue", RGB_COLOR(25,25,112) },
+    { "mintcream", RGB_COLOR(245,255,250) },
+    { "mistyrose", RGB_COLOR(255,228,225) },
+    { "moccasin", RGB_COLOR(255,228,181) },
+    { "navajowhite", RGB_COLOR(255,222,173) },
+    { "navy", RGB_COLOR(0,0,128) },
+    { "oldlace", RGB_COLOR(253,245,230) },
+    { "olive", RGB_COLOR(128,128,0) },
+    { "olivedrab", RGB_COLOR(107,142,35) },
+    { "orange", RGB_COLOR(255,165,0) },
+    { "orangered", RGB_COLOR(255,69,0) },
+    { "orchid", RGB_COLOR(218,112,214) },
+    { "palegoldenrod", RGB_COLOR(238,232,170) },
+    { "palegreen", RGB_COLOR(152,251,152) },
+    { "paleturquoise", RGB_COLOR(175,238,238) },
+    { "palevioletred", RGB_COLOR(219,112,147) },
+    { "papayawhip", RGB_COLOR(255,239,213) },
+    { "peachpuff", RGB_COLOR(255,218,185) },
+    { "peru", RGB_COLOR(205,133,63) },
+    { "pink", RGB_COLOR(255,192,203) },
+    { "plum", RGB_COLOR(221,160,221) },
+    { "powderblue", RGB_COLOR(176,224,230) },
+    { "purple", RGB_COLOR(128,0,128) },
+    { "red", RGB_COLOR(255,0,0) },
+    { "rosybrown", RGB_COLOR(188,143,143) },
+    { "royalblue", RGB_COLOR(65,105,225) },
+    { "saddlebrown", RGB_COLOR(139,69,19) },
+    { "salmon", RGB_COLOR(250,128,114) },
+    { "sandybrown", RGB_COLOR(244,164,96) },
+    { "seagreen", RGB_COLOR(46,139,87) },
+    { "seashell", RGB_COLOR(255,245,238) },
+    { "sienna", RGB_COLOR(160,82,45) },
+    { "silver", RGB_COLOR(192,192,192) },
+    { "skyblue", RGB_COLOR(135,206,235) },
+    { "slateblue", RGB_COLOR(106,90,205) },
+    { "slategray", RGB_COLOR(112,128,144) },
+    { "slategrey", RGB_COLOR(112,128,144) },
+    { "snow", RGB_COLOR(255,250,250) },
+    { "springgreen", RGB_COLOR(0,255,127) },
+    { "steelblue", RGB_COLOR(70,130,180) },
+    { "tan", RGB_COLOR(210,180,140) },
+    { "teal", RGB_COLOR(0,128,128) },
+    { "thistle", RGB_COLOR(216,191,216) },
+    { "tomato", RGB_COLOR(255,99,71) },
+    { "turquoise", RGB_COLOR(64,224,208) },
+    { "violet", RGB_COLOR(238,130,238) },
+    { "wheat", RGB_COLOR(245,222,179) },
+    { "white", RGB_COLOR(255,255,255) },
+    { "whitesmoke", RGB_COLOR(245,245,245) },
+    { "yellow", RGB_COLOR(255,255,0) },
+    { "yellowgreen", RGB_COLOR(154,205,50) },
+    { 0, { 0, 0, 0, 0 } }  /* Terminator.  */
+};
+
+/* Get the color named NAME.  If the color was found, returns 1 and
+   stores the color into *COLOR.  If the color was not found, returns 0 and
+   does not modify *COLOR.  */
+int
+grub_gui_get_named_color (const char *name,
+                          grub_gui_color_t *color)
+{
+  int i;
+  for (i = 0; named_colors[i].name; i++)
+    {
+      if (grub_strcmp (named_colors[i].name, name) == 0)
+        {
+          *color = named_colors[i].color;
+          return 1;
+        }
+    }
+  return 0;
+}

gfxmenu/theme_loader.c

@@ -0,0 +1,723 @@
+/* theme_loader.c - Theme file loader for gfxmenu.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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/>.
+ */
+
+#include <grub/types.h>
+#include <grub/file.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/video.h>
+#include <grub/gui_string_util.h>
+#include <grub/bitmap.h>
+#include <grub/bitmap_scale.h>
+#include <grub/gfxwidgets.h>
+#include <grub/gfxmenu_view.h>
+#include <grub/gui.h>
+
+/* Construct a new box widget using ABSPATTERN to find the pixmap files for
+   it, storing the new box instance at *BOXPTR.
+   PATTERN should be of the form: "(hd0,0)/somewhere/style*.png".
+   The '*' then gets substituted with the various pixmap names that the
+   box uses.  */
+static grub_err_t
+recreate_box_absolute (grub_gfxmenu_box_t *boxptr, const char *abspattern)
+{
+  char *prefix;
+  char *suffix;
+  char *star;
+  grub_gfxmenu_box_t box;
+
+  star = grub_strchr (abspattern, '*');
+  if (! star)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                       "missing `*' in box pixmap pattern `%s'", abspattern);
+
+  /* Prefix:  Get the part before the '*'.  */
+  prefix = grub_malloc (star - abspattern + 1);
+  if (! prefix)
+    return grub_errno;
+
+  grub_memcpy (prefix, abspattern, star - abspattern);
+  prefix[star - abspattern] = '\0';
+
+  /* Suffix:  Everything after the '*' is the suffix.  */
+  suffix = star + 1;
+
+  box = grub_gfxmenu_create_box (prefix, suffix);
+  grub_free (prefix);
+  if (! box)
+    return grub_errno;
+
+  if (*boxptr)
+    (*boxptr)->destroy (*boxptr);
+  *boxptr = box;
+  return grub_errno;
+}
+
+
+/* Construct a new box widget using PATTERN to find the pixmap files for it,
+   storing the new widget at *BOXPTR.  PATTERN should be of the form:
+   "somewhere/style*.png".  The '*' then gets substituted with the various
+   pixmap names that the widget uses.
+
+   Important!  The value of *BOXPTR must be initialized!  It must either
+   (1) Be 0 (a NULL pointer), or
+   (2) Be a pointer to a valid 'grub_gfxmenu_box_t' instance.
+   In this case, the previous instance is destroyed.  */
+grub_err_t
+grub_gui_recreate_box (grub_gfxmenu_box_t *boxptr,
+                       const char *pattern, const char *theme_dir)
+{
+  char *abspattern;
+
+  /* Check arguments.  */
+  if (! pattern)
+    {
+      /* If no pixmap pattern is given, then just create an empty box.  */
+      if (*boxptr)
+        (*boxptr)->destroy (*boxptr);
+      *boxptr = grub_gfxmenu_create_box (0, 0);
+      return grub_errno;
+    }
+
+  if (! theme_dir)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                       "styled box missing theme directory");
+
+  /* Resolve to an absolute path.  */
+  abspattern = grub_resolve_relative_path (theme_dir, pattern);
+  if (! abspattern)
+    return grub_errno;
+
+  /* Create the box.  */
+  recreate_box_absolute (boxptr, abspattern);
+  grub_free (abspattern);
+  return grub_errno;
+}
+
+/* Set the specified property NAME on the view to the given string VALUE.
+   The caller is responsible for the lifetimes of NAME and VALUE.  */
+static grub_err_t
+theme_set_string (grub_gfxmenu_view_t view,
+                  const char *name,
+                  const char *value,
+                  const char *theme_dir,
+                  const char *filename,
+                  int line_num,
+                  int col_num)
+{
+  if (! grub_strcmp ("title-font", name))
+    view->title_font = grub_font_get (value);
+  else if (! grub_strcmp ("message-font", name))
+    view->message_font = grub_font_get (value);
+  else if (! grub_strcmp ("terminal-font", name))
+    {
+      grub_free (view->terminal_font_name);
+      view->terminal_font_name = grub_strdup (value);
+      if (! view->terminal_font_name)
+        return grub_errno;
+    }
+  else if (! grub_strcmp ("title-color", name))
+    grub_gui_parse_color (value, &view->title_color);
+  else if (! grub_strcmp ("message-color", name))
+    grub_gui_parse_color (value, &view->message_color);
+  else if (! grub_strcmp ("message-bg-color", name))
+    grub_gui_parse_color (value, &view->message_bg_color);
+  else if (! grub_strcmp ("desktop-image", name))
+    {
+      struct grub_video_bitmap *raw_bitmap;
+      struct grub_video_bitmap *scaled_bitmap;
+      char *path;
+      path = grub_resolve_relative_path (theme_dir, value);
+      if (! path)
+        return grub_errno;
+      if (grub_video_bitmap_load (&raw_bitmap, path) != GRUB_ERR_NONE)
+        {
+          grub_free (path);
+          return grub_errno;
+        }
+      grub_free(path);
+      grub_video_bitmap_create_scaled (&scaled_bitmap,
+                                       view->screen.width,
+                                       view->screen.height,
+                                       raw_bitmap,
+                                       GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST);
+      grub_video_bitmap_destroy (raw_bitmap);
+      if (! scaled_bitmap)
+        {
+          grub_error_push ();
+          return grub_error (grub_errno, "error scaling desktop image");
+        }
+
+      grub_video_bitmap_destroy (view->desktop_image);
+      view->desktop_image = scaled_bitmap;
+    }
+  else if (! grub_strcmp ("desktop-color", name))
+     grub_gui_parse_color (value, &view->desktop_color);
+  else if (! grub_strcmp ("terminal-box", name))
+    {
+        grub_err_t err;
+        err = grub_gui_recreate_box (&view->terminal_box, value, theme_dir);
+        if (err != GRUB_ERR_NONE)
+          return err;
+    }
+  else if (! grub_strcmp ("title-text", name))
+    {
+      grub_free (view->title_text);
+      view->title_text = grub_strdup (value);
+      if (! view->title_text)
+        return grub_errno;
+    }
+  else
+    {
+      return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                         "%s:%d:%d unknown property `%s'",
+                         filename, line_num, col_num, name);
+    }
+  return grub_errno;
+}
+
+struct parsebuf
+{
+  char *buf;
+  int pos;
+  int len;
+  int line_num;
+  int col_num;
+  const char *filename;
+  char *theme_dir;
+  grub_gfxmenu_view_t view;
+};
+
+static int
+has_more (struct parsebuf *p)
+{
+  return p->pos < p->len;
+}
+
+static int
+read_char (struct parsebuf *p)
+{
+  if (has_more (p))
+    {
+      char c;
+      c = p->buf[p->pos++];
+      if (c == '\n')
+        {
+          p->line_num++;
+          p->col_num = 1;
+        }
+      else
+        {
+          p->col_num++;
+        }
+      return c;
+    }
+  else
+    return -1;
+}
+
+static int
+peek_char (struct parsebuf *p)
+{
+  if (has_more (p))
+    return p->buf[p->pos];
+  else
+    return -1;
+}
+
+static int
+is_whitespace (char c)
+{
+  return (c == ' '
+          || c == '\t'
+          || c == '\r'
+          || c == '\n'
+          || c == '\f');
+}
+
+static void
+skip_whitespace (struct parsebuf *p)
+{
+  while (has_more (p) && is_whitespace(peek_char (p)))
+    read_char (p);
+}
+
+static void
+advance_to_next_line (struct parsebuf *p)
+{
+  int c;
+
+  /* Eat characters up to the newline.  */
+  do
+    {
+      c = read_char (p);
+    }
+  while (c != -1 && c != '\n');
+}
+
+static int
+is_identifier_char (int c)
+{
+  return (c != -1
+          && (grub_isalpha(c)
+              || grub_isdigit(c)
+              || c == '_'
+              || c == '-'));
+}
+
+static char *
+read_identifier (struct parsebuf *p)
+{
+  /* Index of the first character of the identifier in p->buf.  */
+  int start;
+  /* Next index after the last character of the identifer in p->buf.  */
+  int end;
+
+  skip_whitespace (p);
+
+  /* Capture the start of the identifier.  */
+  start = p->pos;
+
+  /* Scan for the end.  */
+  while (is_identifier_char (peek_char (p)))
+    read_char (p);
+  end = p->pos;
+
+  if (end - start < 1)
+    return 0;
+
+  return grub_new_substring (p->buf, start, end);
+}
+
+static char *
+read_expression (struct parsebuf *p)
+{
+  int start;
+  int end;
+
+  skip_whitespace (p);
+  if (peek_char (p) == '"')
+    {
+      /* Read as a quoted string.  
+         The quotation marks are not included in the expression value.  */
+      /* Skip opening quotation mark.  */
+      read_char (p);
+      start = p->pos;
+      while (has_more (p) && peek_char (p) != '"')
+        read_char (p);
+      end = p->pos;
+      /* Skip the terminating quotation mark.  */
+      read_char (p);
+    }
+  else if (peek_char (p) == '(')
+    {
+      /* Read as a parenthesized string -- for tuples/coordinates.  */
+      /* The parentheses are included in the expression value.  */
+      int c;
+
+      start = p->pos;
+      do
+        {
+          c = read_char (p);
+        }
+      while (c != -1 && c != ')');
+      end = p->pos;
+    }
+  else if (has_more (p))
+    {
+      /* Read as a single word -- for numeric values or words without
+         whitespace.  */
+      start = p->pos;
+      while (has_more (p) && ! is_whitespace (peek_char (p)))
+        read_char (p);
+      end = p->pos;
+    }
+  else
+    {
+      /* The end of the theme file has been reached.  */
+      grub_error (GRUB_ERR_IO, "%s:%d:%d expression expected in theme file",
+                  p->filename, p->line_num, p->col_num);
+      return 0;
+    }
+
+  return grub_new_substring (p->buf, start, end);
+}
+
+static grub_err_t
+parse_proportional_spec (char *value, signed *abs, grub_fixed_signed_t *prop)
+{
+  signed num;
+  char *ptr;
+  int sig = 0;
+  *abs = 0;
+  *prop = 0;
+  ptr = value;
+  while (*ptr)
+    {
+      sig = 0;
+
+      while (*ptr == '-' || *ptr == '+')
+	{
+	  if (*ptr == '-')
+	    sig = !sig;
+	  ptr++;
+	}
+
+      num = grub_strtoul (ptr, &ptr, 0);
+      if (grub_errno)
+	return grub_errno;
+      if (sig)
+	num = -num;
+      if (*ptr == '%')
+	{
+	  *prop += grub_fixed_fsf_divide (grub_signed_to_fixed (num), 100);
+	  ptr++;
+	}
+      else
+	*abs += num;
+    }
+  return GRUB_ERR_NONE;
+}
+
+
+/* Read a GUI object specification from the theme file.
+   Any components created will be added to the GUI container PARENT.  */
+static grub_err_t
+read_object (struct parsebuf *p, grub_gui_container_t parent)
+{
+  grub_video_rect_t bounds;
+
+  char *name;
+  name = read_identifier (p);
+  if (! name)
+    goto cleanup;
+
+  grub_gui_component_t component = 0;
+  if (grub_strcmp (name, "label") == 0)
+    {
+      component = grub_gui_label_new ();
+    }
+  else if (grub_strcmp (name, "image") == 0)
+    {
+      component = grub_gui_image_new ();
+    }
+  else if (grub_strcmp (name, "vbox") == 0)
+    {
+      component = (grub_gui_component_t) grub_gui_vbox_new ();
+    }
+  else if (grub_strcmp (name, "hbox") == 0)
+    {
+      component = (grub_gui_component_t) grub_gui_hbox_new ();
+    }
+  else if (grub_strcmp (name, "canvas") == 0)
+    {
+      component = (grub_gui_component_t) grub_gui_canvas_new ();
+    }
+  else if (grub_strcmp (name, "progress_bar") == 0)
+    {
+      component = grub_gui_progress_bar_new ();
+    }
+  else if (grub_strcmp (name, "circular_progress") == 0)
+    {
+      component = grub_gui_circular_progress_new ();
+    }
+  else if (grub_strcmp (name, "boot_menu") == 0)
+    {
+      component = grub_gui_list_new ();
+    }
+  else
+    {
+      /* Unknown type.  */
+      grub_error (GRUB_ERR_IO, "%s:%d:%d unknown object type `%s'",
+                  p->filename, p->line_num, p->col_num, name);
+      goto cleanup;
+    }
+
+  if (! component)
+    goto cleanup;
+
+  /* Inform the component about the theme so it can find its resources.  */
+  component->ops->set_property (component, "theme_dir", p->theme_dir);
+  component->ops->set_property (component, "theme_path", p->filename);
+
+  /* Add the component as a child of PARENT.  */
+  bounds.x = 0;
+  bounds.y = 0;
+  bounds.width = -1;
+  bounds.height = -1;
+  component->ops->set_bounds (component, &bounds);
+  parent->ops->add (parent, component);
+
+  skip_whitespace (p);
+  if (read_char (p) != '{')
+    {
+      grub_error (GRUB_ERR_IO,
+                  "%s:%d:%d expected `{' after object type name `%s'",
+                  p->filename, p->line_num, p->col_num, name);
+      goto cleanup;
+    }
+
+  while (has_more (p))
+    {
+      skip_whitespace (p);
+
+      /* Check whether the end has been encountered.  */
+      if (peek_char (p) == '}')
+        {
+          /* Skip the closing brace.  */
+          read_char (p);
+          break;
+        }
+
+      if (peek_char (p) == '#')
+        {
+          /* Skip comments.  */
+          advance_to_next_line (p);
+          continue;
+        }
+
+      if (peek_char (p) == '+')
+        {
+          /* Skip the '+'.  */
+          read_char (p);
+
+          /* Check whether this component is a container.  */
+          if (component->ops->is_instance (component, "container"))
+            {
+              /* Read the sub-object recursively and add it as a child.  */
+              if (read_object (p, (grub_gui_container_t) component) != 0)
+                goto cleanup;
+              /* After reading the sub-object, resume parsing, expecting
+                 another property assignment or sub-object definition.  */
+              continue;
+            }
+          else
+            {
+              grub_error (GRUB_ERR_IO,
+                          "%s:%d:%d attempted to add object to non-container",
+                          p->filename, p->line_num, p->col_num);
+              goto cleanup;
+            }
+        }
+
+      char *property;
+      property = read_identifier (p);
+      if (! property)
+        {
+          grub_error (GRUB_ERR_IO, "%s:%d:%d identifier expected in theme file",
+                      p->filename, p->line_num, p->col_num);
+          goto cleanup;
+        }
+
+      skip_whitespace (p);
+      if (read_char (p) != '=')
+        {
+          grub_error (GRUB_ERR_IO,
+                      "%s:%d:%d expected `=' after property name `%s'",
+                      p->filename, p->line_num, p->col_num, property);
+          grub_free (property);
+          goto cleanup;
+        }
+      skip_whitespace (p);
+
+      char *value;
+      value = read_expression (p);
+      if (! value)
+        {
+          grub_free (property);
+          goto cleanup;
+        }
+
+      /* Handle the property value.  */
+      if (grub_strcmp (property, "left") == 0)
+	parse_proportional_spec (value, &component->x, &component->xfrac);
+      else if (grub_strcmp (property, "top") == 0)
+	parse_proportional_spec (value, &component->y, &component->yfrac);
+      else if (grub_strcmp (property, "width") == 0)
+	parse_proportional_spec (value, &component->w, &component->wfrac);
+      else if (grub_strcmp (property, "height") == 0)
+	parse_proportional_spec (value, &component->h, &component->hfrac);
+      else
+	/* General property handling.  */
+	component->ops->set_property (component, property, value);
+
+      grub_free (value);
+      grub_free (property);
+      if (grub_errno != GRUB_ERR_NONE)
+        goto cleanup;
+    }
+
+cleanup:
+  grub_free (name);
+  return grub_errno;
+}
+
+static grub_err_t
+read_property (struct parsebuf *p)
+{
+  char *name;
+
+  /* Read the property name.  */
+  name = read_identifier (p);
+  if (! name)
+    {
+      advance_to_next_line (p);
+      return grub_errno;
+    }
+
+  /* Skip whitespace before separator.  */
+  skip_whitespace (p);
+
+  /* Read separator.  */
+  if (read_char (p) != ':')
+    {
+      grub_error (GRUB_ERR_IO,
+                  "%s:%d:%d missing separator after property name `%s'",
+                  p->filename, p->line_num, p->col_num, name);
+      goto done;
+    }
+
+  /* Skip whitespace after separator.  */
+  skip_whitespace (p);
+
+  /* Get the value based on its type.  */
+  if (peek_char (p) == '"')
+    {
+      /* String value (e.g., '"My string"').  */
+      char *value = read_expression (p);
+      if (! value)
+        {
+          grub_error (GRUB_ERR_IO, "%s:%d:%d missing property value",
+                      p->filename, p->line_num, p->col_num);
+          goto done;
+        }
+      /* If theme_set_string results in an error, grub_errno will be returned
+         below.  */
+      theme_set_string (p->view, name, value, p->theme_dir,
+                        p->filename, p->line_num, p->col_num);
+      grub_free (value);
+    }
+  else
+    {
+      grub_error (GRUB_ERR_IO,
+                  "%s:%d:%d property value invalid; "
+                  "enclose literal values in quotes (\")",
+                  p->filename, p->line_num, p->col_num);
+      goto done;
+    }
+
+done:
+  grub_free (name);
+  return grub_errno;
+}
+
+/* Set properties on the view based on settings from the specified
+   theme file.  */
+grub_err_t
+grub_gfxmenu_view_load_theme (grub_gfxmenu_view_t view, const char *theme_path)
+{
+  grub_file_t file;
+  struct parsebuf p;
+
+  p.view = view;
+  p.theme_dir = grub_get_dirname (theme_path);
+
+  file = grub_file_open (theme_path);
+  if (! file)
+    {
+      grub_free (p.theme_dir);
+      return grub_errno;
+    }
+
+  p.len = grub_file_size (file);
+  p.buf = grub_malloc (p.len);
+  p.pos = 0;
+  p.line_num = 1;
+  p.col_num = 1;
+  p.filename = theme_path;
+  if (! p.buf)
+    {
+      grub_file_close (file);
+      grub_free (p.theme_dir);
+      return grub_errno;
+    }
+  if (grub_file_read (file, p.buf, p.len) != p.len)
+    {
+      grub_free (p.buf);
+      grub_file_close (file);
+      grub_free (p.theme_dir);
+      return grub_errno;
+    }
+
+  if (view->canvas)
+    view->canvas->component.ops->destroy (view->canvas);
+
+  view->canvas = grub_gui_canvas_new ();
+  ((grub_gui_component_t) view->canvas)
+    ->ops->set_bounds ((grub_gui_component_t) view->canvas,
+                       &view->screen);
+
+  while (has_more (&p))
+    {
+      /* Skip comments (lines beginning with #).  */
+      if (peek_char (&p) == '#')
+        {
+          advance_to_next_line (&p);
+          continue;
+        }
+
+      /* Find the first non-whitespace character.  */
+      skip_whitespace (&p);
+
+      /* Handle the content.  */
+      if (peek_char (&p) == '+')
+        {
+          /* Skip the '+'.  */
+          read_char (&p);
+          read_object (&p, view->canvas);
+        }
+      else
+        {
+          read_property (&p);
+        }
+
+      if (grub_errno != GRUB_ERR_NONE)
+        goto fail;
+    }
+
+  /* Set the new theme path.  */
+  grub_free (view->theme_path);
+  view->theme_path = grub_strdup (theme_path);
+  goto cleanup;
+
+fail:
+  if (view->canvas)
+    {
+      view->canvas->component.ops->destroy (view->canvas);
+      view->canvas = 0;
+    }
+
+cleanup:
+  grub_free (p.buf);
+  grub_file_close (file);
+  grub_free (p.theme_dir);
+  return grub_errno;
+}

gfxmenu/view.c

@@ -0,0 +1,486 @@
+/* view.c - Graphical menu interface MVC view. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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/>.
+ */
+
+#include <grub/types.h>
+#include <grub/file.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/normal.h>
+#include <grub/video.h>
+#include <grub/gfxterm.h>
+#include <grub/bitmap.h>
+#include <grub/bitmap_scale.h>
+#include <grub/term.h>
+#include <grub/gfxwidgets.h>
+#include <grub/time.h>
+#include <grub/menu.h>
+#include <grub/menu_viewer.h>
+#include <grub/gfxmenu_view.h>
+#include <grub/gui_string_util.h>
+#include <grub/icon_manager.h>
+
+/* The component ID identifying GUI components to be updated as the timeout
+   status changes.  */
+#define TIMEOUT_COMPONENT_ID "__timeout__"
+
+static void
+init_terminal (grub_gfxmenu_view_t view);
+static grub_video_rect_t term_rect;
+static grub_gfxmenu_view_t term_view;
+
+/* Create a new view object, loading the theme specified by THEME_PATH and
+   associating MODEL with the view.  */
+grub_gfxmenu_view_t
+grub_gfxmenu_view_new (const char *theme_path,
+		       int width, int height)
+{
+  grub_gfxmenu_view_t view;
+  grub_font_t default_font;
+  grub_gui_color_t default_fg_color;
+  grub_gui_color_t default_bg_color;
+
+  view = grub_malloc (sizeof (*view));
+  if (! view)
+    return 0;
+
+  view->screen.x = 0;
+  view->screen.y = 0;
+  view->screen.width = width;
+  view->screen.height = height;
+
+  default_font = grub_font_get ("Unknown Regular 16");
+  default_fg_color = grub_gui_color_rgb (0, 0, 0);
+  default_bg_color = grub_gui_color_rgb (255, 255, 255);
+
+  view->canvas = 0;
+
+  view->title_font = default_font;
+  view->message_font = default_font;
+  view->terminal_font_name = grub_strdup ("Fixed 10");
+  view->title_color = default_fg_color;
+  view->message_color = default_bg_color;
+  view->message_bg_color = default_fg_color;
+  view->desktop_image = 0;
+  view->desktop_color = default_bg_color;
+  view->terminal_box = grub_gfxmenu_create_box (0, 0);
+  view->title_text = grub_strdup ("GRUB Boot Menu");
+  view->progress_message_text = 0;
+  view->theme_path = 0;
+
+  /* Set the timeout bar's frame.  */
+  view->progress_message_frame.width = view->screen.width * 4 / 5;
+  view->progress_message_frame.height = 50;
+  view->progress_message_frame.x = view->screen.x
+    + (view->screen.width - view->progress_message_frame.width) / 2;
+  view->progress_message_frame.y = view->screen.y
+    + view->screen.height - 90 - 20 - view->progress_message_frame.height;
+
+  if (grub_gfxmenu_view_load_theme (view, theme_path) != 0)
+    {
+      grub_gfxmenu_view_destroy (view);
+      return 0;
+    }
+
+  return view;
+}
+
+/* Destroy the view object.  All used memory is freed.  */
+void
+grub_gfxmenu_view_destroy (grub_gfxmenu_view_t view)
+{
+  if (!view)
+    return;
+  grub_video_bitmap_destroy (view->desktop_image);
+  if (view->terminal_box)
+    view->terminal_box->destroy (view->terminal_box);
+  grub_free (view->terminal_font_name);
+  grub_free (view->title_text);
+  grub_free (view->progress_message_text);
+  grub_free (view->theme_path);
+  if (view->canvas)
+    view->canvas->component.ops->destroy (view->canvas);
+  grub_free (view);
+}
+
+static void
+redraw_background (grub_gfxmenu_view_t view,
+		   const grub_video_rect_t *bounds)
+{
+  if (view->desktop_image)
+    {
+      struct grub_video_bitmap *img = view->desktop_image;
+      grub_video_blit_bitmap (img, GRUB_VIDEO_BLIT_REPLACE,
+                              bounds->x, bounds->y,
+			      bounds->x - view->screen.x,
+			      bounds->y - view->screen.y,
+			      bounds->width, bounds->height);
+    }
+  else
+    {
+      grub_video_fill_rect (grub_gui_map_color (view->desktop_color),
+                            bounds->x, bounds->y,
+                            bounds->width, bounds->height);
+    }
+}
+
+static void
+draw_title (grub_gfxmenu_view_t view)
+{
+  if (! view->title_text)
+    return;
+
+  /* Center the title. */
+  int title_width = grub_font_get_string_width (view->title_font,
+                                                view->title_text);
+  int x = (view->screen.width - title_width) / 2;
+  int y = 40 + grub_font_get_ascent (view->title_font);
+  grub_font_draw_string (view->title_text,
+                         view->title_font,
+                         grub_gui_map_color (view->title_color),
+                         x, y);
+}
+
+struct progress_value_data
+{
+  int visible;
+  int start;
+  int end;
+  int value;
+};
+
+static void
+update_timeout_visit (grub_gui_component_t component,
+                      void *userdata)
+{
+  struct progress_value_data *pv;
+  pv = (struct progress_value_data *) userdata;
+
+  ((struct grub_gui_progress *) component)->ops
+    ->set_state ((struct grub_gui_progress *) component,
+		 pv->visible, pv->start, pv->value, pv->end);
+}
+
+void 
+grub_gfxmenu_print_timeout (int timeout, void *data)
+{
+  struct grub_gfxmenu_view *view = data;
+
+  struct progress_value_data pv;
+
+  auto void redraw_timeout_visit (grub_gui_component_t component,
+				  void *userdata __attribute__ ((unused)));
+
+  auto void redraw_timeout_visit (grub_gui_component_t component,
+				  void *userdata __attribute__ ((unused)))
+  {
+    grub_video_rect_t bounds;
+    component->ops->get_bounds (component, &bounds);
+    grub_gfxmenu_view_redraw (view, &bounds);
+  }
+
+  if (view->first_timeout == -1)
+    view->first_timeout = timeout;
+
+  pv.visible = 1;
+  pv.start = -(view->first_timeout + 1);
+  pv.end = 0;
+  pv.value = -timeout;
+
+  grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
+                       TIMEOUT_COMPONENT_ID, update_timeout_visit, &pv);
+  grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
+		       TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
+  grub_video_swap_buffers ();
+  if (view->double_repaint)
+    grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
+			 TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
+}
+
+void 
+grub_gfxmenu_clear_timeout (void *data)
+{
+  struct progress_value_data pv;
+  struct grub_gfxmenu_view *view = data;
+
+  auto void redraw_timeout_visit (grub_gui_component_t component,
+				  void *userdata __attribute__ ((unused)));
+
+  auto void redraw_timeout_visit (grub_gui_component_t component,
+				  void *userdata __attribute__ ((unused)))
+  {
+    grub_video_rect_t bounds;
+    component->ops->get_bounds (component, &bounds);
+    grub_gfxmenu_view_redraw (view, &bounds);
+  }
+
+  pv.visible = 0;
+  pv.start = 1;
+  pv.end = 0;
+  pv.value = 0;
+
+  grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
+                       TIMEOUT_COMPONENT_ID, update_timeout_visit, &pv);
+  grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
+		       TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
+  grub_video_swap_buffers ();
+  if (view->double_repaint)
+    grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
+			 TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
+}
+
+static void
+update_menu_visit (grub_gui_component_t component,
+                   void *userdata)
+{
+  grub_gfxmenu_view_t view;
+  view = userdata;
+  if (component->ops->is_instance (component, "list"))
+    {
+      grub_gui_list_t list = (grub_gui_list_t) component;
+      list->ops->set_view_info (list, view);
+    }
+}
+
+/* Update any boot menu components with the current menu model and
+   theme path.  */
+static void
+update_menu_components (grub_gfxmenu_view_t view)
+{
+  grub_gui_iterate_recursively ((grub_gui_component_t) view->canvas,
+                                update_menu_visit, view);
+}
+
+static void
+draw_message (grub_gfxmenu_view_t view)
+{
+  char *text = view->progress_message_text;
+  grub_video_rect_t f = view->progress_message_frame;
+  if (! text)
+    return;
+
+  grub_font_t font = view->message_font;
+  grub_video_color_t color = grub_gui_map_color (view->message_color);
+
+  /* Border.  */
+  grub_video_fill_rect (color,
+                        f.x-1, f.y-1, f.width+2, f.height+2);
+  /* Fill.  */
+  grub_video_fill_rect (grub_gui_map_color (view->message_bg_color),
+                        f.x, f.y, f.width, f.height);
+
+  /* Center the text. */
+  int text_width = grub_font_get_string_width (font, text);
+  int x = f.x + (f.width - text_width) / 2;
+  int y = (f.y + (f.height - grub_font_get_descent (font)) / 2
+           + grub_font_get_ascent (font) / 2);
+  grub_font_draw_string (text, font, color, x, y);
+}
+
+void
+grub_gfxmenu_view_redraw (grub_gfxmenu_view_t view,
+			  const grub_video_rect_t *region)
+{
+  if (grub_video_have_common_points (&term_rect, region))
+    grub_gfxterm_schedule_repaint ();
+
+  grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY);
+
+  redraw_background (view, region);
+  if (view->canvas)
+    view->canvas->component.ops->paint (view->canvas, region);
+  draw_title (view);
+  if (grub_video_have_common_points (&view->progress_message_frame, region))
+    draw_message (view);
+}
+
+void
+grub_gfxmenu_view_draw (grub_gfxmenu_view_t view)
+{
+  init_terminal (view);
+
+  /* Clear the screen; there may be garbage left over in video memory. */
+  grub_video_fill_rect (grub_video_map_rgb (0, 0, 0),
+                        view->screen.x, view->screen.y,
+                        view->screen.width, view->screen.height);
+  grub_video_swap_buffers ();
+  if (view->double_repaint)
+    grub_video_fill_rect (grub_video_map_rgb (0, 0, 0),
+			  view->screen.x, view->screen.y,
+			  view->screen.width, view->screen.height);
+
+  update_menu_components (view);
+
+  grub_gfxmenu_view_redraw (view, &view->screen);
+  grub_video_swap_buffers ();
+  if (view->double_repaint)
+    grub_gfxmenu_view_redraw (view, &view->screen);
+}
+
+static void
+redraw_menu_visit (grub_gui_component_t component,
+                   void *userdata)
+{
+  grub_gfxmenu_view_t view;
+  view = userdata;
+  if (component->ops->is_instance (component, "list"))
+    {
+      grub_gui_list_t list;
+      grub_video_rect_t bounds;
+
+      list = (grub_gui_list_t) component;
+      component->ops->get_bounds (component, &bounds);
+      grub_gfxmenu_view_redraw (view, &bounds);
+    }
+}
+
+void
+grub_gfxmenu_redraw_menu (grub_gfxmenu_view_t view)
+{
+  update_menu_components (view);
+
+  grub_gui_iterate_recursively ((grub_gui_component_t) view->canvas,
+                                redraw_menu_visit, view);
+  grub_video_swap_buffers ();
+  if (view->double_repaint)
+    {
+      grub_gui_iterate_recursively ((grub_gui_component_t) view->canvas,
+				    redraw_menu_visit, view);
+    }
+}
+
+void 
+grub_gfxmenu_set_chosen_entry (int entry, void *data)
+{
+  grub_gfxmenu_view_t view = data;
+
+  view->selected = entry;
+  grub_gfxmenu_redraw_menu (view);
+}
+
+static void
+grub_gfxmenu_draw_terminal_box (void)
+{
+  grub_gfxmenu_box_t term_box;
+
+  term_box = term_view->terminal_box;
+  if (!term_box)
+    return;
+  
+  term_box->set_content_size (term_box, term_rect.width,
+			      term_rect.height);
+  
+  term_box->draw (term_box,
+		  term_rect.x - term_box->get_left_pad (term_box),
+		  term_rect.y - term_box->get_top_pad (term_box));
+  grub_video_swap_buffers ();
+  if (term_view->double_repaint)
+    term_box->draw (term_box,
+		    term_rect.x - term_box->get_left_pad (term_box),
+		    term_rect.y - term_box->get_top_pad (term_box));
+}
+
+static void
+init_terminal (grub_gfxmenu_view_t view)
+{
+  term_rect.width = view->screen.width * 7 / 10;
+  term_rect.height = view->screen.height * 7 / 10;
+
+  term_rect.x = view->screen.x + view->screen.width * (10 - 7) / 10 / 2;
+  term_rect.y = view->screen.y + view->screen.height * (10 - 7) / 10 / 2;
+
+  term_view = view;
+
+  /* Note: currently there is no API for changing the gfxterm font
+     on the fly, so whatever font the initially loaded theme specifies
+     will be permanent.  */
+  grub_gfxterm_set_window (GRUB_VIDEO_RENDER_TARGET_DISPLAY, term_rect.x,
+			   term_rect.y,
+			   term_rect.width, term_rect.height,
+			   view->double_repaint, view->terminal_font_name, 3);
+  grub_gfxterm_decorator_hook = grub_gfxmenu_draw_terminal_box;
+}
+
+/* FIXME: previously notifications were displayed in special case.
+   Is it necessary?
+ */
+#if 0
+/* Sets MESSAGE as the progress message for the view.
+   MESSAGE can be 0, in which case no message is displayed.  */
+static void
+set_progress_message (grub_gfxmenu_view_t view, const char *message)
+{
+  grub_free (view->progress_message_text);
+  if (message)
+    view->progress_message_text = grub_strdup (message);
+  else
+    view->progress_message_text = 0;
+}
+
+static void
+notify_booting (grub_menu_entry_t entry, void *userdata)
+{
+  grub_gfxmenu_view_t view = (grub_gfxmenu_view_t) userdata;
+
+  char *s = grub_malloc (100 + grub_strlen (entry->title));
+  if (!s)
+    return;
+
+  grub_sprintf (s, "Booting '%s'", entry->title);
+  set_progress_message (view, s);
+  grub_free (s);
+  grub_gfxmenu_view_redraw (view, &view->progress_message_frame);
+  grub_video_swap_buffers ();
+  if (view->double_repaint)
+    grub_gfxmenu_view_redraw (view, &view->progress_message_frame);
+}
+
+static void
+notify_fallback (grub_menu_entry_t entry, void *userdata)
+{
+  grub_gfxmenu_view_t view = (grub_gfxmenu_view_t) userdata;
+
+  char *s = grub_malloc (100 + grub_strlen (entry->title));
+  if (!s)
+    return;
+
+  grub_sprintf (s, "Falling back to '%s'", entry->title);
+  set_progress_message (view, s);
+  grub_free (s);
+  grub_gfxmenu_view_redraw (view, &view->progress_message_frame);
+  grub_video_swap_buffers ();
+  if (view->double_repaint)
+    grub_gfxmenu_view_redraw (view, &view->progress_message_frame);
+}
+
+static void
+notify_execution_failure (void *userdata __attribute__ ((unused)))
+{
+}
+
+
+static struct grub_menu_execute_callback execute_callback =
+{
+  .notify_booting = notify_booting,
+  .notify_fallback = notify_fallback,
+  .notify_failure = notify_execution_failure
+};
+
+#endif

gfxmenu/widget-box.c

@@ -0,0 +1,313 @@
+/* widget_box.c - Pixmap-stylized box widget. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/video.h>
+#include <grub/bitmap.h>
+#include <grub/bitmap_scale.h>
+#include <grub/gfxwidgets.h>
+
+enum box_pixmaps
+{
+  BOX_PIXMAP_NW, BOX_PIXMAP_NE, BOX_PIXMAP_SE, BOX_PIXMAP_SW,
+  BOX_PIXMAP_N, BOX_PIXMAP_E, BOX_PIXMAP_S, BOX_PIXMAP_W,
+  BOX_PIXMAP_CENTER
+};
+
+static const char *box_pixmap_names[] = {
+  /* Corners: */
+  "nw", "ne", "se", "sw",
+  /* Sides: */
+  "n", "e", "s", "w",
+  /* Center: */
+  "c"
+};
+
+#define BOX_NUM_PIXMAPS (sizeof(box_pixmap_names)/sizeof(*box_pixmap_names))
+
+static int
+get_height (struct grub_video_bitmap *bitmap)
+{
+  if (bitmap)
+    return grub_video_bitmap_get_height (bitmap);
+  else
+    return 0;
+}
+
+static int
+get_width (struct grub_video_bitmap *bitmap)
+{
+  if (bitmap)
+    return grub_video_bitmap_get_width (bitmap);
+  else
+    return 0;
+}
+
+static void
+blit (grub_gfxmenu_box_t self, int pixmap_index, int x, int y)
+{
+  struct grub_video_bitmap *bitmap;
+  bitmap = self->scaled_pixmaps[pixmap_index];
+  if (! bitmap)
+    return;
+  grub_video_blit_bitmap (bitmap, GRUB_VIDEO_BLIT_BLEND,
+                          x, y, 0, 0,
+                          grub_video_bitmap_get_width (bitmap),
+                          grub_video_bitmap_get_height (bitmap));
+}
+
+static void
+draw (grub_gfxmenu_box_t self, int x, int y)
+{
+  int height_n;
+  int height_s;
+  int height_e;
+  int height_w;
+  int width_n;
+  int width_s;
+  int width_e;
+  int width_w;
+
+  height_n = get_height (self->scaled_pixmaps[BOX_PIXMAP_N]);
+  height_s = get_height (self->scaled_pixmaps[BOX_PIXMAP_S]);
+  height_e = get_height (self->scaled_pixmaps[BOX_PIXMAP_E]);
+  height_w = get_height (self->scaled_pixmaps[BOX_PIXMAP_W]);
+  width_n = get_width (self->scaled_pixmaps[BOX_PIXMAP_N]);
+  width_s = get_width (self->scaled_pixmaps[BOX_PIXMAP_S]);
+  width_e = get_width (self->scaled_pixmaps[BOX_PIXMAP_E]);
+  width_w = get_width (self->scaled_pixmaps[BOX_PIXMAP_W]);
+
+  /* Draw sides.  */
+  blit (self, BOX_PIXMAP_N, x + width_w, y);
+  blit (self, BOX_PIXMAP_S, x + width_w, y + height_n + self->content_height);
+  blit (self, BOX_PIXMAP_E, x + width_w + self->content_width, y + height_n);
+  blit (self, BOX_PIXMAP_W, x, y + height_n);
+
+  /* Draw corners.  */
+  blit (self, BOX_PIXMAP_NW, x, y);
+  blit (self, BOX_PIXMAP_NE, x + width_w + self->content_width, y);
+  blit (self, BOX_PIXMAP_SE,
+        x + width_w + self->content_width,
+        y + height_n + self->content_height);
+  blit (self, BOX_PIXMAP_SW, x, y + height_n + self->content_height);
+
+  /* Draw center.  */
+  blit (self, BOX_PIXMAP_CENTER, x + width_w, y + height_n);
+}
+
+static grub_err_t
+scale_pixmap (grub_gfxmenu_box_t self, int i, int w, int h)
+{
+  struct grub_video_bitmap **scaled = &self->scaled_pixmaps[i];
+  struct grub_video_bitmap *raw = self->raw_pixmaps[i];
+
+  if (raw == 0)
+    return grub_errno;
+
+  if (w == -1)
+    w = grub_video_bitmap_get_width (raw);
+  if (h == -1)
+    h = grub_video_bitmap_get_height (raw);
+
+  if (*scaled == 0
+      || ((int) grub_video_bitmap_get_width (*scaled) != w)
+      || ((int) grub_video_bitmap_get_height (*scaled) != h))
+    {
+      if (*scaled)
+        {
+          grub_video_bitmap_destroy (*scaled);
+          *scaled = 0;
+        }
+
+      /* Don't try to create a bitmap with a zero dimension.  */
+      if (w != 0 && h != 0)
+        grub_video_bitmap_create_scaled (scaled, w, h, raw,
+                                         GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST);
+      if (grub_errno != GRUB_ERR_NONE)
+        {
+          grub_error_push ();
+          grub_error (grub_errno,
+                      "failed to scale bitmap for styled box pixmap #%d", i);
+        }
+    }
+
+  return grub_errno;
+}
+
+static void
+set_content_size (grub_gfxmenu_box_t self,
+                  int width, int height)
+{
+  self->content_width = width;
+  self->content_height = height;
+
+  /* Resize sides to match the width and height.  */
+  /* It is assumed that the corners width/height match the adjacent sides.  */
+
+  /* Resize N and S sides to match width.  */
+  if (scale_pixmap(self, BOX_PIXMAP_N, width, -1) != GRUB_ERR_NONE)
+    return;
+  if (scale_pixmap(self, BOX_PIXMAP_S, width, -1) != GRUB_ERR_NONE)
+    return;
+
+  /* Resize E and W sides to match height.  */
+  if (scale_pixmap(self, BOX_PIXMAP_E, -1, height) != GRUB_ERR_NONE)
+      return;
+  if (scale_pixmap(self, BOX_PIXMAP_W, -1, height) != GRUB_ERR_NONE)
+    return;
+
+  /* Don't scale the corners--they are assumed to match the sides. */
+  if (scale_pixmap(self, BOX_PIXMAP_NW, -1, -1) != GRUB_ERR_NONE)
+    return;
+  if (scale_pixmap(self, BOX_PIXMAP_SW, -1, -1) != GRUB_ERR_NONE)
+    return;
+  if (scale_pixmap(self, BOX_PIXMAP_NE, -1, -1) != GRUB_ERR_NONE)
+    return;
+  if (scale_pixmap(self, BOX_PIXMAP_SE, -1, -1) != GRUB_ERR_NONE)
+    return;
+
+  /* Scale the center area. */
+  if (scale_pixmap(self, BOX_PIXMAP_CENTER, width, height) != GRUB_ERR_NONE)
+    return;
+}
+
+static int
+get_left_pad (grub_gfxmenu_box_t self)
+{
+  return get_width (self->raw_pixmaps[BOX_PIXMAP_W]);
+}
+
+static int
+get_top_pad (grub_gfxmenu_box_t self)
+{
+  return get_height (self->raw_pixmaps[BOX_PIXMAP_N]);
+}
+
+static int
+get_right_pad (grub_gfxmenu_box_t self)
+{
+  return get_width (self->raw_pixmaps[BOX_PIXMAP_E]);
+}
+
+static int
+get_bottom_pad (grub_gfxmenu_box_t self)
+{
+  return get_height (self->raw_pixmaps[BOX_PIXMAP_S]);
+}
+
+static void
+destroy (grub_gfxmenu_box_t self)
+{
+  unsigned i;
+  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
+    {
+      if (self->raw_pixmaps[i])
+        grub_video_bitmap_destroy(self->raw_pixmaps[i]);
+      self->raw_pixmaps[i] = 0;
+
+      if (self->scaled_pixmaps[i])
+        grub_video_bitmap_destroy(self->scaled_pixmaps[i]);
+      self->scaled_pixmaps[i] = 0;
+    }
+  grub_free (self->raw_pixmaps);
+  self->raw_pixmaps = 0;
+  grub_free (self->scaled_pixmaps);
+  self->scaled_pixmaps = 0;
+
+  /* Free self:  must be the last step!  */
+  grub_free (self);
+}
+
+
+/* Create a new box.  If PIXMAPS_PREFIX and PIXMAPS_SUFFIX are both non-null,
+   then an attempt is made to load the north, south, east, west, northwest,
+   northeast, southeast, southwest, and center pixmaps.
+   If either PIXMAPS_PREFIX or PIXMAPS_SUFFIX is 0, then no pixmaps are
+   loaded, and the box has zero-width borders and is drawn transparent.  */
+grub_gfxmenu_box_t
+grub_gfxmenu_create_box (const char *pixmaps_prefix,
+                         const char *pixmaps_suffix)
+{
+  unsigned i;
+  grub_gfxmenu_box_t box;
+
+  box = (grub_gfxmenu_box_t) grub_malloc (sizeof (*box));
+  if (! box)
+    return 0;
+
+  box->content_width = 0;
+  box->content_height = 0;
+  box->raw_pixmaps =
+    (struct grub_video_bitmap **)
+    grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *));
+  box->scaled_pixmaps =
+    (struct grub_video_bitmap **)
+    grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *));
+
+  /* Initialize all pixmap pointers to NULL so that proper destruction can
+     be performed if an error is encountered partway through construction.  */
+  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
+      box->raw_pixmaps[i] = 0;
+  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
+      box->scaled_pixmaps[i] = 0;
+
+  /* Load the pixmaps.  */
+  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
+    {
+      if (pixmaps_prefix && pixmaps_suffix)
+        {
+          char *path;
+          char *path_end;
+
+          path = grub_malloc (grub_strlen (pixmaps_prefix)
+                              + grub_strlen (box_pixmap_names[i])
+                              + grub_strlen (pixmaps_suffix)
+                              + 1);
+          if (! path)
+            goto fail_and_destroy;
+
+          /* Construct the specific path for this pixmap.  */
+          path_end = grub_stpcpy (path, pixmaps_prefix);
+          path_end = grub_stpcpy (path_end, box_pixmap_names[i]);
+          path_end = grub_stpcpy (path_end, pixmaps_suffix);
+
+          grub_video_bitmap_load (&box->raw_pixmaps[i], path);
+          grub_free (path);
+
+          /* Ignore missing pixmaps.  */
+          grub_errno = GRUB_ERR_NONE;
+        }
+    }
+
+  box->draw = draw;
+  box->set_content_size = set_content_size;
+  box->get_left_pad = get_left_pad;
+  box->get_top_pad = get_top_pad;
+  box->get_right_pad = get_right_pad;
+  box->get_bottom_pad = get_bottom_pad;
+  box->destroy = destroy;
+  return box;
+
+fail_and_destroy:
+  destroy (box);
+  return 0;
+}

gnulib/getdelim.c

@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <errno.h>
+#include <unistd.h>
 
 #ifndef SSIZE_MAX
 # define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))

hook/datehook.c

@@ -76,7 +76,7 @@ grub_read_hook_datetime (struct grub_env_var *var,
                 return grub_get_weekday_name (&datetime);
               }
 
-            grub_sprintf (buf, "%d", n);
+            grub_snprintf (buf, sizeof (buf), "%d", n);
             break;
           }
     }

include/grub/aout.h

@@ -16,6 +16,38 @@
  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+/*-
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      from: @(#)exec.h        8.1 (Berkeley) 6/11/93
+ * $FreeBSD$
+ */
+
 #ifndef GRUB_AOUT_HEADER
 #define GRUB_AOUT_HEADER 1
 

include/grub/at_keyboard.h

@@ -0,0 +1,54 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007,2008,2009  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/>.
+ */
+
+#ifndef GRUB_AT_KEYBOARD_HEADER
+#define GRUB_AT_KEYBOARD_HEADER	1
+
+#define SHIFT_L		0x2a
+#define SHIFT_R		0x36
+#define CTRL		0x1d
+#define ALT		0x38
+#define CAPS_LOCK	0x3a
+#define NUM_LOCK	0x45
+#define SCROLL_LOCK	0x46
+
+/* Used for sending commands to the controller.  */
+#define KEYBOARD_COMMAND_ISREADY(x)	!((x) & 0x02)
+#define KEYBOARD_COMMAND_READ		0x20
+#define KEYBOARD_COMMAND_WRITE		0x60
+#define KEYBOARD_COMMAND_REBOOT		0xfe
+
+#define KEYBOARD_SCANCODE_SET1		0x40
+
+#define KEYBOARD_ISMAKE(x)	!((x) & 0x80)
+#define KEYBOARD_ISREADY(x)	((x) & 0x01)
+#define KEYBOARD_SCANCODE(x)	((x) & 0x7f)
+
+#ifdef GRUB_MACHINE_IEEE1275
+#define OLPC_UP		GRUB_TERM_UP
+#define OLPC_DOWN	GRUB_TERM_DOWN
+#define OLPC_LEFT	GRUB_TERM_LEFT
+#define OLPC_RIGHT	GRUB_TERM_RIGHT
+#else
+#define OLPC_UP		'\0'
+#define OLPC_DOWN	'\0'
+#define OLPC_LEFT	'\0'
+#define OLPC_RIGHT	'\0'
+#endif
+
+#endif

include/grub/ata.h

@@ -98,8 +98,8 @@ struct grub_ata_device
 
   /* IO addresses on which the registers for this device can be
      found.  */
-  int ioaddress;
+  grub_port_t ioaddress;
-  int ioaddress2;
+  grub_port_t ioaddress2;
 
   /* Two devices can be connected to a single cable.  Use this field
      to select device 0 (commonly known as "master") or device 1

include/grub/bitmap.h

@@ -47,24 +47,24 @@ struct grub_video_bitmap_reader
 };
 typedef struct grub_video_bitmap_reader *grub_video_bitmap_reader_t;
 
-void grub_video_bitmap_reader_register (grub_video_bitmap_reader_t reader);
+void EXPORT_FUNC (grub_video_bitmap_reader_register) (grub_video_bitmap_reader_t reader);
-void grub_video_bitmap_reader_unregister (grub_video_bitmap_reader_t reader);
+void EXPORT_FUNC (grub_video_bitmap_reader_unregister) (grub_video_bitmap_reader_t reader);
 
-grub_err_t grub_video_bitmap_create (struct grub_video_bitmap **bitmap,
+grub_err_t EXPORT_FUNC (grub_video_bitmap_create) (struct grub_video_bitmap **bitmap,
-                                     unsigned int width, unsigned int height,
+						   unsigned int width, unsigned int height,
-                                     enum grub_video_blit_format blit_format);
+						   enum grub_video_blit_format blit_format);
 
-grub_err_t grub_video_bitmap_destroy (struct grub_video_bitmap *bitmap);
+grub_err_t EXPORT_FUNC (grub_video_bitmap_destroy) (struct grub_video_bitmap *bitmap);
 
-grub_err_t grub_video_bitmap_load (struct grub_video_bitmap **bitmap,
+grub_err_t EXPORT_FUNC (grub_video_bitmap_load) (struct grub_video_bitmap **bitmap,
-                                   const char *filename);
+						 const char *filename);
 
-unsigned int grub_video_bitmap_get_width (struct grub_video_bitmap *bitmap);
+unsigned int EXPORT_FUNC (grub_video_bitmap_get_width) (struct grub_video_bitmap *bitmap);
-unsigned int grub_video_bitmap_get_height (struct grub_video_bitmap *bitmap);
+unsigned int EXPORT_FUNC (grub_video_bitmap_get_height) (struct grub_video_bitmap *bitmap);
 
-void grub_video_bitmap_get_mode_info (struct grub_video_bitmap *bitmap,
+void EXPORT_FUNC (grub_video_bitmap_get_mode_info) (struct grub_video_bitmap *bitmap,
-                                      struct grub_video_mode_info *mode_info);
+						    struct grub_video_mode_info *mode_info);
 
-void *grub_video_bitmap_get_data (struct grub_video_bitmap *bitmap);
+void *EXPORT_FUNC (grub_video_bitmap_get_data) (struct grub_video_bitmap *bitmap);
 
 #endif /* ! GRUB_BITMAP_HEADER */

include/grub/bitmap_scale.h

@@ -0,0 +1,49 @@
+/* bitmap_scale.h - Bitmap scaling functions. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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/>.
+ */
+
+#ifndef GRUB_BITMAP_SCALE_HEADER
+#define GRUB_BITMAP_SCALE_HEADER 1
+
+#include <grub/err.h>
+#include <grub/types.h>
+#include <grub/bitmap_scale.h>
+
+enum grub_video_bitmap_scale_method
+{
+  /* Choose the fastest interpolation algorithm.  */
+  GRUB_VIDEO_BITMAP_SCALE_METHOD_FASTEST,
+  /* Choose the highest quality interpolation algorithm.  */
+  GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST,
+
+  /* Specific algorithms:  */
+  /* Nearest neighbor interpolation.  */
+  GRUB_VIDEO_BITMAP_SCALE_METHOD_NEAREST,
+  /* Bilinear interpolation.  */
+  GRUB_VIDEO_BITMAP_SCALE_METHOD_BILINEAR
+};
+
+grub_err_t
+EXPORT_FUNC (grub_video_bitmap_create_scaled) (struct grub_video_bitmap **dst,
+					       int dst_width, int dst_height,
+					       struct grub_video_bitmap *src,
+					       enum 
+					       grub_video_bitmap_scale_method
+					       scale_method);
+
+#endif /* ! GRUB_BITMAP_SCALE_HEADER */

include/grub/bufio.h

@@ -22,7 +22,7 @@
 
 #include <grub/file.h>
 
-grub_file_t grub_bufio_open (grub_file_t io, int size);
+grub_file_t EXPORT_FUNC (grub_bufio_open) (grub_file_t io, int size);
-grub_file_t grub_buffile_open (const char *name, int size);
+grub_file_t EXPORT_FUNC (grub_buffile_open) (const char *name, int size);
 
 #endif /* ! GRUB_BUFIO_H */

include/grub/cache.h

@@ -23,6 +23,14 @@
 #include <grub/symbol.h>
 #include <grub/types.h>
 
+#if defined (__i386__) || defined (__x86_64__)
+static inline void
+grub_arch_sync_caches (void *address __attribute__ ((unused)),
+		       grub_size_t len __attribute__ ((unused)))
+{
+}
+#else
 void EXPORT_FUNC(grub_arch_sync_caches) (void *address, grub_size_t len);
+#endif
 
 #endif /* ! GRUB_CACHE_HEADER */

include/grub/cmos.h

@@ -0,0 +1,72 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008, 2009  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/>.
+ */
+
+#ifndef	GRUB_CMOS_H
+#define	GRUB_CMOS_H	1
+
+#include <grub/types.h>
+#include <grub/cpu/io.h>
+#include <grub/cpu/cmos.h>
+
+#define GRUB_CMOS_INDEX_SECOND		0
+#define GRUB_CMOS_INDEX_SECOND_ALARM	1
+#define GRUB_CMOS_INDEX_MINUTE		2
+#define GRUB_CMOS_INDEX_MINUTE_ALARM	3
+#define GRUB_CMOS_INDEX_HOUR		4
+#define GRUB_CMOS_INDEX_HOUR_ALARM	5
+#define GRUB_CMOS_INDEX_DAY_OF_WEEK	6
+#define GRUB_CMOS_INDEX_DAY_OF_MONTH	7
+#define GRUB_CMOS_INDEX_MONTH		8
+#define GRUB_CMOS_INDEX_YEAR		9
+
+#define GRUB_CMOS_INDEX_STATUS_A	0xA
+#define GRUB_CMOS_INDEX_STATUS_B	0xB
+#define GRUB_CMOS_INDEX_STATUS_C	0xC
+#define GRUB_CMOS_INDEX_STATUS_D	0xD
+
+#define GRUB_CMOS_STATUS_B_DAYLIGHT	1
+#define GRUB_CMOS_STATUS_B_24HOUR	2
+#define GRUB_CMOS_STATUS_B_BINARY	4
+
+static inline grub_uint8_t
+grub_bcd_to_num (grub_uint8_t a)
+{
+  return ((a >> 4) * 10 + (a & 0xF));
+}
+
+static inline grub_uint8_t
+grub_num_to_bcd (grub_uint8_t a)
+{
+  return (((a / 10) << 4) + (a % 10));
+}
+
+static inline grub_uint8_t
+grub_cmos_read (grub_uint8_t index)
+{
+  grub_outb (index, GRUB_CMOS_ADDR_REG);
+  return grub_inb (GRUB_CMOS_DATA_REG);
+}
+
+static inline void
+grub_cmos_write (grub_uint8_t index, grub_uint8_t value)
+{
+  grub_outb (index, GRUB_CMOS_ADDR_REG);
+  grub_outb (value, GRUB_CMOS_DATA_REG);
+}
+
+#endif /* GRUB_CMOS_H */

include/grub/dl.h

@@ -110,10 +110,15 @@ int EXPORT_FUNC(grub_dl_unref) (grub_dl_t mod);
 #endif
 void EXPORT_FUNC(grub_dl_iterate) (int (*hook) (grub_dl_t mod));
 grub_dl_t EXPORT_FUNC(grub_dl_get) (const char *name);
-grub_err_t EXPORT_FUNC(grub_dl_register_symbol) (const char *name, void *addr,
+grub_err_t grub_dl_register_symbol (const char *name, void *addr,
-					    grub_dl_t mod);
+				    grub_dl_t mod);
 
 grub_err_t grub_arch_dl_check_header (void *ehdr);
 grub_err_t grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr);
 
+#if defined (_mips) && ! defined (GRUB_UTIL)
+#define GRUB_LINKER_HAVE_INIT 1
+void grub_arch_dl_init_linker (void);
+#endif
+
 #endif /* ! GRUB_DL_H */

include/grub/elfload.h

@@ -46,12 +46,12 @@ grub_elf_t grub_elf_file (grub_file_t);
 grub_err_t grub_elf_close (grub_elf_t);
 
 int grub_elf_is_elf32 (grub_elf_t);
-grub_size_t grub_elf32_size (grub_elf_t);
+grub_size_t grub_elf32_size (grub_elf_t, Elf32_Addr *);
 grub_err_t grub_elf32_load (grub_elf_t, grub_elf32_load_hook_t, grub_addr_t *,
 			    grub_size_t *);
 
 int grub_elf_is_elf64 (grub_elf_t);
-grub_size_t grub_elf64_size (grub_elf_t);
+grub_size_t grub_elf64_size (grub_elf_t, Elf64_Addr *);
 grub_err_t grub_elf64_load (grub_elf_t, grub_elf64_load_hook_t, grub_addr_t *,
 			    grub_size_t *);
 

include/grub/env.h

@@ -22,6 +22,7 @@
 #include <grub/symbol.h>
 #include <grub/err.h>
 #include <grub/types.h>
+#include <grub/menu.h>
 
 struct grub_env_var;
 
@@ -30,18 +31,6 @@ typedef char *(*grub_env_read_hook_t) (struct grub_env_var *var,
 typedef char *(*grub_env_write_hook_t) (struct grub_env_var *var,
 					const char *val);
 
-enum grub_env_var_type
-  {
-    /* The default variable type which is local in current context.  */
-    GRUB_ENV_VAR_LOCAL,
-
-    /* The exported type, which is passed to new contexts.  */
-    GRUB_ENV_VAR_GLOBAL,
-
-    /* The data slot type, which is used to store arbitrary data.  */
-    GRUB_ENV_VAR_DATA
-  };
-
 struct grub_env_var
 {
   char *name;
@@ -50,23 +39,24 @@ struct grub_env_var
   grub_env_write_hook_t write_hook;
   struct grub_env_var *next;
   struct grub_env_var **prevp;
-  enum grub_env_var_type type;
+  int global;
 };
 
 grub_err_t EXPORT_FUNC(grub_env_set) (const char *name, const char *val);
 char *EXPORT_FUNC(grub_env_get) (const char *name);
 void EXPORT_FUNC(grub_env_unset) (const char *name);
 void EXPORT_FUNC(grub_env_iterate) (int (*func) (struct grub_env_var *var));
+struct grub_env_var *EXPORT_FUNC(grub_env_find) (const char *name);
 grub_err_t EXPORT_FUNC(grub_register_variable_hook) (const char *name,
 						     grub_env_read_hook_t read_hook,
 						     grub_env_write_hook_t write_hook);
-grub_err_t EXPORT_FUNC(grub_env_context_open) (int export);
-grub_err_t EXPORT_FUNC(grub_env_context_close) (void);
-grub_err_t EXPORT_FUNC(grub_env_export) (const char *name);
 
-grub_err_t EXPORT_FUNC(grub_env_set_data_slot) (const char *name,
+grub_err_t grub_env_context_open (int export);
-						const void *ptr);
+grub_err_t grub_env_context_close (void);
-void *EXPORT_FUNC(grub_env_get_data_slot) (const char *name);
+grub_err_t grub_env_export (const char *name);
-void EXPORT_FUNC(grub_env_unset_data_slot) (const char *name);
+
+void grub_env_unset_menu (void);
+grub_menu_t grub_env_get_menu (void);
+void grub_env_set_menu (grub_menu_t nmenu);
 
 #endif /* ! GRUB_ENV_HEADER */

include/grub/env_private.h

@@ -0,0 +1,46 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2003,2005,2006,2007,2009  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/>.
+ */
+
+#ifndef GRUB_ENV_PRIVATE_HEADER
+#define GRUB_ENV_PRIVATE_HEADER	1
+
+#include <grub/env.h>
+
+/* The size of the hash table.  */
+#define	HASHSZ	13
+
+/* A hashtable for quick lookup of variables.  */
+struct grub_env_context
+{
+  /* A hash table for variables.  */
+  struct grub_env_var *vars[HASHSZ];
+
+  /* One level deeper on the stack.  */
+  struct grub_env_context *prev;
+};
+
+/* This is used for sorting only.  */
+struct grub_env_sorted_var
+{
+  struct grub_env_var *var;
+  struct grub_env_sorted_var *next;
+};
+
+extern struct grub_env_context *EXPORT_VAR(grub_current_context);
+
+#endif /* ! GRUB_ENV_PRIVATE_HEADER */