1 \ Copyright (c) 2003 Scott Long <scottl@FreeBSD.org>
   2 \ Copyright (c) 2003 Aleksander Fafula <alex@fafula.com>
   3 \ Copyright (c) 2006-2015 Devin Teske <dteske@FreeBSD.org>
   4 \ Copyright 2019 OmniOS Community Edition (OmniOSce) Association.
   5 \ All rights reserved.
   6 \
   7 \ Redistribution and use in source and binary forms, with or without
   8 \ modification, are permitted provided that the following conditions
   9 \ are met:
  10 \ 1. Redistributions of source code must retain the above copyright
  11 \    notice, this list of conditions and the following disclaimer.
  12 \ 2. Redistributions in binary form must reproduce the above copyright
  13 \    notice, this list of conditions and the following disclaimer in the
  14 \    documentation and/or other materials provided with the distribution.
  15 \
  16 \ THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17 \ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18 \ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19 \ ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20 \ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21 \ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22 \ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23 \ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24 \ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25 \ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26 \ SUCH DAMAGE.
  27 
  28 marker task-menu.4th
  29 
  30 \ Frame drawing
  31 include /boot/forth/frames.4th
  32 
  33 vocabulary menu-infrastructure
  34 vocabulary menu-namespace
  35 vocabulary menu-command-helpers
  36 
  37 only forth also menu-infrastructure definitions
  38 
  39 f_double        \ Set frames to double (see frames.4th). Replace with
  40                 \ f_single if you want single frames.
  41 46 constant dot \ ASCII definition of a period (in decimal)
  42 
  43  5 constant menu_default_x         \ default column position of timeout
  44 10 constant menu_default_y         \ default row position of timeout msg
  45  4 constant menu_timeout_default_x \ default column position of timeout
  46 23 constant menu_timeout_default_y \ default row position of timeout msg
  47 10 constant menu_timeout_default   \ default timeout (in seconds)
  48 
  49 \ Customize the following values with care
  50 
  51   1 constant menu_start \ Numerical prefix of first menu item
  52 dot constant bullet     \ Menu bullet (appears after numerical prefix)
  53   5 constant menu_x     \ Row position of the menu (from the top)
  54  10 constant menu_y     \ Column position of the menu (from left side)
  55 
  56 \ Menu Appearance
  57 variable menuidx   \ Menu item stack for number prefixes
  58 variable menurow   \ Menu item stack for positioning
  59 variable menubllt  \ Menu item bullet
  60 
  61 \ Menu Positioning
  62 variable menuX     \ Menu X offset (columns)
  63 variable menuY     \ Menu Y offset (rows)
  64 
  65 \ Menu-item elements
  66 variable menurebootadded
  67 
  68 \ Parsing of kernels into menu-items
  69 variable kernidx
  70 variable kernlen
  71 variable kernmenuidx
  72 
  73 \ Menu timer [count-down] variables
  74 variable menu_timeout_enabled \ timeout state (internal use only)
  75 variable menu_time            \ variable for tracking the passage of time
  76 variable menu_timeout         \ determined configurable delay duration
  77 variable menu_timeout_x       \ column position of timeout message
  78 variable menu_timeout_y       \ row position of timeout message
  79 
  80 \ Containers for parsing kernels into menu-items
  81 create kerncapbuf 64 allot
  82 create kerndefault 64 allot
  83 create kernelsbuf 256 allot
  84 
  85 only forth also menu-namespace definitions
  86 
  87 \ Menu-item key association/detection
  88 variable menukey1
  89 variable menukey2
  90 variable menukey3
  91 variable menukey4
  92 variable menukey5
  93 variable menukey6
  94 variable menukey7
  95 variable menukey8
  96 variable menureboot
  97 variable menuacpi
  98 variable menuosconsole
  99 variable menuoptions
 100 variable menukernel
 101 
 102 \ Menu initialization status variables
 103 variable init_state1
 104 variable init_state2
 105 variable init_state3
 106 variable init_state4
 107 variable init_state5
 108 variable init_state6
 109 variable init_state7
 110 variable init_state8
 111 
 112 \ Boolean option status variables
 113 variable toggle_state1
 114 variable toggle_state2
 115 variable toggle_state3
 116 variable toggle_state4
 117 variable toggle_state5
 118 variable toggle_state6
 119 variable toggle_state7
 120 variable toggle_state8
 121 
 122 \ Array option status variables
 123 variable cycle_state1
 124 variable cycle_state2
 125 variable cycle_state3
 126 variable cycle_state4
 127 variable cycle_state5
 128 variable cycle_state6
 129 variable cycle_state7
 130 variable cycle_state8
 131 
 132 \ Containers for storing the initial caption text
 133 create init_text1 64 allot
 134 create init_text2 64 allot
 135 create init_text3 64 allot
 136 create init_text4 64 allot
 137 create init_text5 64 allot
 138 create init_text6 64 allot
 139 create init_text7 64 allot
 140 create init_text8 64 allot
 141 
 142 only forth definitions
 143 
 144 : arch-i386? ( -- BOOL ) \ Returns TRUE (-1) on i386, FALSE (0) otherwise.
 145         s" arch-i386" environment? dup if
 146                 drop
 147         then
 148 ;
 149 
 150 : acpipresent? ( -- flag ) \ Returns TRUE if ACPI is present, FALSE otherwise
 151         s" hint.acpi.0.rsdp" getenv
 152         dup -1 = if
 153                 drop false exit
 154         then
 155         2drop
 156         true
 157 ;
 158 
 159 : acpienabled? ( -- flag ) \ Returns TRUE if ACPI is enabled, FALSE otherwise
 160         s" hint.acpi.0.disabled" getenv
 161         dup -1 <> if
 162                 s" 0" compare 0<> if
 163                         false exit
 164                 then
 165         else
 166                 drop
 167         then
 168         true
 169 ;
 170 
 171 : +c! ( N C-ADDR/U K -- C-ADDR/U )
 172         3 pick 3 pick   ( n c-addr/u k -- n c-addr/u k n c-addr )
 173         rot + c!        ( n c-addr/u k n c-addr -- n c-addr/u )
 174         rot drop        ( n c-addr/u -- c-addr/u )
 175 ;
 176 
 177 only forth also menu-namespace definitions
 178 
 179 \ Forth variables
 180 : namespace     ( C-ADDR/U N -- ) also menu-namespace +c! evaluate previous ;
 181 : menukeyN      ( N -- ADDR )   s" menukeyN"       7 namespace ;
 182 : init_stateN   ( N -- ADDR )   s" init_stateN"   10 namespace ;
 183 : toggle_stateN ( N -- ADDR )   s" toggle_stateN" 12 namespace ;
 184 : cycle_stateN  ( N -- ADDR )   s" cycle_stateN"  11 namespace ;
 185 : init_textN    ( N -- C-ADDR ) s" init_textN"     9 namespace ;
 186 
 187 \ Environment variables
 188 : kernel[x]          ( N -- C-ADDR/U )   s" kernel[x]"           7 +c! ;
 189 : menu_init[x]       ( N -- C-ADDR/U )   s" menu_init[x]"       10 +c! ;
 190 : menu_command[x]    ( N -- C-ADDR/U )   s" menu_command[x]"    13 +c! ;
 191 : menu_caption[x]    ( N -- C-ADDR/U )   s" menu_caption[x]"    13 +c! ;
 192 : ansi_caption[x]    ( N -- C-ADDR/U )   s" ansi_caption[x]"    13 +c! ;
 193 : menu_keycode[x]    ( N -- C-ADDR/U )   s" menu_keycode[x]"    13 +c! ;
 194 : toggled_text[x]    ( N -- C-ADDR/U )   s" toggled_text[x]"    13 +c! ;
 195 : toggled_ansi[x]    ( N -- C-ADDR/U )   s" toggled_ansi[x]"    13 +c! ;
 196 : menu_caption[x][y] ( N M -- C-ADDR/U ) s" menu_caption[x][y]" 16 +c! 13 +c! ;
 197 : ansi_caption[x][y] ( N M -- C-ADDR/U ) s" ansi_caption[x][y]" 16 +c! 13 +c! ;
 198 
 199 also menu-infrastructure definitions
 200 
 201 \ This function prints a menu item at menuX (row) and menuY (column), returns
 202 \ the incremental decimal ASCII value associated with the menu item, and
 203 \ increments the cursor position to the next row for the creation of the next
 204 \ menu item. This function is called by the menu-create function. You need not
 205 \ call it directly.
 206 \
 207 : printmenuitem ( menu_item_str -- ascii_keycode )
 208 
 209         loader_color? if [char] ^ escc! then
 210 
 211         menurow dup @ 1+ swap ! ( increment menurow )
 212         menuidx dup @ 1+ swap ! ( increment menuidx )
 213 
 214         \ Calculate the menuitem row position
 215         menurow @ menuY @ +
 216 
 217         \ Position the cursor at the menuitem position
 218         dup menuX @ swap at-xy
 219 
 220         \ Print the value of menuidx
 221         loader_color? dup ( -- bool bool )
 222         if b then
 223         menuidx @ .
 224         if me then
 225 
 226         \ Move the cursor forward 1 column
 227         dup menuX @ 1+ swap at-xy
 228 
 229         menubllt @ emit \ Print the menu bullet using the emit function
 230 
 231         \ Move the cursor to the 3rd column from the current position
 232         \ to allow for a space between the numerical prefix and the
 233         \ text caption
 234         menuX @ 3 + swap at-xy
 235 
 236         \ Print the menu caption (we expect a string to be on the stack
 237         \ prior to invoking this function)
 238         type
 239 
 240         \ Here we will add the ASCII decimal of the numerical prefix
 241         \ to the stack (decimal ASCII for `1' is 49) as a "return value"
 242         menuidx @ 48 +
 243 ;
 244 
 245 : delim? ( C -- BOOL )
 246         dup  32 =               ( c -- c bool )         \ [sp] space
 247         over  9 = or            ( c bool -- c bool )    \ [ht] horizontal tab
 248         over 10 = or            ( c bool -- c bool )    \ [nl] newline
 249         over 13 = or            ( c bool -- c bool )    \ [cr] carriage return
 250         over [char] , = or      ( c bool -- c bool )    \ comma
 251         swap drop               ( c bool -- bool )      \ return boolean
 252 ;
 253 
 254 \ This function parses $kernels into variables that are used by the menu to
 255 \ display which kernel to boot when the [overloaded] `boot' word is interpreted.
 256 \ Used internally by menu-create, you need not (nor should you) call this
 257 \ directly.
 258 \
 259 : parse-kernels ( N -- ) \ kernidx
 260         kernidx ! ( n -- )      \ store provided `x' value
 261         [char] 0 kernmenuidx !  \ initialize `y' value for menu_caption[x][y]
 262 
 263         \ Attempt to get a list of kernels, fall back to sensible default
 264         s" kernels" getenv dup -1 = if
 265                 drop ( cruft )
 266                 s" kernel kernel.old"
 267         then ( -- c-addr/u )
 268 
 269         \ Check to see if the user has altered $kernel by comparing it against
 270         \ $kernel[N] where N is kernel_state (the actively displayed kernel).
 271         s" kernel_state" evaluate @ 48 + s" kernel[N]" 7 +c! getenv
 272         dup -1 <> if
 273                 s" kernel" getenv dup -1 = if
 274                         drop ( cruft ) s" "
 275                 then
 276                 2swap 2over compare 0= if
 277                         2drop FALSE ( skip below conditional )
 278                 else \ User has changed $kernel
 279                         TRUE ( slurp in new value )
 280                 then
 281         else \ We haven't yet parsed $kernels into $kernel[N]
 282                 drop ( getenv cruft )
 283                 s" kernel" getenv dup -1 = if
 284                         drop ( cruft ) s" "
 285                 then
 286                 TRUE ( slurp in initial value )
 287         then ( c-addr/u -- c-addr/u c-addr/u,-1 | 0 )
 288         if \ slurp new value into kerndefault
 289                 kerndefault 1+ 0 2swap strcat swap 1- c!
 290         then
 291 
 292         \ Clear out existing parsed-kernels
 293         kernidx @ [char] 0
 294         begin
 295                 dup kernel[x] unsetenv
 296                 2dup menu_caption[x][y] unsetenv
 297                 2dup ansi_caption[x][y] unsetenv
 298                 1+ dup [char] 8 >
 299         until
 300         2drop
 301 
 302         \ Step through the string until we find the end
 303         begin
 304                 0 kernlen ! \ initialize length of value
 305 
 306                 \ Skip leading whitespace and/or comma delimiters
 307                 begin
 308                         dup 0<> if
 309                                 over c@ delim? ( c-addr/u -- c-addr/u bool )
 310                         else
 311                                 false ( c-addr/u -- c-addr/u bool )
 312                         then
 313                 while
 314                         1- swap 1+ swap ( c-addr/u -- c-addr'/u' )
 315                 repeat
 316                 ( c-addr/u -- c-addr'/u' )
 317 
 318                 dup 0= if \ end of string while eating whitespace
 319                         2drop ( c-addr/u -- )
 320                         kernmenuidx @ [char] 0 <> if \ found at least one
 321                                 exit \ all done
 322                         then
 323 
 324                         \ No entries in $kernels; use $kernel instead
 325                         s" kernel" getenv dup -1 = if
 326                                 drop ( cruft ) s" "
 327                         then ( -- c-addr/u )
 328                         dup kernlen ! \ store entire value length as kernlen
 329                 else
 330                         \ We're still within $kernels parsing toward the end;
 331                         \ find delimiter/end to determine kernlen
 332                         2dup ( c-addr/u -- c-addr/u c-addr/u )
 333                         begin dup 0<> while
 334                                 over c@ delim? if
 335                                         drop 0 ( break ) \ found delimiter
 336                                 else
 337                                         kernlen @ 1+ kernlen ! \ incrememnt
 338                                         1- swap 1+ swap \ c-addr++ u--
 339                                 then
 340                         repeat
 341                         2drop ( c-addr/u c-addr'/u' -- c-addr/u )
 342 
 343                         \ If this is the first entry, compare it to $kernel
 344                         \ If different, then insert $kernel beforehand
 345                         kernmenuidx @ [char] 0 = if
 346                                 over kernlen @ kerndefault count compare if
 347                                         kernelsbuf 0 kerndefault count strcat
 348                                         s" ," strcat 2swap strcat
 349                                         kerndefault count swap drop kernlen !
 350                                 then
 351                         then
 352                 then
 353                 ( c-addr/u -- c-addr'/u' )
 354 
 355                 \ At this point, we should have something on the stack to store
 356                 \ as the next kernel menu option; start assembling variables
 357 
 358                 over kernlen @ ( c-addr/u -- c-addr/u c-addr/u2 )
 359 
 360                 \ Assign first to kernel[x]
 361                 2dup kernmenuidx @ kernel[x] setenv
 362 
 363                 \ Assign second to menu_caption[x][y]
 364                 kerncapbuf 0 s" [K]ernel: " strcat
 365                 2over strcat
 366                 kernidx @ kernmenuidx @ menu_caption[x][y]
 367                 setenv
 368 
 369                 \ Assign third to ansi_caption[x][y]
 370                 kerncapbuf 0 s" @[1mK@[37mernel: " [char] @ escc! strcat
 371                 kernmenuidx @ [char] 0 = if
 372                         s" default/@[32m"
 373                 else
 374                         s" @[34;1m"
 375                 then
 376                 [char] @ escc! strcat
 377                 2over strcat
 378                 s" @[37m" [char] @ escc! strcat
 379                 kernidx @ kernmenuidx @ ansi_caption[x][y]
 380                 setenv
 381 
 382                 2drop ( c-addr/u c-addr/u2 -- c-addr/u )
 383 
 384                 kernmenuidx @ 1+ dup kernmenuidx ! [char] 8 > if
 385                         2drop ( c-addr/u -- ) exit
 386                 then
 387 
 388                 kernlen @ - swap kernlen @ + swap ( c-addr/u -- c-addr'/u' )
 389         again
 390 ;
 391 
 392 \ This function goes through the kernels that were discovered by the
 393 \ parse-kernels function [above], adding " (# of #)" text to the end of each
 394 \ caption.
 395 \
 396 : tag-kernels ( -- )
 397         kernidx @ ( -- x ) dup 0= if exit then
 398         [char] 0 s"  (Y of Z)" ( x -- x y c-addr/u )
 399         kernmenuidx @ -rot 7 +c! \ Replace 'Z' with number of kernels parsed
 400         begin
 401                 2 pick 1+ -rot 2 +c! \ Replace 'Y' with current ASCII num
 402 
 403                 2over menu_caption[x][y] getenv dup -1 <> if
 404                         2dup + 1- c@ [char] ) = if
 405                                 2drop \ Already tagged
 406                         else
 407                                 kerncapbuf 0 2swap strcat
 408                                 2over strcat
 409                                 5 pick 5 pick menu_caption[x][y] setenv
 410                         then
 411                 else
 412                         drop ( getenv cruft )
 413                 then
 414 
 415                 2over ansi_caption[x][y] getenv dup -1 <> if
 416                         2dup + 1- c@ [char] ) = if
 417                                 2drop \ Already tagged
 418                         else
 419                                 kerncapbuf 0 2swap strcat
 420                                 2over strcat
 421                                 5 pick 5 pick ansi_caption[x][y] setenv
 422                         then
 423                 else
 424                         drop ( getenv cruft )
 425                 then
 426 
 427                 rot 1+ dup [char] 8 > if
 428                         -rot 2drop TRUE ( break )
 429                 else
 430                         -rot FALSE
 431                 then
 432         until
 433         2drop ( x y -- )
 434 ;
 435 
 436 \ Illumos kernel acpi-user-options has following values:
 437 \ default:      0 - system will enable acpi based on bios date
 438 \ on:           1 - acpi is set on
 439 \ off:          2 - acpi is set off
 440 \ madt:         4 - use only MADT
 441 \ legacy:       8 - use legacy mode
 442 
 443 : acpi-captions ( N -- )
 444   \ first entry
 445   dup s" [A]CPI.............. default" rot 48 menu_caption[x][y] setenv
 446   dup s" ^[1mA^[mCPI.............. ^[32;7mdefault^[m" rot 48 ansi_caption[x][y] setenv
 447 
 448   dup s" [A]CPI.............. On" rot 49 menu_caption[x][y] setenv
 449   dup s" ^[1mA^[mCPI.............. ^[34;1mOn^[m" rot 49 ansi_caption[x][y] setenv
 450 
 451   dup s" [A]CPI.............. Off" rot 50 menu_caption[x][y] setenv
 452   dup s" ^[1mA^[mCPI.............. ^[34;1mOff^[m" rot 50 ansi_caption[x][y] setenv
 453 
 454   dup s" [A]CPI.............. MADT" rot 51 menu_caption[x][y] setenv
 455   dup s" ^[1mA^[mCPI.............. ^[34;1mMADT^[m" rot 51 ansi_caption[x][y] setenv
 456 
 457   dup s" [A]CPI.............. Legacy" rot 52 menu_caption[x][y] setenv
 458   s" ^[1mA^[mCPI.............. ^[34;1mLegacy^[m" rot 52 ansi_caption[x][y] setenv
 459 ;
 460 
 461 \ Illumos console has following values:
 462 \ text, ttya, ttyb, ttyc, ttyd
 463 
 464 : osconsole-captions ( N -- )
 465   \ first entry
 466   dup s" Os[C]onsole............ text" rot 48 menu_caption[x][y] setenv
 467   dup s" Os^[1mC^[monsole............ ^[32;7mtext^[m" rot 48 ansi_caption[x][y] setenv
 468 
 469   dup s" Os[C]onsole............ ttya" rot 49 menu_caption[x][y] setenv
 470   dup s" Os^[1mC^[monsole............ ^[34;1mttya^[m" rot 49 ansi_caption[x][y] setenv
 471 
 472   dup s" Os[C]onsole............ ttyb" rot 50 menu_caption[x][y] setenv
 473   dup s" Os^[1mC^[monsole............ ^[34;1mttyb^[m" rot 50 ansi_caption[x][y] setenv
 474 
 475   dup s" Os[C]onsole............ ttyc" rot 51 menu_caption[x][y] setenv
 476   dup s" Os^[1mC^[monsole............ ^[34;1mttyc^[m" rot 51 ansi_caption[x][y] setenv
 477 
 478   dup s" Os[C]onsole............ ttyd" rot 52 menu_caption[x][y] setenv
 479   s" Os^[1mC^[monsole............ ^[34;1mttyd^[m" rot 52 ansi_caption[x][y] setenv
 480 ;
 481 
 482 \ This function creates the list of menu items. This function is called by the
 483 \ menu-display function. You need not call it directly.
 484 \
 485 : menu-create ( -- )
 486 
 487         \ Print the frame caption at (x,y)
 488         s" loader_menu_title" getenv dup -1 = if
 489                 drop s" Welcome to illumos"
 490         then
 491         TRUE ( use default alignment )
 492         s" loader_menu_title_align" getenv dup -1 <> if
 493                 2dup s" left" compare-insensitive 0= if ( 1 )
 494                         2drop ( c-addr/u ) drop ( bool )
 495                         menuX @ menuY @ 1-
 496                         FALSE ( don't use default alignment )
 497                 else ( 1 ) 2dup s" right" compare-insensitive 0= if ( 2 )
 498                         2drop ( c-addr/u ) drop ( bool )
 499                         menuX @ 42 + 4 - over - menuY @ 1-
 500                         FALSE ( don't use default alignment )
 501                 else ( 2 ) 2drop ( c-addr/u ) then ( 1 ) then
 502         else
 503                 drop ( getenv cruft )
 504         then
 505         if ( use default center alignement? )
 506                 menuX @ 19 + over 2 / - menuY @ 1-
 507         then
 508         at-xy type
 509 
 510         \ If $menu_init is set, evaluate it (allowing for whole menus to be
 511         \ constructed dynamically -- as this function could conceivably set
 512         \ the remaining environment variables to construct the menu entirely).
 513         \
 514         s" menu_init" getenv dup -1 <> if
 515                 evaluate
 516         else
 517                 drop
 518         then
 519 
 520         \ Print our menu options with respective key/variable associations.
 521         \ `printmenuitem' ends by adding the decimal ASCII value for the
 522         \ numerical prefix to the stack. We store the value left on the stack
 523         \ to the key binding variable for later testing against a character
 524         \ captured by the `getkey' function.
 525 
 526         \ Note that any menu item beyond 9 will have a numerical prefix on the
 527         \ screen consisting of the first digit (ie. 1 for the tenth menu item)
 528         \ and the key required to activate that menu item will be the decimal
 529         \ ASCII of 48 plus the menu item (ie. 58 for the tenth item, aka. `:')
 530         \ which is misleading and not desirable.
 531         \
 532         \ Thus, we do not allow more than 8 configurable items on the menu
 533         \ (with "Reboot" as the optional ninth and highest numbered item).
 534 
 535         \
 536         \ Initialize the OsConsole option status.
 537         \
 538         0 menuosconsole !
 539         s" menu_osconsole" getenv -1 <> if
 540                 c@ dup 48 > over 57 < and if ( '1' <= c1 <= '8' )
 541                         dup menuosconsole !
 542                         dup osconsole-captions
 543 
 544                         s" init_osconsole" evaluate
 545 
 546                         \ Get the current cycle state (entry to use)
 547                         s" osconsole_state" evaluate @ 48 + ( n -- n y )
 548 
 549                         \ Set the current non-ANSI caption
 550                         2dup swap dup ( n y -- n y y n n )
 551                         s" set menu_caption[x]=$menu_caption[x][y]"
 552                         17 +c! 34 +c! 37 +c! evaluate
 553                         ( n y y n n c-addr/u -- n y  )
 554 
 555                         \ Set the current ANSI caption
 556                         2dup swap dup ( n y -- n y y n n )
 557                         s" set ansi_caption[x]=$ansi_caption[x][y]"
 558                         17 +c! 34 +c! 37 +c! evaluate
 559                         ( n y y n n c-addr/u -- n y )
 560 
 561                         \ Initialize cycle state from stored value
 562                         48 - ( n y -- n k )
 563                         s" init_cyclestate" evaluate ( n k -- n )
 564 
 565                         \ Set $os_console
 566                         s" activate_osconsole" evaluate ( n -- n )
 567                 then
 568                 drop
 569         then
 570 
 571         \
 572         \ Initialize the ACPI option status.
 573         \
 574         0 menuacpi !
 575         s" menu_acpi" getenv -1 <> if
 576                 c@ dup 48 > over 57 < and if ( '1' <= c1 <= '8' )
 577                         dup menuacpi !
 578                         dup acpi-captions
 579 
 580                         s" init_acpi" evaluate
 581 
 582                         \ Get the current cycle state (entry to use)
 583                         s" acpi_state" evaluate @ 48 + ( n -- n y )
 584 
 585                         \ Set the current non-ANSI caption
 586                         2dup swap dup ( n y -- n y y n n )
 587                         s" set menu_caption[x]=$menu_caption[x][y]"
 588                         17 +c! 34 +c! 37 +c! evaluate
 589                         ( n y y n n c-addr/u -- n y  )
 590 
 591                         \ Set the current ANSI caption
 592                         2dup swap dup ( n y -- n y y n n )
 593                         s" set ansi_caption[x]=$ansi_caption[x][y]"
 594                         17 +c! 34 +c! 37 +c! evaluate
 595                         ( n y y n n c-addr/u -- n y )
 596 
 597                         \ Initialize cycle state from stored value
 598                         48 - ( n y -- n k )
 599                         s" init_cyclestate" evaluate ( n k -- n )
 600 
 601                         \ Set $acpi-user-options
 602                         s" activate_acpi" evaluate ( n -- n )
 603                 then
 604                 drop
 605         then
 606 
 607         \
 608         \ Initialize kernel captions after parsing $kernels
 609         \
 610         0 menukernel !
 611         s" menu_kernel" getenv -1 <> if
 612                 c@ dup 48 > over 57 < and if ( '1' <= c1 <= '8' )
 613                         dup menukernel !
 614                         dup parse-kernels tag-kernels
 615 
 616                         \ Get the current cycle state (entry to use)
 617                         s" kernel_state" evaluate @ 48 + ( n -- n y )
 618 
 619                         \ If state is invalid, reset
 620                         dup kernmenuidx @ 1- > if
 621                                 drop [char] 0 ( n y -- n 48 )
 622                                 0 s" kernel_state" evaluate !
 623                                 over s" init_kernel" evaluate drop
 624                         then
 625 
 626                         \ Set the current non-ANSI caption
 627                         2dup swap dup ( n y -- n y y n n )
 628                         s" set menu_caption[x]=$menu_caption[x][y]"
 629                         17 +c! 34 +c! 37 +c! evaluate
 630                         ( n y y n n c-addr/u -- n y  )
 631 
 632                         \ Set the current ANSI caption
 633                         2dup swap dup ( n y -- n y y n n )
 634                         s" set ansi_caption[x]=$ansi_caption[x][y]"
 635                         17 +c! 34 +c! 37 +c! evaluate
 636                         ( n y y n n c-addr/u -- n y )
 637 
 638                         \ Initialize cycle state from stored value
 639                         48 - ( n y -- n k )
 640                         s" init_cyclestate" evaluate ( n k -- n )
 641 
 642                         \ Set $kernel to $kernel[y]
 643                         s" activate_kernel" evaluate ( n -- n )
 644                 then
 645                 drop
 646         then
 647 
 648         \
 649         \ Initialize the menu_options visual separator.
 650         \
 651         0 menuoptions !
 652         s" menu_options" getenv -1 <> if
 653                 c@ dup 48 > over 57 < and if ( '1' <= c1 <= '8' )
 654                         menuoptions !
 655                 else
 656                         drop
 657                 then
 658         then
 659 
 660         \ Initialize "Reboot" menu state variable (prevents double-entry)
 661         false menurebootadded !
 662 
 663         menu_start
 664         1- menuidx !    \ Initialize the starting index for the menu
 665         0 menurow !     \ Initialize the starting position for the menu
 666 
 667         49 \ Iterator start (loop range 49 to 56; ASCII '1' to '8')
 668         begin
 669                 \ If the "Options:" separator, print it.
 670                 dup menuoptions @ = if
 671                         \ Optionally add a reboot option to the menu
 672                         s" menu_reboot" getenv -1 <> if
 673                                 drop
 674                                 s" Reboot" printmenuitem menureboot !
 675                                 true menurebootadded !
 676                         then
 677 
 678                         menuX @
 679                         menurow @ 2 + menurow !
 680                         menurow @ menuY @ +
 681                         at-xy
 682                         s" menu_optionstext" getenv dup -1 <> if
 683                                 type
 684                         else
 685                                 drop ." Options:"
 686                         then
 687                 then
 688 
 689                 \ make sure we have not already initialized this item
 690                 dup init_stateN dup @ 0= if
 691                         1 swap !
 692 
 693                         \ If this menuitem has an initializer, run it
 694                         dup menu_init[x]
 695                         getenv dup -1 <> if
 696                                 evaluate
 697                         else
 698                                 drop
 699                         then
 700                 else
 701                         drop
 702                 then
 703 
 704                 dup
 705                 loader_color? if
 706                         ansi_caption[x]
 707                 else
 708                         menu_caption[x]
 709                 then
 710 
 711                 dup -1 <> if
 712                         \ test for environment variable
 713                         getenv dup -1 <> if
 714                                 printmenuitem ( c-addr/u -- n )
 715                                 dup menukeyN !
 716                         else
 717                                 drop
 718                         then
 719                 else
 720                         drop
 721                 then
 722 
 723                 1+ dup 56 > \ add 1 to iterator, continue if less than 57
 724         until
 725         drop \ iterator
 726 
 727         \ Optionally add a reboot option to the menu
 728         menurebootadded @ true <> if
 729                 s" menu_reboot" getenv -1 <> if
 730                         drop       \ no need for the value
 731                         s" Reboot" \ menu caption (required by printmenuitem)
 732 
 733                         printmenuitem
 734                         menureboot !
 735                 else
 736                         0 menureboot !
 737                 then
 738         then
 739 ;
 740 
 741 \ Takes a single integer on the stack and updates the timeout display. The
 742 \ integer must be between 0 and 9 (we will only update a single digit in the
 743 \ source message).
 744 \
 745 : menu-timeout-update ( N -- )
 746 
 747         \ Enforce minimum/maximum
 748         dup 9 > if drop 9 then
 749         dup 0 < if drop 0 then
 750 
 751         s" Autoboot in N seconds. [Space] to pause" ( n -- n c-addr/u )
 752 
 753         2 pick 0> if
 754                 rot 48 + -rot ( n c-addr/u -- n' c-addr/u ) \ convert to ASCII
 755                 12 +c!        ( n' c-addr/u -- c-addr/u )   \ replace 'N' above
 756 
 757                 menu_timeout_x @ menu_timeout_y @ at-xy \ position cursor
 758                 type ( c-addr/u -- ) \ print message
 759         else
 760                 menu_timeout_x @ menu_timeout_y @ at-xy \ position cursor
 761                 spaces ( n c-addr/u -- n c-addr ) \ erase message
 762                 2drop ( n c-addr -- )
 763         then
 764 
 765         at-bl
 766 ;
 767 
 768 \ This function blocks program flow (loops forever) until a key is pressed.
 769 \ The key that was pressed is added to the top of the stack in the form of its
 770 \ decimal ASCII representation. This function is called by the menu-display
 771 \ function. You need not call it directly.
 772 \ note, the esc sequences will be dropped, this needs to be changed if
 773 \ menu is built based on arrow keys.
 774 \
 775 : getkey ( -- ascii_keycode )
 776 
 777         begin \ loop forever
 778 
 779                 menu_timeout_enabled @ 1 = if
 780                         ( -- )
 781                         seconds ( get current time: -- N )
 782                         dup menu_time @ <> if ( has time elapsed?: N N N -- N )
 783 
 784                                 \ At least 1 second has elapsed since last loop
 785                                 \ so we will decrement our "timeout" (really a
 786                                 \ counter, insuring that we do not proceed too
 787                                 \ fast) and update our timeout display.
 788 
 789                                 menu_time ! ( update time record: N -- )
 790                                 menu_timeout @ ( "time" remaining: -- N )
 791                                 dup 0> if ( greater than 0?: N N 0 -- N )
 792                                         1- ( decrement counter: N -- N )
 793                                         dup menu_timeout !
 794                                                 ( re-assign: N N Addr -- N )
 795                                 then
 796                                 ( -- N )
 797 
 798                                 dup 0= swap 0< or if ( N <= 0?: N N -- )
 799                                         \ halt the timer
 800                                         0 menu_timeout ! ( 0 Addr -- )
 801                                         0 menu_timeout_enabled ! ( 0 Addr -- )
 802                                 then
 803 
 804                                 \ update the timer display ( N -- )
 805                                 menu_timeout @ menu-timeout-update
 806 
 807                                 menu_timeout @ 0= if
 808                                         \ We've reached the end of the timeout
 809                                         \ (user did not cancel by pressing ANY
 810                                         \ key)
 811 
 812                                         s" menu_timeout_command"  getenv dup
 813                                         -1 = if
 814                                                 drop \ clean-up
 815                                         else
 816                                                 evaluate
 817                                         then
 818                                 then
 819 
 820                         else ( -- N )
 821                                 \ No [detectable] time has elapsed (in seconds)
 822                                 drop ( N -- )
 823                         then
 824                         ( -- )
 825                 then
 826 
 827                 key? if \ Was a key pressed? (see loader(8))
 828 
 829                         \ An actual key was pressed (if the timeout is running,
 830                         \ kill it regardless of which key was pressed)
 831                         menu_timeout @ 0<> if
 832                                 0 menu_timeout !
 833                                 0 menu_timeout_enabled !
 834 
 835                                 \ clear screen of timeout message
 836                                 0 menu-timeout-update
 837                         then
 838 
 839                         \ get the key that was pressed and exit (if we
 840                         \ get a non-zero ASCII code)
 841                         key dup 0<> if
 842                                 dup 0x1b = if
 843                                         key? if ( is it sequence? )
 844                                                 drop
 845                                                 begin
 846                                                         key?
 847                                                 while
 848                                                         key drop
 849                                                 repeat
 850                                         else
 851                                                 exit
 852                                         then
 853                                 else
 854                                         exit
 855                                 then
 856                         else
 857                                 drop
 858                         then
 859                 then
 860                 50 ms \ sleep for 50 milliseconds (see loader(8))
 861 
 862         again
 863 ;
 864 
 865 : menu-erase ( -- ) \ Erases menu and resets positioning variable to position 1.
 866 
 867         \ Clear the screen area associated with the interactive menu
 868         menuX @ menuY @
 869         2dup at-xy 38 spaces 1+         2dup at-xy 38 spaces 1+
 870         2dup at-xy 38 spaces 1+         2dup at-xy 38 spaces 1+
 871         2dup at-xy 38 spaces 1+         2dup at-xy 38 spaces 1+
 872         2dup at-xy 38 spaces 1+         2dup at-xy 38 spaces 1+
 873         2dup at-xy 38 spaces 1+         2dup at-xy 38 spaces 1+
 874         2dup at-xy 38 spaces 1+         2dup at-xy 38 spaces
 875         2drop
 876 
 877         \ Reset the starting index and position for the menu
 878         menu_start 1- menuidx !
 879         0 menurow !
 880 ;
 881 
 882 only forth
 883 also menu-infrastructure
 884 also menu-namespace
 885 also menu-command-helpers definitions
 886 
 887 : toggle_menuitem ( N -- N ) \ toggles caption text and internal menuitem state
 888 
 889         \ ASCII numeral equal to user-selected menu item must be on the stack.
 890         \ We do not modify the stack, so the ASCII numeral is left on top.
 891 
 892         dup init_textN c@ 0= if
 893                 \ NOTE: no need to check toggle_stateN since the first time we
 894                 \ are called, we will populate init_textN. Further, we don't
 895                 \ need to test whether menu_caption[x] (ansi_caption[x] when
 896                 \ loader_color?=1) is available since we would not have been
 897                 \ called if the caption was NULL.
 898 
 899                 \ base name of environment variable
 900                 dup ( n -- n n ) \ key pressed
 901                 loader_color? if
 902                         ansi_caption[x]
 903                 else
 904                         menu_caption[x]
 905                 then
 906                 getenv dup -1 <> if
 907 
 908                         2 pick ( n c-addr/u -- n c-addr/u n )
 909                         init_textN ( n c-addr/u n -- n c-addr/u c-addr )
 910 
 911                         \ now we have the buffer c-addr on top
 912                         \ ( followed by c-addr/u of current caption )
 913 
 914                         \ Copy the current caption into our buffer
 915                         2dup c! -rot \ store strlen at first byte
 916                         begin
 917                                 rot 1+    \ bring alt addr to top and increment
 918                                 -rot -rot \ bring buffer addr to top
 919                                 2dup c@ swap c! \ copy current character
 920                                 1+     \ increment buffer addr
 921                                 rot 1- \ bring buffer len to top and decrement
 922                                 dup 0= \ exit loop if buffer len is zero
 923                         until
 924                         2drop \ buffer len/addr
 925                         drop  \ alt addr
 926 
 927                 else
 928                         drop
 929                 then
 930         then
 931 
 932         \ Now we are certain to have init_textN populated with the initial
 933         \ value of menu_caption[x] (ansi_caption[x] with loader_color enabled).
 934         \ We can now use init_textN as the untoggled caption and
 935         \ toggled_text[x] (toggled_ansi[x] with loader_color enabled) as the
 936         \ toggled caption and store the appropriate value into menu_caption[x]
 937         \ (again, ansi_caption[x] with loader_color enabled). Last, we'll
 938         \ negate the toggled state so that we reverse the flow on subsequent
 939         \ calls.
 940 
 941         dup toggle_stateN @ 0= if
 942                 \ state is OFF, toggle to ON
 943 
 944                 dup ( n -- n n ) \ key pressed
 945                 loader_color? if
 946                         toggled_ansi[x]
 947                 else
 948                         toggled_text[x]
 949                 then
 950                 getenv dup -1 <> if
 951                         \ Assign toggled text to menu caption
 952                         2 pick ( n c-addr/u -- n c-addr/u n ) \ key pressed
 953                         loader_color? if
 954                                 ansi_caption[x]
 955                         else
 956                                 menu_caption[x]
 957                         then
 958                         setenv
 959                 else
 960                         \ No toggled text, keep the same caption
 961                         drop ( n -1 -- n ) \ getenv cruft
 962                 then
 963 
 964                 true \ new value of toggle state var (to be stored later)
 965         else
 966                 \ state is ON, toggle to OFF
 967 
 968                 dup init_textN count ( n -- n c-addr/u )
 969 
 970                 \ Assign init_textN text to menu caption
 971                 2 pick ( n c-addr/u -- n c-addr/u n ) \ key pressed
 972                 loader_color? if
 973                         ansi_caption[x]
 974                 else
 975                         menu_caption[x]
 976                 then
 977                 setenv
 978 
 979                 false \ new value of toggle state var (to be stored below)
 980         then
 981 
 982         \ now we'll store the new toggle state (on top of stack)
 983         over toggle_stateN !
 984 ;
 985 
 986 : cycle_menuitem ( N -- N ) \ cycles through array of choices for a menuitem
 987 
 988         \ ASCII numeral equal to user-selected menu item must be on the stack.
 989         \ We do not modify the stack, so the ASCII numeral is left on top.
 990 
 991         dup cycle_stateN dup @ 1+ \ get value and increment
 992 
 993         \ Before assigning the (incremented) value back to the pointer,
 994         \ let's test for the existence of this particular array element.
 995         \ If the element exists, we'll store index value and move on.
 996         \ Otherwise, we'll loop around to zero and store that.
 997 
 998         dup 48 + ( n addr k -- n addr k k' )
 999                  \ duplicate array index and convert to ASCII numeral
1000 
1001         3 pick swap ( n addr k k' -- n addr k n k' ) \ (n,k') as (x,y)
1002         loader_color? if
1003                 ansi_caption[x][y]
1004         else
1005                 menu_caption[x][y]
1006         then
1007         ( n addr k n k' -- n addr k c-addr/u )
1008 
1009         \ Now test for the existence of our incremented array index in the
1010         \ form of $menu_caption[x][y] ($ansi_caption[x][y] with loader_color
1011         \ enabled) as set in loader.rc(5), et. al.
1012 
1013         getenv dup -1 = if
1014                 \ No caption set for this array index. Loop back to zero.
1015 
1016                 drop ( n addr k -1 -- n addr k ) \ getenv cruft
1017                 drop 0 ( n addr k -- n addr 0 )  \ new value to store later
1018 
1019                 2 pick [char] 0 ( n addr 0 -- n addr 0 n 48 ) \ (n,48) as (x,y)
1020                 loader_color? if
1021                         ansi_caption[x][y]
1022                 else
1023                         menu_caption[x][y]
1024                 then
1025                 ( n addr 0 n 48 -- n addr 0 c-addr/u )
1026                 getenv dup -1 = if
1027                         \ Highly unlikely to occur, but to ensure things move
1028                         \ along smoothly, allocate a temporary NULL string
1029                         drop ( cruft ) s" "
1030                 then
1031         then
1032 
1033         \ At this point, we should have the following on the stack (in order,
1034         \ from bottom to top):
1035         \
1036         \    n        - Ascii numeral representing the menu choice (inherited)
1037         \    addr     - address of our internal cycle_stateN variable
1038         \    k        - zero-based number we intend to store to the above
1039         \    c-addr/u - string value we intend to store to menu_caption[x]
1040         \               (or ansi_caption[x] with loader_color enabled)
1041         \
1042         \ Let's perform what we need to with the above.
1043 
1044         \ Assign array value text to menu caption
1045         4 pick ( n addr k c-addr/u -- n addr k c-addr/u n )
1046         loader_color? if
1047                 ansi_caption[x]
1048         else
1049                 menu_caption[x]
1050         then
1051         setenv
1052 
1053         swap ! ( n addr k -- n ) \ update array state variable
1054 ;
1055 
1056 only forth definitions also menu-infrastructure
1057 
1058 \ Erase and redraw the menu. Useful if you change a caption and want to
1059 \ update the menu to reflect the new value.
1060 \
1061 : menu-redraw ( -- )
1062         menu-erase
1063         menu-create
1064 ;
1065 
1066 \ This function initializes the menu. Call this from your `loader.rc' file
1067 \ before calling any other menu-related functions.
1068 \
1069 : menu-init ( -- )
1070         menu_start
1071         1- menuidx !    \ Initialize the starting index for the menu
1072         0 menurow !     \ Initialize the starting position for the menu
1073 
1074         \ Assign configuration values
1075         s" loader_menu_y" getenv dup -1 = if
1076                 drop \ no custom row position
1077                 menu_default_y
1078         else
1079                 \ make sure custom position is a number
1080                 ?number 0= if
1081                         menu_default_y \ or use default
1082                 then
1083         then
1084         menuY !
1085         s" loader_menu_x" getenv dup -1 = if
1086                 drop \ no custom column position
1087                 menu_default_x
1088         else
1089                 \ make sure custom position is a number
1090                 ?number 0= if
1091                         menu_default_x \ or use default
1092                 then
1093         then
1094         menuX !
1095 
1096         \ Interpret a custom frame type for the menu
1097         TRUE ( draw a box? default yes, but might be altered below )
1098         s" loader_menu_frame" getenv dup -1 = if ( 1 )
1099                 drop \ no custom frame type
1100         else ( 1 )  2dup s" single" compare-insensitive 0= if ( 2 )
1101                 f_single ( see frames.4th )
1102         else ( 2 )  2dup s" double" compare-insensitive 0= if ( 3 )
1103                 f_double ( see frames.4th )
1104         else ( 3 ) s" none" compare-insensitive 0= if ( 4 )
1105                 drop FALSE \ don't draw a box
1106         ( 4 ) then ( 3 ) then ( 2 )  then ( 1 ) then
1107         if
1108                 42 13 menuX @ 3 - menuY @ 1- box \ Draw frame (w,h,x,y)
1109         then
1110 
1111         at-bl
1112 ;
1113 
1114 also menu-namespace
1115 
1116 \ Main function. Call this from your `loader.rc' file.
1117 \
1118 : menu-display ( -- )
1119 
1120         0 menu_timeout_enabled ! \ start with automatic timeout disabled
1121 
1122         \ check indication that automatic execution after delay is requested
1123         s" menu_timeout_command" getenv -1 <> if ( Addr C -1 -- | Addr )
1124                 drop ( just testing existence right now: Addr -- )
1125 
1126                 \ initialize state variables
1127                 seconds menu_time ! ( store the time we started )
1128                 1 menu_timeout_enabled ! ( enable automatic timeout )
1129 
1130                 \ read custom time-duration (if set)
1131                 s" autoboot_delay" getenv dup -1 = if
1132                         drop \ no custom duration (remove dup'd bunk -1)
1133                         menu_timeout_default \ use default setting
1134                 else
1135                         2dup ?number 0= if ( if not a number )
1136                                 \ disable timeout if "NO", else use default
1137                                 s" NO" compare-insensitive 0= if
1138                                         0 menu_timeout_enabled !
1139                                         0 ( assigned to menu_timeout below )
1140                                 else
1141                                         menu_timeout_default
1142                                 then
1143                         else
1144                                 -rot 2drop
1145 
1146                                 \ boot immediately if less than zero
1147                                 dup 0< if
1148                                         drop
1149                                         menu-create
1150                                         at-bl
1151                                         0 boot
1152                                 then
1153                         then
1154                 then
1155                 menu_timeout ! ( store value on stack from above )
1156 
1157                 menu_timeout_enabled @ 1 = if
1158                         \ read custom column position (if set)
1159                         s" loader_menu_timeout_x" getenv dup -1 = if
1160                                 drop \ no custom column position
1161                                 menu_timeout_default_x \ use default setting
1162                         else
1163                                 \ make sure custom position is a number
1164                                 ?number 0= if
1165                                         menu_timeout_default_x \ or use default
1166                                 then
1167                         then
1168                         menu_timeout_x ! ( store value on stack from above )
1169 
1170                         \ read custom row position (if set)
1171                         s" loader_menu_timeout_y" getenv dup -1 = if
1172                                 drop \ no custom row position
1173                                 menu_timeout_default_y \ use default setting
1174                         else
1175                                 \ make sure custom position is a number
1176                                 ?number 0= if
1177                                         menu_timeout_default_y \ or use default
1178                                 then
1179                         then
1180                         menu_timeout_y ! ( store value on stack from above )
1181                 then
1182         then
1183 
1184         menu-create
1185 
1186         begin \ Loop forever
1187 
1188                 at-bl
1189                 getkey     \ Block here, waiting for a key to be pressed
1190 
1191                 dup -1 = if
1192                         drop exit \ Caught abort (abnormal return)
1193                 then
1194 
1195                 \ Boot if the user pressed Enter/Ctrl-M (13) or
1196                 \ Ctrl-Enter/Ctrl-J (10)
1197                 dup over 13 = swap 10 = or if
1198                         drop ( no longer needed )
1199                         s" boot" evaluate
1200                         exit ( pedantic; never reached )
1201                 then
1202 
1203                 dup menureboot @ = if 0 reboot then
1204 
1205                 \ Evaluate the decimal ASCII value against known menu item
1206                 \ key associations and act accordingly
1207 
1208                 49 \ Iterator start (loop range 49 to 56; ASCII '1' to '8')
1209                 begin
1210                         dup menukeyN @
1211                         rot tuck = if
1212 
1213                                 \ Adjust for missing ACPI menuitem on non-i386
1214 \                               arch-i386? true <> menuacpi @ 0<> and if
1215 \                                       menuacpi @ over 2dup < -rot = or
1216 \                                       over 58 < and if
1217 \                                       ( key >= menuacpi && key < 58: N -- N )
1218 \                                               1+
1219 \                                       then
1220 \                               then
1221 
1222                                 \ Test for the environment variable
1223                                 dup menu_command[x]
1224                                 getenv dup -1 <> if
1225                                         \ Execute the stored procedure
1226                                         evaluate
1227 
1228                                         \ We expect there to be a non-zero
1229                                         \  value left on the stack after
1230                                         \ executing the stored procedure.
1231                                         \ If so, continue to run, else exit.
1232 
1233                                         0= if
1234                                                 drop \ key pressed
1235                                                 drop \ loop iterator
1236                                                 exit
1237                                         else
1238                                                 swap \ need iterator on top
1239                                         then
1240                                 then
1241 
1242                                 \ Re-adjust for missing ACPI menuitem
1243 \                               arch-i386? true <> menuacpi @ 0<> and if
1244 \                                       swap
1245 \                                       menuacpi @ 1+ over 2dup < -rot = or
1246 \                                       over 59 < and if
1247 \                                               1-
1248 \                                       then
1249 \                                       swap
1250 \                               then
1251                         else
1252                                 swap \ need iterator on top
1253                         then
1254 
1255                         \
1256                         \ Check for menu keycode shortcut(s)
1257                         \
1258                         dup menu_keycode[x]
1259                         getenv dup -1 = if
1260                                 drop
1261                         else
1262                                 ?number 0<> if
1263                                         rot tuck = if
1264                                                 swap
1265                                                 dup menu_command[x]
1266                                                 getenv dup -1 <> if
1267                                                         evaluate
1268                                                         0= if
1269                                                                 2drop
1270                                                                 exit
1271                                                         then
1272                                                 else
1273                                                         drop
1274                                                 then
1275                                         else
1276                                                 swap
1277                                         then
1278                                 then
1279                         then
1280 
1281                         1+ dup 56 > \ increment iterator
1282                                     \ continue if less than 57
1283                 until
1284                 drop \ loop iterator
1285                 drop \ key pressed
1286 
1287         again   \ Non-operational key was pressed; repeat
1288 ;
1289 
1290 \ This function unsets all the possible environment variables associated with
1291 \ creating the interactive menu.
1292 \
1293 : menu-unset ( -- )
1294 
1295         49 \ Iterator start (loop range 49 to 56; ASCII '1' to '8')
1296         begin
1297                 dup menu_init[x]    unsetenv    \ menu initializer
1298                 dup menu_command[x] unsetenv    \ menu command
1299                 dup menu_caption[x] unsetenv    \ menu caption
1300                 dup ansi_caption[x] unsetenv    \ ANSI caption
1301                 dup menu_keycode[x] unsetenv    \ menu keycode
1302                 dup toggled_text[x] unsetenv    \ toggle_menuitem caption
1303                 dup toggled_ansi[x] unsetenv    \ toggle_menuitem ANSI caption
1304 
1305                 48 \ Iterator start (inner range 48 to 57; ASCII '0' to '9')
1306                 begin
1307                         \ cycle_menuitem caption and ANSI caption
1308                         2dup menu_caption[x][y] unsetenv
1309                         2dup ansi_caption[x][y] unsetenv
1310                         1+ dup 57 >
1311                 until
1312                 drop \ inner iterator
1313 
1314                 0 over menukeyN      !  \ used by menu-create, menu-display
1315                 0 over init_stateN   !  \ used by menu-create
1316                 0 over toggle_stateN !  \ used by toggle_menuitem
1317                 0 over init_textN   c!  \ used by toggle_menuitem
1318                 0 over cycle_stateN  !  \ used by cycle_menuitem
1319 
1320                 1+ dup 56 >  \ increment, continue if less than 57
1321         until
1322         drop \ iterator
1323 
1324         s" menu_timeout_command" unsetenv       \ menu timeout command
1325         s" menu_reboot"          unsetenv       \ Reboot menu option flag
1326         s" menu_acpi"            unsetenv       \ ACPI menu option flag
1327         s" menu_osconsole"       unsetenv       \ osconsole menu option flag
1328         s" menu_kernel"          unsetenv       \ Kernel menu option flag
1329         s" menu_options"         unsetenv       \ Options separator flag
1330         s" menu_optionstext"     unsetenv       \ separator display text
1331         s" menu_init"            unsetenv       \ menu initializer
1332 
1333         0 menureboot !
1334         0 menuacpi !
1335         0 menuosconsole !
1336         0 menuoptions !
1337 ;
1338 
1339 only forth definitions also menu-infrastructure
1340 
1341 \ This function both unsets menu variables and visually erases the menu area
1342 \ in-preparation for another menu.
1343 \
1344 : menu-clear ( -- )
1345         menu-unset
1346         menu-erase
1347 ;
1348 
1349 bullet menubllt !
1350 
1351 also menu-namespace
1352 
1353 \ Initialize our menu initialization state variables
1354 0 init_state1 !
1355 0 init_state2 !
1356 0 init_state3 !
1357 0 init_state4 !
1358 0 init_state5 !
1359 0 init_state6 !
1360 0 init_state7 !
1361 0 init_state8 !
1362 
1363 \ Initialize our boolean state variables
1364 0 toggle_state1 !
1365 0 toggle_state2 !
1366 0 toggle_state3 !
1367 0 toggle_state4 !
1368 0 toggle_state5 !
1369 0 toggle_state6 !
1370 0 toggle_state7 !
1371 0 toggle_state8 !
1372 
1373 \ Initialize our array state variables
1374 0 cycle_state1 !
1375 0 cycle_state2 !
1376 0 cycle_state3 !
1377 0 cycle_state4 !
1378 0 cycle_state5 !
1379 0 cycle_state6 !
1380 0 cycle_state7 !
1381 0 cycle_state8 !
1382 
1383 \ Initialize string containers
1384 0 init_text1 c!
1385 0 init_text2 c!
1386 0 init_text3 c!
1387 0 init_text4 c!
1388 0 init_text5 c!
1389 0 init_text6 c!
1390 0 init_text7 c!
1391 0 init_text8 c!
1392 
1393 only forth definitions