Chameleon

Chameleon Svn Source Tree

Root/branches/zenith432/i386/boot2/options.c

1/*␊
2 * Copyright (c) 1999-2004 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * Portions Copyright (c) 1999-2004 Apple Computer, Inc. All Rights␊
7 * Reserved. This file contains Original Code and/or Modifications of␊
8 * Original Code as defined in and that are subject to the Apple Public␊
9 * Source License Version 2.0 (the "License"). You may not use this file␊
10 * except in compliance with the License. Please obtain a copy of the␊
11 * License at http://www.apple.com/publicsource and read it before using␊
12 * this file.␊
13 * ␊
14 * The Original Code and all software distributed under the License are␊
15 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the␊
19 * License for the specific language governing rights and limitations␊
20 * under the License.␊
21 * ␊
22 * @APPLE_LICENSE_HEADER_END@␊
23 */␊
24␊
25#include "boot.h"␊
26#include "bootstruct.h"␊
27#include "fdisk.h"␊
28#include "ramdisk.h"␊
29#include "gui.h"␊
30#include "term.h"␊
31#include "embedded.h"␊
32#include "pci.h"␊
33#include "modules.h"␊
34␊
35#if DEBUG␊
36#define DBG(x...)␉printf(x)␊
37#else␊
38#define DBG(x...)␉msglog(x)␊
39#endif␊
40␊
41char␉␉gMacOSVersion[OSVERSTRLEN];␊
42uint32_t␉MacOSVerCurrent = 0;␊
43bool␉␉showBootBanner = true; //Azi:showinfo␊
44static bool␉shouldboot = false;␊
45␊
46extern int multiboot_timeout;␊
47extern int multiboot_timeout_set;␊
48␊
49extern BVRef bvChain;␊
50//extern int␉␉menucount;␊
51␊
52extern int␉␉gDeviceCount;␊
53␊
54int␉␉␉selectIndex = 0;␊
55␊
56MenuItem *menuItems = NULL;␊
57␊
58enum {␊
59 kMenuTopRow = 5,␊
60 kMenuMaxItems = 10,␊
61 kScreenLastRow = 24␊
62};␊
63␊
64extern char *msgbuf;␊
65␊
66void showTextBuffer(char *buf_orig, int size);␊
67␊
68//==========================================================================␊
69␊
70// MacOSVer2Int - converts OS ver. string to uint32 (e.g "10.9.5" -> 0x0A090500) for easy comparing␊
71uint32_t MacOSVer2Int(const char *osver)␊
72{␊
73␉uint32_t result = 0;␊
74␉uint8_t *resptr = (uint8_t *)&result;␊
75␉uint8_t len = strlen(osver);␊
76␉uint8_t i, j, m;␊
77#define CHR2UINT(c) ((uint8_t)(c - '0'))␊
78#define ISDIGIT(c) ((c >= '0') && (c <= '9'))␊
79#define ISDOT(c) (c == '.')␊
80␊
81␉if (!osver || (len < 4) || (len > OSVERSTRLEN - 1) || !ISDIGIT(osver[0]) || !ISDOT(osver[2]) || !ISDIGIT(osver[len - 1]))␊
82␉{␊
83␉␉verbose("ERROR: wrong Mac OS version string syntax: '%s'\n", osver);␊
84␉␉return 0;␊
85␉}␊
86␊
87␉for (i = 0, j = 3, m = 1; i < len; i++)␊
88␉{␊
89␉␉if (ISDIGIT(osver[i]))␊
90␉␉{␊
91␉␉␉resptr[j] = resptr[j] * m + CHR2UINT(osver[i]);␊
92␉␉␉m = 10;␊
93␉␉}␊
94␉␉else if (ISDOT(osver[i]))␊
95␉␉{␊
96␉␉␉if (j > 0)␊
97␉␉␉{␊
98␉␉␉␉j--;␊
99␉␉␉}␊
100␉␉␉else␊
101␉␉␉{␊
102␉␉␉␉return 0;␊
103␉␉␉}␊
104␉␉␉m = 1;␊
105␉␉}␊
106␉␉else␊
107␉␉{␊
108␉␉␉return 0;␊
109␉␉}␊
110␉}␊
111␊
112␉return result;␊
113}␊
114␊
115//==========================================================================␊
116␊
117typedef struct {␊
118 int x;␊
119 int y;␊
120 int type;␊
121} CursorState;␊
122␊
123static void changeCursor( int col, int row, int type, CursorState * cs )␊
124{␊
125 if (cs) getCursorPositionAndType( &cs->x, &cs->y, &cs->type );␊
126 setCursorType( type );␊
127 setCursorPosition( col, row, 0 );␊
128}␊
129␊
130static void moveCursor( int col, int row )␊
131{␊
132 setCursorPosition( col, row, 0 );␊
133}␊
134␊
135static void restoreCursor( const CursorState * cs )␊
136{␊
137 setCursorPosition( cs->x, cs->y, 0 );␊
138 setCursorType( cs->type );␊
139}␊
140␊
141//==========================================================================␊
142␊
143/* Flush keyboard buffer; returns TRUE if any of the flushed␊
144 * characters was F8.␊
145 */␊
146␊
147static bool flushKeyboardBuffer(void)␊
148{␊
149 bool status = false;␊
150␊
151 while ( readKeyboardStatus() ) {␊
152 if (bgetc() == 0x4200) status = true;␊
153 }␊
154 return status;␊
155}␊
156␊
157//==========================================================================␊
158␊
159static int countdown( const char * msg, int row, int timeout )␊
160{␊
161␉unsigned long time;␊
162␉int ch = 0;␊
163␉int col = strlen(msg) + 1;␊
164␊
165␉flushKeyboardBuffer();␊
166␊
167␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
168␉{␊
169␉␉moveCursor( 0, row );␊
170␉␉printf(msg);␊
171␊
172␉} else {␊
173␊
174␉␉position_t p = pos( gui.screen.width / 2 + 1 , ( gui.devicelist.pos.y + 3 ) + ( ( gui.devicelist.height - gui.devicelist.iconspacing ) / 2 ) );␊
175␊
176␉␉char dummy[80];␊
177␉␉getBootVolumeDescription( gBootVolume, dummy, sizeof(dummy) - 1, true );␊
178␉␉drawDeviceIcon( gBootVolume, gui.screen.pixmap, p, true );␊
179␉␉drawStrCenteredAt( (char *) msg, &font_small, gui.screen.pixmap, gui.countdown.pos );␊
180␊
181␉␉// make this screen the new background␊
182␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
183␊
184␉}␊
185␊
186␉int multi_buff = 18 * (timeout);␊
187␉int multi = ++multi_buff;␊
188␊
189␉int lasttime=0;␊
190␊
191␉for ( time = time18(), timeout++; timeout > 0; )␊
192␉{␊
193␉␉int currenttime;␊
194␉␉if (lasttime)␊
195␉␉{␊
196␉␉␉currenttime = time18();␊
197␉␉␉if( currenttime > lasttime)␊
198␉␉␉{␊
199␉␉␉␉multi -= (currenttime - lasttime);␊
200␉␉␉␉if (multi < 0) multi = 0;␊
201␉␉␉␉lasttime=currenttime;␊
202␉␉␉}␊
203␉␉}␊
204␉␉else␊
205␉␉{␊
206␉␉␉lasttime = currenttime = time;␊
207␉␉}␊
208 ␊
209␉␉if ( (ch = readKeyboardStatus()) )␊
210␉␉␉break;␊
211␊
212␉␉// Count can be interrupted by holding down shift,␊
213␉␉// control or alt key␊
214␉␉if ( ( readKeyboardShiftFlags() & 0x0F ) != 0 )␊
215␉␉{␊
216␉␉␉ch = 1;␊
217␉␉␉break;␊
218␉␉}␊
219␊
220␉␉if ( currenttime >= time )␊
221␉␉{␊
222␉␉␉time += 18;␊
223␉␉␉timeout--;␊
224␊
225␉␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
226␉␉␉{␊
227␉␉␉␉moveCursor( col, row );␊
228␉␉␉␉printf("(%d) ", timeout);␊
229␉␉␉}␊
230␉␉}␊
231␊
232␉␉if( bootArgs->Video.v_display != VGA_TEXT_MODE )␊
233␉␉{␊
234␉␉␉drawProgressBar( gui.screen.pixmap, 100, gui.progressbar.pos , ( multi * 100 / multi_buff ) );␊
235␉␉␉gui.redraw = true;␊
236␉␉␉updateVRAM();␊
237␉␉}␊
238␊
239␉}␊
240␊
241␉flushKeyboardBuffer();␊
242␊
243␉return ch;␊
244}␊
245␊
246//==========================================================================␊
247␊
248char␉␉gBootArgs[BOOT_STRING_LEN];␊
249static char␉*gBootArgsPtr = gBootArgs;␊
250static char␉*gBootArgsEnd = gBootArgs + BOOT_STRING_LEN - 1;␊
251static char␉booterCommand[BOOT_STRING_LEN];␊
252static char␉booterParam[BOOT_STRING_LEN];␊
253␊
254static void clearBootArgs(void)␊
255{␊
256␉gBootArgsPtr = gBootArgs;␊
257␉memset(gBootArgs, '\0', BOOT_STRING_LEN);␊
258␊
259␉if (bootArgs->Video.v_display != VGA_TEXT_MODE)␊
260␉{␊
261␉␉clearGraphicBootPrompt();␊
262␉}␊
263␉execute_hook("ClearArgs", NULL, NULL, NULL, NULL);␊
264}␊
265␊
266void addBootArg(const char * argStr)␊
267{␊
268␉if ( (gBootArgsPtr + strlen(argStr) + 1) < gBootArgsEnd)␊
269␉{␊
270␉␉if(gBootArgsPtr != gBootArgs) *gBootArgsPtr++ = ' ';␊
271␉␉strcat(gBootArgs, argStr);␊
272␉␉gBootArgsPtr += strlen(argStr);␊
273␉}␊
274}␊
275␊
276//==========================================================================␊
277␊
278static void showBootPrompt(int row, bool visible)␊
279{␊
280␉extern char bootPrompt[];␊
281␉extern char bootRescanPrompt[];␊
282␊
283␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
284␉{␊
285␉␉changeCursor( 0, row, kCursorTypeUnderline, 0 );␊
286␉␉clearScreenRows( row, kScreenLastRow );␊
287␉}␊
288␊
289␉clearBootArgs();␊
290␊
291␉if (visible)␊
292␉{␊
293␉␉if (bootArgs->Video.v_display == VGA_TEXT_MODE)␊
294␉␉{␊
295␉␉␉if (gEnableCDROMRescan)␊
296␉␉␉{␊
297␉␉␉␉printf( bootRescanPrompt );␊
298␉␉␉}␊
299␉␉␉else␊
300␉␉␉{␊
301␉␉␉␉printf( bootPrompt );␊
302␉␉␉␉printf( gBootArgs );␊
303␉␉␉}␊
304␉␉}␊
305␉}␊
306␉else␊
307␉{␊
308␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE)␊
309␉␉{␊
310␉␉␉clearGraphicBootPrompt();␊
311␉␉}␊
312␉␉else␊
313␉␉{␊
314␉␉␉printf("Press Enter to start up the foreign OS. ");␊
315␉␉}␊
316␉}␊
317}␊
318␊
319//==========================================================================␊
320␊
321static void updateBootArgs( int key )␊
322{␊
323␉key = ASCII_KEY(key);␊
324␊
325␉switch ( key )␊
326␉{␊
327␉␉case KEY_BKSP:␊
328␉␉␉if ( gBootArgsPtr > gBootArgs )␊
329␉␉␉{␊
330␉␉␉␉*--gBootArgsPtr = '\0';␊
331␊
332␉␉␉␉int x, y, t;␊
333␉␉␉␉getCursorPositionAndType( &x, &y, &t );␊
334␉␉␉␉if ( x == 0 && y )␊
335␉␉␉␉{␊
336␉␉␉␉␉x = 80; y--;␊
337␉␉␉␉}␊
338␊
339␉␉␉␉if (x)␊
340␉␉␉␉{␊
341␉␉␉␉␉x--;␊
342␉␉␉␉}␊
343␊
344␉␉␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
345␉␉␉␉{␊
346␉␉␉␉␉setCursorPosition( x, y, 0 );␊
347␉␉␉␉␉putca(' ', 0x07, 1);␊
348␉␉␉␉}␊
349␉␉␉␉else␊
350␉␉␉␉{␊
351␉␉␉␉␉updateGraphicBootPrompt();␊
352␉␉␉␉}␊
353␉␉␉}␊
354␉␉␉break;␊
355␊
356 ␉default:␊
357␉␉␉if ( key >= ' ' && gBootArgsPtr < gBootArgsEnd)␊
358␉␉␉{␊
359␉␉␉␉*gBootArgsPtr++ = key;␊
360␊
361␉␉␉␉if( bootArgs->Video.v_display != VGA_TEXT_MODE )␊
362␉␉␉␉{␊
363␉␉␉␉␉updateGraphicBootPrompt();␊
364␉␉␉␉}␊
365␉␉␉␉else if ( key >= ' ' && key < 0x7f)␊
366␉␉␉␉{␊
367␉␉␉␉␉putchar(key);␊
368␉␉␉␉}␊
369␉␉␉}␊
370␊
371␉␉␉break;␊
372␉}␊
373}␊
374␊
375//==========================================================================␊
376␊
377static const MenuItem * gMenuItems = NULL;␊
378␊
379static int gMenuItemCount;␊
380static int gMenuRow;␊
381static int gMenuHeight;␊
382static int gMenuTop;␊
383static int gMenuBottom;␊
384static int gMenuSelection;␊
385␊
386static int␉ gMenuStart;␊
387static int␉ gMenuEnd;␊
388␊
389static void printMenuItem( const MenuItem * item, int highlight )␊
390{␊
391 printf(" ");␊
392␊
393 if ( highlight )␊
394 putca(' ', 0x70, strlen(item->name) + 4);␊
395 else␊
396 putca(' ', 0x07, 40);␊
397␊
398 printf(" %40s\n", item->name);␊
399}␊
400␊
401//==========================================================================␊
402␊
403static void showMenu( const MenuItem * items, int count,␊
404 int selection, int row, int height )␊
405{␊
406 int i;␊
407 CursorState cursorState;␊
408␊
409 if ( items == NULL || count == 0 ) ␊
410␉␉return;␊
411␊
412 // head and tail points to the start and the end of the list.␊
413 // top and bottom points to the first and last visible items␊
414 // in the menu window.␊
415␊
416 gMenuItems␉␉= items;␊
417 gMenuRow␉␉= row;␊
418 gMenuHeight␉␉= height;␊
419 gMenuItemCount␉= count;␊
420 gMenuTop␉␉= 0;␊
421 gMenuBottom␉␉= MIN( count, height ) - 1;␊
422 gMenuSelection␉= selection;␊
423␊
424 gMenuStart␉␉= 0;␊
425 gMenuEnd␉ = MIN( count, gui.maxdevices ) - 1;␊
426␉␊
427␉// If the selected item is not visible, shift the list down.␊
428␊
429 if ( gMenuSelection > gMenuBottom )␊
430 {␊
431 gMenuTop += ( gMenuSelection - gMenuBottom );␊
432 gMenuBottom = gMenuSelection;␊
433 }␊
434␊
435␉if ( gMenuSelection > gMenuEnd )␊
436 {␊
437␉␉gMenuStart += ( gMenuSelection - gMenuEnd );␊
438 gMenuEnd = gMenuSelection;␊
439 }␊
440␉␊
441␉// Draw the visible items.␊
442␊
443␉if( bootArgs->Video.v_display != VGA_TEXT_MODE )␊
444␉{␊
445␉␉drawDeviceList(gMenuStart, gMenuEnd, gMenuSelection);␊
446␉}␊
447␉else␊
448␉{␊
449␉␉changeCursor( 0, row, kCursorTypeHidden, &cursorState );␊
450␊
451␉␉for ( i = gMenuTop; i <= gMenuBottom; i++ )␊
452␉␉{␊
453␉␉␉printMenuItem( &items[i], (i == gMenuSelection) );␊
454␉␉}␊
455␊
456␉␉restoreCursor( &cursorState );␊
457␉}␊
458}␊
459␊
460//==========================================================================␊
461␊
462static int updateMenu( int key, void ** paramPtr )␊
463{␊
464 int moved = 0;␊
465␊
466 union {␊
467 struct {␊
468 unsigned int␊
469 selectionUp : 1,␊
470 selectionDown : 1,␊
471 scrollUp : 1,␊
472 scrollDown : 1;␊
473 } f;␊
474 unsigned int w;␊
475 } draw = {{0}};␊
476␊
477 if ( gMenuItems == NULL )␊
478␉␉return 0;␊
479␊
480␉if( bootArgs->Video.v_display != VGA_TEXT_MODE )␊
481␉{␊
482␉␉int res;␊
483␉␉␊
484␉␉// set navigation keys for horizontal layout as defaults␊
485␉␉int previous␉= 0x4B00;␉␉// left arrow␊
486␉␉int subsequent␉= 0x4D00;␉␉// right arrow␊
487␉␉int menu␉␉= 0x5000;␉␉// down arrow␊
488␉␉␊
489␉␉if ( gui.layout == VerticalLayout )␊
490␉␉{␊
491␉␉␉// set navigation keys for vertical layout␊
492␉␉␉previous␉= 0x4800;␉␉// up arrow␊
493␉␉␉subsequent␉= 0x5000;␉␉// down arrow␊
494␉␉␉menu␉␉= 0x4B00;␉␉// right arrow␊
495␉␉} ␊
496␊
497␉␉if ( key == previous )␊
498␉␉{␊
499␉␉␉if ( gMenuSelection > gMenuTop )␊
500␉␉␉␉draw.f.selectionUp = 1;␊
501␉␉␉else if ( gMenuTop > 0 )␊
502␉␉␉␉draw.f.scrollDown = 1;␊
503␉␉␉␊
504␉␉}␊
505␉␉␊
506␉␉else if ( key == subsequent )␊
507␉␉{␊
508␉␉␉if ( gMenuSelection != gMenuBottom)␊
509␉␉␉␉draw.f.selectionDown = 1;␊
510␉␉␉else if ( gMenuBottom < ( gMenuItemCount - 1 ) )␊
511␉␉␉␉draw.f.scrollUp = 1;␊
512␉␉}␊
513␉␉␊
514␉␉else if ( key == menu )␊
515␉␉{␊
516␉␉␉if ( gui.menu.draw )␊
517␉␉␉␉updateInfoMenu(key);␊
518␉␉␉else␊
519␉␉␉␉drawInfoMenu();␊
520␉␉}␊
521␊
522␉␉else if ( gui.menu.draw )␊
523␉␉{␊
524␉␉␉res = updateInfoMenu(key);␊
525␊
526␉␉␉if ( res == CLOSE_INFO_MENU )␊
527␉␉␉␉gui.menu.draw = false;␊
528␉␉␉else␊
529␉␉␉{␊
530␉␉␉␉shouldboot = ( res != DO_NOT_BOOT );␊
531␉␉␉␉␊
532␉␉␉␉if ( shouldboot )␊
533␉␉␉␉␉gui.menu.draw = false;␊
534␊
535␉␉␉␉switch (res)␊
536␉␉␉␉{␊
537␉␉␉␉␉case BOOT_NORMAL:␊
538␉␉␉␉␉␉gVerboseMode = false;␊
539␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
540␉␉␉␉␉␉break;␊
541␉␉␉␉␉␉␊
542␉␉␉␉␉case BOOT_VERBOSE:␊
543␉␉␉␉␉␉gVerboseMode = true;␊
544␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
545␉␉␉␉␉␉addBootArg(kVerboseModeFlag);␊
546␉␉␉␉␉␉break;␊
547␉␉␉␉␉␉␊
548␉␉␉␉␉case BOOT_IGNORECACHE:␊
549␉␉␉␉␉␉gVerboseMode = false;␊
550␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
551␉␉␉␉␉␉addBootArg(kIgnoreCachesFlag);␊
552␉␉␉␉␉␉break;␊
553␉␉␉␉␉␉␊
554␉␉␉␉␉case BOOT_SINGLEUSER:␊
555␉␉␉␉␉␉gVerboseMode = true;␊
556␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
557␉␉␉␉␉␉addBootArg(kSingleUserModeFlag);␊
558␉␉␉␉␉␉break;␊
559␉␉␉␉}␊
560␉␉␉␉␊
561␉␉␉}␊
562␉␉␉␊
563␉␉}␉␊
564␉␉␉␊
565␉} else {␊
566␉␉switch ( key )␊
567␉␉{␊
568 ␉case 0x4800: // Up Arrow␊
569␉␉␉␉if ( gMenuSelection != gMenuTop )␊
570␉␉␉␉␉draw.f.selectionUp = 1;␊
571␉␉␉␉else if ( gMenuTop > 0 )␊
572␉␉␉␉␉draw.f.scrollDown = 1;␊
573␉␉␉␉break;␊
574␊
575␉␉␉case 0x5000: // Down Arrow␊
576␉␉␉␉if ( gMenuSelection != gMenuBottom )␊
577␉␉␉␉␉draw.f.selectionDown = 1;␊
578␉␉␉␉else if ( gMenuBottom < (gMenuItemCount - 1) ) ␊
579␉␉␉␉␉draw.f.scrollUp = 1;␊
580␉␉␉␉break;␊
581␉␉}␊
582␉}␊
583␊
584 if ( draw.w )␊
585 {␊
586 if ( draw.f.scrollUp )␊
587 {␊
588 scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, 1);␊
589 gMenuTop++; gMenuBottom++;␊
590␉␉␉gMenuStart++; gMenuEnd++;␊
591 draw.f.selectionDown = 1;␊
592 }␊
593␊
594 if ( draw.f.scrollDown )␊
595 {␊
596 scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, -1);␊
597 gMenuTop--; gMenuBottom--;␊
598 gMenuStart--; gMenuEnd--;␊
599 draw.f.selectionUp = 1;␊
600 }␊
601␊
602 if ( draw.f.selectionUp || draw.f.selectionDown )␊
603 {␊
604␊
605␉␉␉CursorState cursorState;␊
606␊
607␉␉␉// Set cursor at current position, and clear inverse video.␊
608␉␊
609␉␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
610␉␉␉{␊
611␉␉␉␉changeCursor( 0, gMenuRow + gMenuSelection - gMenuTop, kCursorTypeHidden, &cursorState );␊
612␉␉␉␉printMenuItem( &gMenuItems[gMenuSelection], 0 );␊
613␉␉␉}␊
614␊
615␉␉␉if ( draw.f.selectionUp )␊
616␉␉␉{␊
617␉␉␉␉gMenuSelection--;␊
618␉␉␉␉if(( gMenuSelection - gMenuStart) == -1 )␊
619␉␉␉␉{␊
620␉␉␉␉␉gMenuStart--;␊
621␉␉␉␉␉gMenuEnd--;␊
622␉␉␉␉}␊
623␉␉␉␉␊
624␉␉␉} else {␊
625␉␉␉gMenuSelection++;␊
626␉␉␉if(( gMenuSelection - ( gui.maxdevices - 1) - gMenuStart) > 0 )␊
627␉␉␉{␊
628␉␉␉␉gMenuStart++;␊
629␉␉␉␉gMenuEnd++;␊
630␉␉␉}␊
631␉ }␊
632␊
633␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
634␉ {␊
635␉␉␉moveCursor( 0, gMenuRow + gMenuSelection - gMenuTop );␊
636␉␉␉printMenuItem( &gMenuItems[gMenuSelection], 1 );␊
637␉␉␉restoreCursor( &cursorState );␊
638␊
639␉ } else␊
640␊
641␉␉␉drawDeviceList (gMenuStart, gMenuEnd, gMenuSelection);␊
642␊
643␉}␊
644␊
645 *paramPtr = gMenuItems[gMenuSelection].param; ␊
646 moved = 1;␊
647 }␊
648␊
649␉return moved;␊
650}␊
651␊
652//==========================================================================␊
653␊
654static void skipblanks( const char ** cpp ) ␊
655{␊
656 while ( **(cpp) == ' ' || **(cpp) == '\t' ) ++(*cpp);␊
657}␊
658␊
659//==========================================================================␊
660␊
661static const char * extractKernelName( char ** cpp )␊
662{␊
663 char * kn = *cpp;␊
664 char * cp = *cpp;␊
665 char c;␊
666␊
667 // Convert char to lower case.␊
668␊
669 c = *cp | 0x20;␊
670␊
671 // Must start with a letter or a '/'.␊
672␊
673 if ( (c < 'a' || c > 'z') && ( c != '/' ) )␊
674 return 0;␊
675␊
676 // Keep consuming characters until we hit a separator.␊
677␊
678 while ( *cp && (*cp != '=') && (*cp != ' ') && (*cp != '\t') )␊
679 cp++;␊
680␊
681 // Only SPACE or TAB separator is accepted.␊
682 // Reject everything else.␊
683␊
684 if (*cp == '=')␊
685 return 0;␊
686␊
687 // Overwrite the separator, and move the pointer past␊
688 // the kernel name.␊
689␊
690 if (*cp != '\0') *cp++ = '\0';␊
691 *cpp = cp;␊
692␊
693 return kn;␊
694}␊
695␊
696//==========================================================================␊
697␊
698static void printMemoryInfo(void)␊
699{␊
700 int line;␊
701 int i;␊
702 MemoryRange *mp = bootInfo->memoryMap;␊
703␊
704 // Activate and clear page 1␊
705 setActiveDisplayPage(1);␊
706 clearScreenRows(0, 24);␊
707 setCursorPosition( 0, 0, 1 );␊
708␊
709 printf("BIOS reported memory ranges:\n");␊
710 line = 1;␊
711 for (i=0; i<bootInfo->memoryMapCount; i++) {␊
712 printf("Base 0x%08x%08x, ",␊
713 (unsigned long)(mp->base >> 32),␊
714 (unsigned long)(mp->base));␊
715 printf("length 0x%08x%08x, type %d\n",␊
716 (unsigned long)(mp->length >> 32),␊
717 (unsigned long)(mp->length),␊
718 mp->type);␊
719 if (line++ > 20) {␊
720 pause();␊
721 line = 0;␊
722 }␊
723 mp++;␊
724 }␊
725 if (line > 0) {␊
726 pause();␊
727 }␊
728 ␊
729 setActiveDisplayPage(0);␊
730}␊
731␊
732char *getMemoryInfoString()␊
733{␊
734␉int i, bufflen;␊
735␉MemoryRange *mp = bootInfo->memoryMap;␊
736␉char *buff = malloc(sizeof(char)*1024);␊
737␉if(!buff) {␊
738␉␉return 0;␊
739␉}␊
740␊
741␉static const char info[] = "BIOS reported memory ranges:\n";␊
742␉bufflen = sprintf(buff, "%s", info);␊
743␊
744␉for (i = 0;␊
745␉␉(i < bootInfo->memoryMapCount) && (bufflen < 1024); /* prevent buffer overflow */␊
746␉␉i++) {␊
747␉␉bufflen += snprintf(buff+bufflen, 1024-bufflen, "Base 0x%08x%08x, ",␊
748 (unsigned long)(mp->base >> 32),␊
749 (unsigned long)(mp->base));␊
750␉␉bufflen += snprintf(buff+bufflen, 1024-bufflen, "length 0x%08x%08x, type %d\n",␊
751 (unsigned long)(mp->length >> 32),␊
752 (unsigned long)(mp->length),␊
753 mp->type);␊
754␉␉mp++;␊
755␉}␊
756␉return buff;␊
757}␊
758␊
759//==========================================================================␊
760␊
761void lspci(void)␊
762{␊
763␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) { ␊
764␉␉setActiveDisplayPage(1);␊
765␉␉clearScreenRows(0, 24);␊
766␉␉setCursorPosition(0, 0, 1);␊
767␉}␊
768␊
769␉dump_pci_dt(root_pci_dev->children);␊
770␊
771␉pause();␊
772␊
773␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) {␊
774␉␉setActiveDisplayPage(0);␊
775␉}␊
776}␊
777␊
778//==========================================================================␊
779␊
780int getBootOptions(bool firstRun)␊
781{␊
782␉int i;␊
783␉int key;␊
784␉int nextRow;␊
785␉int timeout;␊
786␉int bvCount;␊
787␉BVRef bvr;␊
788␉BVRef menuBVR;␊
789␉bool showPrompt, newShowPrompt, isCDROM;␊
790␊
791␉// Initialize default menu selection entry.␊
792␉gBootVolume = menuBVR = selectBootVolume(bvChain);␊
793␊
794␉if (biosDevIsCDROM(gBIOSDev)) {␊
795␉␉isCDROM = true;␊
796␉} else {␊
797␉␉isCDROM = false;␊
798␉}␊
799␊
800␉// ensure we're in graphics mode if gui is setup␊
801␉if (firstRun && gui.initialised && bootArgs->Video.v_display == VGA_TEXT_MODE)␊
802␉{␊
803␉␉setVideoMode(GRAPHICS_MODE, 0);␊
804␉}␊
805␊
806␉// Clear command line boot arguments␊
807␉clearBootArgs();␊
808␊
809␉// Allow user to override default timeout.␊
810␉if (multiboot_timeout_set) {␊
811␉␉timeout = multiboot_timeout;␊
812␉} else if (!getIntForKey(kTimeoutKey, &timeout, &bootInfo->chameleonConfig)) {␊
813␉␉/* If there is no timeout key in the file use the default timeout␊
814␉␉ which is different for CDs vs. hard disks. However, if not booting␊
815␉␉ a CD and no config file could be loaded set the timeout␊
816␉␉ to zero which causes the menu to display immediately.␊
817␉␉ This way, if no partitions can be found, that is the disk is unpartitioned␊
818␉␉ or simply cannot be read) then an empty menu is displayed.␊
819␉␉ If some partitions are found, for example a Windows partition, then␊
820␉␉ these will be displayed in the menu as foreign partitions.␊
821␉␉ */␊
822␉␉if (isCDROM) {␊
823␉␉␉timeout = kCDBootTimeout;␊
824␉␉} else {␊
825␉␉␉timeout = sysConfigValid ? kBootTimeout : 0;␊
826␉␉}␊
827␉}␊
828␊
829␉if (timeout < 0) {␊
830␉␉gBootMode |= kBootModeQuiet;␊
831␉}␊
832␊
833␉// If the user is holding down a modifier key, enter safe mode.␊
834␉if ((readKeyboardShiftFlags() & 0x0F) != 0) {␊
835␉␉gBootMode |= kBootModeSafe;␊
836␉}␊
837␊
838␉// Checking user pressed keys␊
839␉bool f8press = false, spress = false, vpress = false;␊
840␉while (readKeyboardStatus()) {␊
841␉␉key = bgetc ();␊
842␉␉if (key == 0x4200) f8press = true;␊
843␉␉if ((key & 0xff) == 's' || (key & 0xff) == 'S') spress = true;␊
844␉␉if ((key & 0xff) == 'v' || (key & 0xff) == 'V') vpress = true;␊
845␉}␊
846␉// If user typed F8, abort quiet mode, and display the menu.␊
847␉if (f8press) {␊
848␉␉gBootMode &= ~kBootModeQuiet;␊
849␉␉timeout = 0;␊
850␉}␊
851␉// If user typed 'v' or 'V', boot in verbose mode.␊
852␉if ((gBootMode & kBootModeQuiet) && firstRun && vpress) {␊
853␉␉addBootArg(kVerboseModeFlag);␊
854␉}␊
855␉// If user typed 's' or 'S', boot in single user mode.␊
856␉if ((gBootMode & kBootModeQuiet) && firstRun && spress) {␊
857␉␉addBootArg(kSingleUserModeFlag);␊
858␉}␊
859␊
860␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) {␊
861␉␉setCursorPosition(0, 0, 0);␊
862␉␉clearScreenRows(0, kScreenLastRow);␊
863␉␉if (!(gBootMode & kBootModeQuiet)) {␊
864␉␉␉// Display banner and show hardware info.␊
865␉␉␉printf(bootBanner, (bootInfo->convmem + bootInfo->extmem) / 1024);␊
866␉␉␉printf(getVBEInfoString());␊
867␉␉}␊
868␉␉changeCursor(0, kMenuTopRow, kCursorTypeUnderline, 0);␊
869␉␉verbose("Scanning device %x...", gBIOSDev);␊
870␉}␊
871␊
872␉// When booting from CD, default to hard drive boot when possible. ␊
873␉if (isCDROM && firstRun) {␊
874␉␉const char *val;␊
875␉␉char *prompt = NULL;␊
876␉␉char *name = NULL;␊
877␉␉int cnt;␊
878␉␉int optionKey;␊
879␊
880␉␉if (getValueForKey(kCDROMPromptKey, &val, &cnt, &bootInfo->chameleonConfig)) {␊
881␉␉␉prompt = malloc(cnt + 1);␊
882␉␉␉strncat(prompt, val, cnt);␊
883␉␉} else {␊
884␉␉␉name = malloc(80);␊
885␉␉␉getBootVolumeDescription(gBootVolume, name, 79, false);␊
886␉␉␉prompt = malloc(256);␊
887␉␉␉sprintf(prompt, "Press any key to start up from %s, or press F8 to enter startup options.", name);␊
888␉␉␉free(name);␊
889␉␉}␊
890␊
891␉␉if (getIntForKey( kCDROMOptionKey, &optionKey, &bootInfo->chameleonConfig )) {␊
892␉␉␉// The key specified is a special key.␊
893␉␉} else {␊
894␉␉␉// Default to F8.␊
895␉␉␉optionKey = 0x4200;␊
896␉␉}␊
897␊
898␉␉// If the timeout is zero then it must have been set above due to the␊
899␉␉// early catch of F8 which means the user wants to set boot options␊
900␉␉// which we ought to interpret as meaning he wants to boot the CD.␊
901␉␉if (timeout != 0) {␊
902␉␉␉key = countdown(prompt, kMenuTopRow, timeout);␊
903␉␉} else {␊
904␉␉␉key = optionKey;␊
905␉␉}␊
906␊
907␉␉if (prompt != NULL) {␊
908␉␉␉free(prompt);␊
909␉␉}␊
910␊
911␉␉clearScreenRows( kMenuTopRow, kMenuTopRow + 2 );␊
912␊
913␉␉// Hit the option key ?␊
914␉␉if (key == optionKey) {␊
915␉␉␉gBootMode &= ~kBootModeQuiet;␊
916␉␉␉timeout = 0;␊
917␉␉} else {␊
918␉␉␉key = key & 0xFF;␊
919␊
920␉␉␉// Try booting hard disk if user pressed 'h'␊
921␉␉␉if (biosDevIsCDROM(gBIOSDev) && key == 'h') {␊
922␉␉␉␉BVRef bvr;␊
923␊
924␉␉␉␉// Look at partitions hosting OS X other than the CD-ROM␊
925␉␉␉␉for (bvr = bvChain; bvr; bvr=bvr->next) {␊
926␉␉␉␉␉if ((bvr->flags & kBVFlagSystemVolume) && bvr->biosdev != gBIOSDev) {␊
927␉␉␉␉␉␉gBootVolume = bvr;␊
928␉␉␉␉␉}␊
929␉␉␉␉}␊
930␉␉␉}␊
931␉␉␉goto done;␊
932␉␉}␊
933␉}␊
934␊
935␉if (gBootMode & kBootModeQuiet) {␊
936␉␉// No input allowed from user.␊
937␉␉goto done;␊
938␉}␊
939␊
940␉if (firstRun && timeout > 0 && countdown("Press any key to enter startup options.", kMenuTopRow, timeout) == 0) {␊
941␉␉// If the user is holding down a modifier key,␊
942␉␉// enter safe mode.␊
943␉␉if ((readKeyboardShiftFlags() & 0x0F) != 0) {␊
944␉␉␉gBootMode |= kBootModeSafe;␊
945␉␉}␊
946␉␉goto done;␊
947␉}␊
948␊
949␉if (gDeviceCount > 0) {␊
950␉␉// Allocate memory for an array of menu items.␊
951␉␉menuItems = malloc(sizeof(MenuItem) * gDeviceCount);␊
952␉␉if (menuItems == NULL) {␊
953␉␉␉goto done;␊
954␉␉}␊
955␊
956␉␉// Associate a menu item for each BVRef.␊
957␉␉for (bvr=bvChain, i=gDeviceCount-1, selectIndex=-1; bvr; bvr=bvr->next) {␊
958␉␉␉if (bvr->visible) {␊
959␉␉␉␉getBootVolumeDescription(bvr, menuItems[i].name, sizeof(menuItems[i].name) - 1, true);␊
960␉␉␉␉menuItems[i].param = (void *) bvr;␊
961␉␉␉␉if (bvr == menuBVR) {␊
962␉␉␉␉␉selectIndex = i;␊
963␉␉␉␉}␊
964␉␉␉␉i--;␊
965␉␉␉}␊
966␉␉}␊
967␉␉// Jief : In case the default partition (returned by selectBootVolume) is not in the menu␊
968␉␉if ( selectIndex == -1 )␊
969␉␉{␊
970␉␉␉selectIndex = 0;␊
971␊
972␉␉␉// gDeviceCount is actually > 0, so menuItems[selectIndex] exists␊
973␉␉␉menuBVR = (BVRef)(menuItems[selectIndex].param);␊
974␉␉␉// what happen if bvChain is empty ?␊
975␉␉}␊
976␉}␊
977␊
978␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
979␉␉// redraw the background buffer␊
980␉␉gui.logo.draw = true;␊
981␉␉drawBackground();␊
982␉␉gui.devicelist.draw = true;␊
983␉␉gui.redraw = true;␊
984␉␉if (!(gBootMode & kBootModeQuiet)) {␊
985 ␊
986␉␉␉// Check if "Boot Banner"=N switch is present in config file.␊
987␉␉␉getBoolForKey(kBootBannerKey, &showBootBanner, &bootInfo->chameleonConfig); ␊
988␉␉␉if (showBootBanner) {␊
989␉␉␉␉// Display banner and show hardware info.␊
990␉␉␉␉gprintf(&gui.screen, bootBanner + 1, (bootInfo->convmem + bootInfo->extmem) / 1024);␊
991␉␉␉}␊
992␊
993␉␉␉// redraw background␊
994␉␉␉memcpy(gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4);␊
995␉␉}␊
996␉} else {␊
997␉␉// Clear screen and hide the blinking cursor.␊
998␉␉clearScreenRows(kMenuTopRow, kMenuTopRow + 2);␊
999␉␉changeCursor(0, kMenuTopRow, kCursorTypeHidden, 0);␊
1000␉}␊
1001␊
1002␉nextRow = kMenuTopRow;␊
1003␉showPrompt = true;␊
1004␊
1005␉if (gDeviceCount) {␊
1006␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE ) {␊
1007␉␉␉printf("Use \30\31 keys to select the startup volume.");␊
1008␉␉}␊
1009␉␉showMenu( menuItems, gDeviceCount, selectIndex, kMenuTopRow + 2, kMenuMaxItems );␊
1010␉␉nextRow += MIN( gDeviceCount, kMenuMaxItems ) + 3;␊
1011␉}␊
1012␊
1013␉// Show the boot prompt.␊
1014␉showPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);␊
1015␉showBootPrompt( nextRow, showPrompt );␊
1016␉␊
1017␉do {␊
1018␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1019␉␉␉// redraw background␊
1020␉␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
1021␉␉␉// reset cursor co-ords␊
1022␉␉␉gui.debug.cursor = pos( gui.screen.width - 160 , 10 );␊
1023␉␉}␊
1024␉␉key = getchar();␊
1025␉␉updateMenu( key, (void **) &menuBVR );␊
1026␉␉newShowPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);␊
1027␊
1028␉␉if (newShowPrompt != showPrompt) {␊
1029␉␉␉showPrompt = newShowPrompt;␊
1030␉␉␉showBootPrompt( nextRow, showPrompt );␊
1031␉␉}␊
1032␊
1033␉␉if (showPrompt) {␊
1034␉␉␉updateBootArgs(key);␊
1035␉␉}␊
1036␊
1037␉␉switch (key) {␊
1038␉␉case KEY_ENTER:␊
1039␉␉␉if (gui.menu.draw) { ␊
1040␉␉␉␉key=0;␊
1041␉␉␉␉break;␊
1042␉␉␉}␊
1043␉␉␉if (*gBootArgs == '?') {␊
1044␉␉␉␉char * argPtr = gBootArgs;␊
1045␊
1046␉␉␉␉// Skip the leading "?" character.␊
1047␉␉␉␉argPtr++;␊
1048␉␉␉␉getNextArg(&argPtr, booterCommand);␊
1049␉␉␉␉getNextArg(&argPtr, booterParam);␊
1050␊
1051␉␉␉␉/*␊
1052␉␉␉␉* TODO: this needs to be refactored.␊
1053␉␉␉␉*/␊
1054␉␉␉␉if (strcmp( booterCommand, "video" ) == 0) {␊
1055␉␉␉␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1056␉␉␉␉␉␉showInfoBox(getVBEInfoString(), getVBEModeInfoString());␊
1057␉␉␉␉␉} else {␊
1058␉␉␉␉␉␉printVBEModeInfo();␊
1059␉␉␉␉␉}␊
1060␉␉␉␉} else if ( strcmp( booterCommand, "memory" ) == 0) {␊
1061␉␉␉␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE ) {␊
1062␉␉␉␉␉␉showInfoBox("Memory Map", getMemoryInfoString());␊
1063␉␉␉␉␉} else {␊
1064␉␉␉␉␉␉printMemoryInfo();␊
1065␉␉␉␉␉}␊
1066␉␉␉␉} else if (strcmp(booterCommand, "lspci") == 0) {␊
1067␉␉␉␉␉lspci();␊
1068␉␉␉␉} else if (strcmp(booterCommand, "log") == 0) {␊
1069␉␉␉ showTextBuffer(msgbuf, strlen(msgbuf));␊
1070␉␉␉␉} else if (strcmp(booterCommand, "more") == 0) {␊
1071␉␉␉␉␉showTextFile(booterParam);␊
1072␉␉␉␉} else if (strcmp(booterCommand, "rd") == 0) {␊
1073␉␉␉␉␉processRAMDiskCommand(&argPtr, booterParam);␊
1074␉␉␉␉} else if (strcmp(booterCommand, "norescan") == 0) {␊
1075␉␉␉␉␉if (gEnableCDROMRescan) {␊
1076␉␉␉␉␉␉gEnableCDROMRescan = false;␊
1077␉␉␉␉␉␉break;␊
1078␉␉␉␉␉}␊
1079␉␉␉␉} else {␊
1080␉␉␉␉␉showHelp();␊
1081␉␉␉␉}␊
1082␉␉␉␉key = 0;␊
1083␉␉␉␉showBootPrompt(nextRow, showPrompt);␊
1084␉␉␉␉break;␊
1085␉␉␉}␊
1086␉␉␉gBootVolume = menuBVR;␊
1087␉␉␉setRootVolume(menuBVR);␊
1088␉␉␉gBIOSDev = menuBVR->biosdev;␊
1089␉␉␉break;␊
1090␊
1091␉␉case KEY_ESC:␊
1092␉␉␉clearBootArgs();␊
1093␉␉␉break;␊
1094␊
1095␉␉case KEY_F5:␊
1096␉␉␉// New behavior:␊
1097␉␉␉// Clear gBootVolume to restart the loop␊
1098␉␉␉// if the user enabled rescanning the optical drive.␊
1099␉␉␉// Otherwise boot the default boot volume.␊
1100␉␉␉if (gEnableCDROMRescan) {␊
1101␉␉␉␉gBootVolume = NULL;␊
1102␉␉␉␉clearBootArgs();␊
1103␉␉␉}␊
1104␉␉␉break;␊
1105␊
1106␉␉case KEY_F10:␊
1107␉␉␉gScanSingleDrive = false;␊
1108␉␉␉scanDisks(gBIOSDev, &bvCount);␊
1109␉␉␉gBootVolume = NULL;␊
1110␉␉␉clearBootArgs();␊
1111␉␉␉break;␊
1112␊
1113␉␉case KEY_TAB:␊
1114␉␉␉// New behavior:␊
1115␉␉␉// Switch between text & graphic interfaces␊
1116␉␉␉// Only Permitted if started in graphics interface␊
1117␉␉␉if (useGUI)␊
1118␉␉␉{␊
1119␉␉␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE)␊
1120␉␉␉␉{␊
1121␉␉␉␉␉setVideoMode(VGA_TEXT_MODE, 0);␊
1122␊
1123␉␉␉␉␉setCursorPosition(0, 0, 0);␊
1124␉␉␉␉␉clearScreenRows(0, kScreenLastRow);␊
1125␊
1126␉␉␉␉␉// Display banner and show hardware info.␊
1127␉␉␉␉␉printf(bootBanner, (bootInfo->convmem + bootInfo->extmem) / 1024);␊
1128␉␉␉␉␉printf(getVBEInfoString());␊
1129␊
1130␉␉␉␉␉clearScreenRows(kMenuTopRow, kMenuTopRow + 2);␊
1131␉␉␉␉␉changeCursor(0, kMenuTopRow, kCursorTypeHidden, 0);␊
1132␊
1133␉␉␉␉␉nextRow = kMenuTopRow;␊
1134␉␉␉␉␉showPrompt = true;␊
1135␊
1136␉␉␉␉␉if (gDeviceCount)␊
1137␉␉␉␉␉{␊
1138␉␉␉␉␉␉printf("Use \30\31 keys to select the startup volume.");␊
1139␉␉␉␉␉␉showMenu(menuItems, gDeviceCount, selectIndex, kMenuTopRow + 2, kMenuMaxItems);␊
1140␉␉␉␉␉␉nextRow += MIN(gDeviceCount, kMenuMaxItems) + 3;␊
1141␉␉␉␉␉}␊
1142␊
1143␉␉␉␉␉showPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);␊
1144␉␉␉␉␉showBootPrompt(nextRow, showPrompt);␊
1145␉␉␉␉␉//changeCursor( 0, kMenuTopRow, kCursorTypeUnderline, 0 );␊
1146␉␉␉␉}␊
1147␉␉␉␉else␊
1148␉␉␉␉{␊
1149␉␉␉␉␉gui.redraw = true;␊
1150␉␉␉␉␉setVideoMode(GRAPHICS_MODE, 0);␊
1151␉␉␉␉␉updateVRAM();␊
1152 ␉␉␉updateGraphicBootPrompt();␊
1153␉␉␉␉}␊
1154␉␉␉}␊
1155␉␉␉key = 0;␊
1156␉␉␉break;␊
1157␊
1158␉␉default:␊
1159␉␉␉key = 0;␊
1160␉␉␉break;␊
1161␉␉}␊
1162␉} while (0 == key);␊
1163␊
1164done:␊
1165␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) {␊
1166␉␉clearScreenRows(kMenuTopRow, kScreenLastRow);␊
1167␉␉changeCursor(0, kMenuTopRow, kCursorTypeUnderline, 0);␊
1168␉}␊
1169␉shouldboot = false;␊
1170␉gui.menu.draw = false;␊
1171␉if (menuItems) {␊
1172␉␉free(menuItems);␊
1173␉␉menuItems = NULL;␊
1174␉}␊
1175␉execute_hook("BootOptions", gBootArgs, gBootArgsPtr, NULL, NULL);␊
1176␉return 0;␊
1177}␊
1178␊
1179//==========================================================================␊
1180␊
1181char gBootUUIDString[32+4+1] = ""; // UUID of the boot volume e.g. 5EB1869F-C4FA-3502-BDEB-3B8ED5D87292␊
1182extern unsigned char chainbootdev;␊
1183extern unsigned char chainbootflag;␊
1184␊
1185bool copyArgument(const char *argName, const char *val, int cnt, char **argP, int *cntRemainingP)␊
1186{␊
1187␉int argLen = argName ? strlen(argName) : 0;␊
1188␉int len = argLen + cnt + 1; // +1 to account for space␊
1189␊
1190␉if (argName)␊
1191␉{␊
1192␉␉len++; // +1 to account for '='␊
1193␉}␊
1194␊
1195␉if (len > *cntRemainingP)␊
1196␉{␊
1197␉␉error("Warning: boot arguments too long, truncating\n");␊
1198␉␉return false;␊
1199␉}␊
1200␊
1201␉if (argName)␊
1202␉{␊
1203␉␉strncpy(*argP, argName, argLen);␊
1204␉␉*argP += argLen;␊
1205␉␉*argP[0] = '=';␊
1206␉␉(*argP)++;␊
1207␉}␊
1208␊
1209␉strncpy(*argP, val, cnt);␊
1210␉*argP += cnt;␊
1211␉*argP[0] = ' ';␊
1212␉(*argP)++;␊
1213␉*cntRemainingP -= len;␊
1214␊
1215␉return true;␊
1216}␊
1217␊
1218// ␊
1219// Returns TRUE if an argument was copied, FALSE otherwise␊
1220bool␊
1221processBootArgument(␊
1222 const char *argName, // The argument to search for␊
1223 const char *userString, // Typed-in boot arguments␊
1224 const char *kernelFlags, // Kernel flags from config table␊
1225 const char *configTable,␊
1226 char **argP, // Output value␊
1227 int *cntRemainingP, // Output count␊
1228 char *foundVal, // found value␊
1229 int foundValSize // max found value size␊
1230 ) {␊
1231␉const char *val;␊
1232␉int cnt;␊
1233␉bool found = false;␊
1234␊
1235␉if (getValueForBootKey(userString, argName, &val, &cnt)) {␊
1236␉␉// Don't copy; these values will be copied at the end of argument processing.␊
1237␉␉found = true;␊
1238␉} else if (getValueForBootKey(kernelFlags, argName, &val, &cnt)) {␊
1239␉␉// Don't copy; these values will be copied at the end of argument processing.␊
1240␉␉found = true;␊
1241␉} else if (getValueForKey(argName, &val, &cnt, &bootInfo->chameleonConfig)) {␊
1242␉␉copyArgument(argName, val, cnt, argP, cntRemainingP);␊
1243␉␉found = true;␊
1244␉}␊
1245␉if (found && foundVal) {␊
1246␉␉strlcpy(foundVal, val, foundValSize);␊
1247␉}␊
1248␉return found;␊
1249}␊
1250␊
1251// Maximum config table value size␊
1252#define VALUE_SIZE 2048␊
1253␊
1254int processBootOptions()␊
1255{␊
1256␉const char *cp = gBootArgs;␊
1257␉const char *val = 0;␊
1258␉const char *kernel;␊
1259␉int cnt;␊
1260␉int userCnt;␊
1261␉int cntRemaining;␊
1262␉char *argP;␊
1263␉char *configKernelFlags;␊
1264␉char *valueBuffer;␊
1265␊
1266␉valueBuffer = malloc(VALUE_SIZE);␊
1267 ␊
1268␉skipblanks( &cp );␊
1269␊
1270␉// Update the unit and partition number.␊
1271␉if (gBootVolume)␊
1272␉{␊
1273␉␉if (!(gBootVolume->flags & kBVFlagNativeBoot))␊
1274␉␉{␊
1275␉␉␉readBootSector(gBootVolume->biosdev, gBootVolume->part_boff, (void *)0x7c00);␊
1276␉␉␉//␊
1277␉␉␉// Setup edx, and signal intention to chain load the␊
1278␉␉␉// foreign booter.␊
1279␉␉␉//␊
1280␊
1281␉␉␉chainbootdev = gBootVolume->biosdev;␊
1282␉␉␉chainbootflag = 1;␊
1283␊
1284␉␉␉return 1;␊
1285␉␉}␊
1286␊
1287␉␉setRootVolume(gBootVolume);␊
1288␊
1289␉}␊
1290␉// If no boot volume fail immediately because we're just going to fail␊
1291␉// trying to load the config file anyway.␊
1292␉else␊
1293␉{␊
1294␉␉return -1;␊
1295␉}␊
1296␊
1297␉// Save a version of mac os we're booting.␊
1298␉MacOSVerCurrent = MacOSVer2Int(gBootVolume->OSVersion);␊
1299␉// so copy it and trim␊
1300␉gMacOSVersion[0] = 0;␊
1301␉if (MacOSVerCurrent >= MacOSVer2Int("10.10"))␊
1302␉{␊
1303␉␉strncat(gMacOSVersion, gBootVolume->OSVersion, 5);␊
1304␉}␊
1305␉else␊
1306␉{␊
1307␉␉strncat(gMacOSVersion, gBootVolume->OSVersion, 4);␊
1308␉}␊
1309␊
1310␉// Load config table specified by the user, or use the default.␊
1311␊
1312␉if (!getValueForBootKey(cp, "config", &val, &cnt))␊
1313␉{␊
1314␉␉val = 0;␊
1315␉␉cnt = 0;␊
1316␉}␊
1317␊
1318␉// Load com.apple.Boot.plist from the selected volume␊
1319␉// and use its contents to override default bootConfig.␊
1320␊
1321␉loadSystemConfig(&bootInfo->bootConfig);␊
1322␉loadChameleonConfig(&bootInfo->chameleonConfig, NULL);␊
1323␊
1324␉// Use the kernel name specified by the user, or fetch the name␊
1325␉// in the config table, or use the default if not specified.␊
1326␉// Specifying a kernel name on the command line, or specifying␊
1327␉// a non-default kernel name in the config file counts as␊
1328␉// overriding the kernel, which causes the kernelcache not␊
1329␉// to be used.␊
1330␊
1331␉gOverrideKernel = false;␊
1332␉if (( kernel = extractKernelName((char **)&cp) ))␊
1333␉{␊
1334␉␉strlcpy( bootInfo->bootFile, kernel, sizeof(bootInfo->bootFile) );␊
1335␉}␊
1336␉else␊
1337␉{␊
1338␉␉if ( getValueForKey( kKernelNameKey, &val, &cnt, &bootInfo->bootConfig ) )␊
1339␉␉{␊
1340␉␉␉strlcpy( bootInfo->bootFile, val, cnt+1 );␊
1341␉␉}␊
1342␉␉else␊
1343␉␉{␊
1344␉␉␉if (MacOSVerCurrent >= MacOSVer2Int("10.10")) // OS X is 10.10 or newer␊
1345␉␉␉{␊
1346␉␉␉␉strlcpy( bootInfo->bootFile, kOSXKernel, sizeof(bootInfo->bootFile) );␊
1347␉␉␉}␊
1348␉␉␉else␊
1349␉␉␉{␊
1350␉␉␉␉// or 10.9 and previous␊
1351␉␉␉␉strlcpy( bootInfo->bootFile, kDefaultKernel, sizeof(bootInfo->bootFile) );␊
1352␉␉␉}␊
1353␉␉}␊
1354␉}␊
1355␊
1356␉if ((strcmp( bootInfo->bootFile, kDefaultKernel ) != 0) && (strcmp( bootInfo->bootFile, kOSXKernel ) != 0))␊
1357␉{␊
1358␉␉gOverrideKernel = true;␊
1359␉}␊
1360␊
1361␉// Ermac : Inject "kext-dev-mode=1" if OS X 10.10 is detected␊
1362␉if (MacOSVerCurrent >= MacOSVer2Int("10.10")) // OS X is 10.10 or newer␊
1363␉{␊
1364␉␉addBootArg("kext-dev-mode=1");␊
1365␉}␊
1366␊
1367␉cntRemaining = BOOT_STRING_LEN - 2; // save 1 for NULL, 1 for space␊
1368␉argP = bootArgs->CommandLine;␊
1369␊
1370␉// Get config kernel flags, if not ignored.␊
1371␉if (getValueForBootKey(cp, kIgnoreBootFileFlag, &val, &cnt) || !getValueForKey(kKernelFlagsKey, &val, &cnt, &bootInfo->bootConfig))␊
1372␉{␊
1373␉␉val = "";␊
1374␉␉cnt = 0;␊
1375␉}␊
1376␉configKernelFlags = malloc(cnt + 1);␊
1377␉strlcpy(configKernelFlags, val, cnt + 1);␊
1378␊
1379␉// boot-uuid can be set either on the command-line or in the config file␊
1380␉if (!processBootArgument(kBootUUIDKey, cp, configKernelFlags, bootInfo->config,␊
1381 &argP, &cntRemaining, gBootUUIDString, sizeof(gBootUUIDString)))␊
1382␉{␊
1383␉␉//␊
1384␉␉// Try an alternate method for getting the root UUID on boot helper partitions.␊
1385␉␉//␊
1386␉␉if (gBootVolume->flags & kBVFlagBooter)␊
1387␉␉{␊
1388␉␉␉// Load the configuration store in the boot helper partition␊
1389␉␉␉if (loadHelperConfig(&bootInfo->helperConfig) == 0)␊
1390␉␉␉{␊
1391␉␉␉␉val = getStringForKey(kHelperRootUUIDKey, &bootInfo->helperConfig);␊
1392␉␉␉␉if (val != NULL)␊
1393␉␉␉␉{␊
1394␉␉␉␉␉strlcpy(gBootUUIDString, val, sizeof(gBootUUIDString));␊
1395␉␉␉␉}␊
1396␉␉␉}␊
1397␉␉}␊
1398/*␊
1399␉␉// Try to get the volume uuid string␊
1400␉␉if (!strlen(gBootUUIDString) && gBootVolume->fs_getuuid)␊
1401␉␉{␊
1402␉␉␉gBootVolume->fs_getuuid(gBootVolume, gBootUUIDString);␊
1403␉␉}␊
1404*/␊
1405␉␉// If we have the volume uuid add it to the commandline arguments␊
1406␉␉if (strlen(gBootUUIDString))␊
1407␉␉{␊
1408␉␉␉copyArgument(kBootUUIDKey, gBootUUIDString, strlen(gBootUUIDString), &argP, &cntRemaining);␊
1409␉␉}␊
1410␉␉// Try to get the volume uuid string␊
1411␉␉if (!strlen(gBootUUIDString) && gBootVolume->fs_getuuid)␊
1412␉␉{␊
1413␉␉␉gBootVolume->fs_getuuid(gBootVolume, gBootUUIDString);␊
1414␉␉}␊
1415␉}␊
1416␉DBG("Boot UUID [%s (%s), %s]: %s\n", gBootVolume->label, gBootVolume->altlabel, gBootVolume->type_name, gBootUUIDString);␊
1417␊
1418␉if (!processBootArgument(kRootDeviceKey, cp, configKernelFlags, bootInfo->config,␊
1419 &argP, &cntRemaining, gRootDevice, ROOT_DEVICE_SIZE))␊
1420␉{␊
1421␉␉cnt = 0;␊
1422␉␉if ( getValueForKey( kBootDeviceKey, &val, &cnt, &bootInfo->chameleonConfig))␊
1423␉␉{␊
1424␉␉␉valueBuffer[0] = '*';␊
1425␉␉␉cnt++;␊
1426␉␉␉strlcpy(valueBuffer + 1, val, cnt);␊
1427␉␉␉val = valueBuffer;␊
1428␉␉␉if (cnt > 0)␊
1429␉␉␉{␊
1430␉␉␉␉copyArgument( kRootDeviceKey, val, cnt, &argP, &cntRemaining);␊
1431␉␉␉}␊
1432␉␉}␊
1433␉␉else␊
1434␉␉{␊
1435␉␉␉if (strlen(gBootUUIDString))␊
1436␉␉␉{␊
1437␉␉␉␉val = "*uuid";␊
1438␉␉␉␉cnt = 5;␊
1439␉␉␉}␊
1440␉␉␉else␊
1441␉␉␉{␊
1442␉␉␉␉// Don't set "rd=.." if there is no boot device key␊
1443␉␉␉␉// and no UUID.␊
1444␉␉␉␉val = "";␊
1445␉␉␉␉cnt = 0;␊
1446␉␉␉}␊
1447␉␉}␊
1448/* Bungo␊
1449␉␉if (cnt > 0)␊
1450␉␉{␊
1451␉␉␉copyArgument( kRootDeviceKey, val, cnt, &argP, &cntRemaining);␊
1452␉␉}␊
1453*/␊
1454␉␉strlcpy(gRootDevice, val, (cnt + 1));␊
1455␉}␊
1456␊
1457␉/*␊
1458␉ * Removed. We don't need this anymore.␊
1459␉ *␊
1460␉if (!processBootArgument(kPlatformKey, cp, configKernelFlags, bootInfo->config,␊
1461␉␉␉␉␉␉␉ &argP, &cntRemaining, gPlatformName, sizeof(gCacheNameAdler)))␊
1462␉{␊
1463␉␉getPlatformName(gPlatformName);␊
1464␉␉copyArgument(kPlatformKey, gPlatformName, strlen(gPlatformName), &argP, &cntRemaining);␊
1465␉}␊
1466␉*/␊
1467␊
1468␉if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&␊
1469 !getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt))␊
1470␉{␊
1471␉␉if (gBootMode & kBootModeSafe)␊
1472␉␉{␊
1473␉␉␉copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &cntRemaining);␊
1474␉␉}␊
1475␉}␊
1476␊
1477␉// Store the merged kernel flags and boot args.␊
1478␊
1479␉cnt = strlen(configKernelFlags);␊
1480␉if (cnt)␊
1481␉{␊
1482␉␉if (cnt > cntRemaining)␊
1483␉␉{␊
1484␉␉␉error("Warning: boot arguments too long, truncating\n");␊
1485␉␉␉cnt = cntRemaining;␊
1486␉␉}␊
1487␉␉strncpy(argP, configKernelFlags, cnt);␊
1488␉␉argP[cnt++] = ' ';␊
1489␉␉cntRemaining -= cnt;␊
1490␉}␊
1491␉userCnt = strlen(cp);␊
1492␉if (userCnt > cntRemaining)␊
1493␉{␊
1494␉␉error("Warning: boot arguments too long, truncating\n");␊
1495␉␉userCnt = cntRemaining;␊
1496␉}␊
1497␉strncpy(&argP[cnt], cp, userCnt);␊
1498␉argP[cnt+userCnt] = '\0';␊
1499␊
1500␉if(!shouldboot)␊
1501␉{␊
1502␉␉gVerboseMode = getValueForKey( kVerboseModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ||␊
1503␉␉␉getValueForKey( kSingleUserModeFlag, &val, &cnt, &bootInfo->chameleonConfig );␊
1504␉␉␊
1505␉␉gBootMode = ( getValueForKey( kSafeModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ) ?␊
1506␉␉␉kBootModeSafe : kBootModeNormal;␊
1507␊
1508␉␉if ( getValueForKey( kIgnoreCachesFlag, &val, &cnt, &bootInfo->chameleonConfig ) )␊
1509␉␉{␊
1510␉␉␉gBootMode = kBootModeSafe;␊
1511␉␉}␊
1512␉}␊
1513␊
1514␉if ( getValueForKey( kMKextCacheKey, &val, &cnt, &bootInfo->bootConfig ) )␊
1515␉{␊
1516␉␉strlcpy(gMKextName, val, cnt + 1);␊
1517␉}␊
1518␉else␊
1519␉{␊
1520␉␉gMKextName[0]=0;␊
1521␉}␊
1522␊
1523␉free(configKernelFlags);␊
1524␉free(valueBuffer);␊
1525␊
1526␉return 0;␊
1527}␊
1528␊
1529␊
1530//==========================================================================␊
1531// Load the help file and display the file contents on the screen.␊
1532␊
1533void showTextBuffer(char *buf_orig, int size)␊
1534{␊
1535␉char␉*bp;␊
1536␉char␉*buf;␊
1537␉int␉line;␊
1538␉int␉line_offset;␊
1539␉int␉c;␊
1540␊
1541␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1542␉␉showInfoBox( "Press q to continue, space for next page.\n",buf_orig );␊
1543␉␉return;␊
1544␉}␊
1545␊
1546␉// Create a copy so that we don't mangle the original␊
1547␉buf = malloc(size + 1);␊
1548␉memcpy(buf, buf_orig, size);␊
1549␉␊
1550␊
1551 bp = buf;␊
1552 while (size-- > 0) {␊
1553␉␉if (*bp == '\n') {␊
1554␉␉␉*bp = '\0';␊
1555␉␉}␊
1556␉␉bp++;␊
1557 }␊
1558 *bp = '\1';␊
1559 line_offset = 0;␊
1560␊
1561 setActiveDisplayPage(1);␊
1562␊
1563 while (1) {␊
1564␉␉clearScreenRows(0, 24);␊
1565␉␉setCursorPosition(0, 0, 1);␊
1566␉␉bp = buf;␊
1567␉␉for (line = 0; *bp != '\1' && line < line_offset; line++) {␊
1568␉␉␉while (*bp != '\0') {␊
1569␉␉␉␉bp++;␊
1570␉␉␉}␊
1571␉␉␉bp++;␊
1572␉␉}␊
1573␉␉for (line = 0; *bp != '\1' && line < 23; line++) {␊
1574␉␉␉setCursorPosition(0, line, 1);␊
1575␉␉␉printf("%s\n", bp);␊
1576␉␉␉while (*bp != '\0') {␊
1577␉␉␉␉bp++;␊
1578␉␉␉}␊
1579␉␉␉bp++;␊
1580␉␉}␊
1581␊
1582␉␉setCursorPosition(0, 23, 1);␊
1583␉␉if (*bp == '\1') {␊
1584␉␉␉printf("[Type %sq or space to quit viewer]", (line_offset > 0) ? "p for previous page, " : "");␊
1585␉␉} else {␊
1586␉␉␉printf("[Type %s%sq to quit viewer]", (line_offset > 0) ? "p for previous page, " : "", (*bp != '\1') ? "space for next page, " : "");␊
1587␉␉}␊
1588␊
1589␉␉c = getchar();␊
1590␉␉if (c == 'q' || c == 'Q') {␊
1591␉␉␉break;␊
1592␉␉}␊
1593␉␉if ((c == 'p' || c == 'P') && line_offset > 0) {␊
1594␉␉␉line_offset -= 23;␊
1595␉␉}␊
1596␉␉if (c == ' ') {␊
1597␉␉␉if (*bp == '\1') {␊
1598␉␉␉␉break;␊
1599␉␉␉} else {␊
1600␉␉␉␉line_offset += 23;␊
1601␉␉␉}␊
1602␉␉}␊
1603 }␊
1604 setActiveDisplayPage(0);␊
1605}␊
1606␊
1607void showHelp(void)␊
1608{␊
1609␉if (bootArgs->Video.v_display != VGA_TEXT_MODE)␊
1610␉{␊
1611␉␉showInfoBox("Help. Press q to quit.\n", (char *)BootHelp_txt);␊
1612␉}␊
1613␉else␊
1614␉{␊
1615␉␉showTextBuffer((char *)BootHelp_txt, BootHelp_txt_len);␊
1616␉}␊
1617}␊
1618␊
1619void showTextFile(const char * filename)␊
1620{␊
1621#define MAX_TEXT_FILE_SIZE 65536␊
1622␉char␉*buf;␊
1623␉int␉fd;␊
1624␉int␉size;␊
1625 ␊
1626␉if ((fd = open_bvdev("bt(0,0)", filename, 0)) < 0)␊
1627␉{␊
1628␉␉printf("\nFile not found: %s\n", filename);␊
1629␉␉sleep(2);␊
1630␉␉return;␊
1631␉}␊
1632␊
1633 size = file_size(fd);␊
1634 if (size > MAX_TEXT_FILE_SIZE)␊
1635␉{␊
1636␉␉size = MAX_TEXT_FILE_SIZE;␊
1637␉}␊
1638 buf = malloc(size);␊
1639 read(fd, buf, size);␊
1640 close(fd);␊
1641␉showTextBuffer(buf, size);␊
1642␉free(buf);␊
1643}␊
1644␊
1645// This is a very simplistic prompting scheme that just grabs two hex characters␊
1646// Eventually we need to do something more user-friendly like display a menu␊
1647// based off of the Multiboot device list␊
1648␊
1649int selectAlternateBootDevice(int bootdevice)␊
1650{␊
1651␉int key;␊
1652␉int newbootdevice;␊
1653␉int digitsI = 0;␊
1654␉char *end;␊
1655␉char digits[3] = {0,0,0};␊
1656␊
1657␉// We've already printed the current boot device so user knows what it is␊
1658␉printf("Typical boot devices are 80 (First HD), 81 (Second HD)\n");␊
1659␉printf("Enter two-digit hexadecimal boot device [%02x]: ", bootdevice);␊
1660␉do {␊
1661␉␉key = getchar();␊
1662␉␉switch (ASCII_KEY(key))␊
1663␉␉{␊
1664␉␉case KEY_BKSP:␊
1665␉␉␉if (digitsI > 0)␊
1666␉␉␉{␊
1667␉␉␉␉int x, y, t;␊
1668␉␉␉␉getCursorPositionAndType(&x, &y, &t);␊
1669␉␉␉␉// Assume x is not 0;␊
1670␉␉␉␉x--;␊
1671␉␉␉␉setCursorPosition(x,y,0); // back up one char␊
1672␉␉␉␉// Overwrite with space without moving cursor position␊
1673␉␉␉␉putca(' ', 0x07, 1);␊
1674␉␉␉␉digitsI--;␊
1675␉␉␉}␊
1676␉␉␉else␊
1677␉␉␉{␊
1678␉␉␉␉// TODO: Beep or something␊
1679␉␉␉}␊
1680␉␉␉break;␊
1681␊
1682␉␉case KEY_ENTER:␊
1683␉␉␉digits[digitsI] = '\0';␊
1684␉␉␉newbootdevice = strtol(digits, &end, 16);␊
1685␉␉␉if (end == digits && *end == '\0')␊
1686␉␉␉{␊
1687␉␉␉␉// User entered empty string␊
1688␉␉␉␉printf("\nUsing default boot device %x\n", bootdevice);␊
1689␉␉␉␉key = 0;␊
1690␉␉␉} else if(end != digits && *end == '\0') {␊
1691␉␉␉␉bootdevice = newbootdevice;␊
1692␉␉␉␉printf("\n");␊
1693␉␉␉␉key = 0; // We gots da boot device␊
1694␉␉␉} else {␊
1695␉␉␉␉printf("\nCouldn't parse. try again: ");␊
1696␉␉␉␉digitsI = 0;␊
1697␉␉␉}␊
1698␉␉␉break;␊
1699␊
1700␉␉default:␊
1701␉␉␉if (isxdigit(ASCII_KEY(key)) && digitsI < 2)␊
1702␉␉␉{␊
1703␉␉␉␉putchar(ASCII_KEY(key));␊
1704␉␉␉␉digits[digitsI++] = ASCII_KEY(key);␊
1705␉␉␉}␊
1706␉␉␉else␊
1707␉␉␉{␊
1708␉␉␉␉// TODO: Beep or something␊
1709␉␉␉}␊
1710␉␉␉break;␊
1711␉␉};␊
1712␉} while (key != 0);␊
1713␊
1714␉return bootdevice;␊
1715}␊
1716␊
1717bool promptForRescanOption(void)␊
1718{␊
1719␉printf("\nWould you like to enable media rescan option?\nPress ENTER to enable or any key to skip.\n");␊
1720␉if (getchar() == KEY_ENTER)␊
1721␉{␊
1722␉␉return true;␊
1723␉}␊
1724␉else␊
1725␉{␊
1726␉␉return false;␊
1727␉}␊
1728}␊
1729

Archive Download this file

Revision: 2592