Mercurial > illumos > onarm

comparison usr/src/cmd/format/menu.c @ 0:c9caec207d52 b86

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial porting based on b86
author Koji Uno <koji.uno@sun.com>
date Tue, 02 Jun 2009 18:56:50 +0900
parents
children 1a15d5aaf794
comparison
equal deleted inserted replaced
-1:000000000000 0:c9caec207d52
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 1991-2003 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright (c) 2007 NEC Corporation
28 */
29
30 #pragma ident "@(#)menu.c 1.27 05/06/08 SMI"
31
32 /*
33 * This file contains routines relating to running the menus.
34 */
35 #include <string.h>
36 #include "global.h"
37 #include "menu.h"
38 #include "misc.h"
39
40 #ifdef __STDC__
41
42 /* Function prototypes for ANSI C Compilers */
43 static int (*find_enabled_menu_item())(struct menu_item *menu, int item);
44
45 #else /* __STDC__ */
46
47 /* Function prototypes for non-ANSI C Compilers */
48 static int (*find_enabled_menu_item())();
49
50 #endif /* __STDC__ */
51
52 static char cur_title[MAXPATHLEN];
53
54 /*
55 * This routine takes a menu struct and concatenates the
56 * command names into an array of strings describing the menu.
57 * All menus have a 'quit' command at the bottom to exit the menu.
58 */
59 char **
60 create_menu_list(menu)
61 struct menu_item *menu;
62 {
63 register struct menu_item *mptr;
64 register char **cpptr;
65 register char **list;
66 int nitems;
67
68 /*
69 * A minimum list consists of the quit command, followed
70 * by a terminating null.
71 */
72 nitems = 2;
73 /*
74 * Count the number of active commands in the menu and allocate
75 * space for the array of pointers.
76 */
77 for (mptr = menu; mptr->menu_cmd != NULL; mptr++) {
78 if ((*mptr->menu_state)())
79 nitems++;
80 }
81 list = (char **)zalloc(nitems * sizeof (char *));
82 cpptr = list;
83 /*
84 * Fill in the array with the names of the menu commands.
85 */
86 for (mptr = menu; mptr->menu_cmd != NULL; mptr++) {
87 if ((*mptr->menu_state)()) {
88 *cpptr++ = mptr->menu_cmd;
89 }
90 }
91 /*
92 * Add the 'quit' command to the end.
93 */
94 *cpptr = "quit";
95 return (list);
96 }
97
98 /*
99 * This routine takes a menu list created by the above routine and
100 * prints it nicely on the screen.
101 */
102 void
103 display_menu_list(list)
104 char **list;
105 {
106 register char **str;
107
108 for (str = list; *str != NULL; str++)
109 fmt_print(" %s\n", *str);
110 }
111
112 /*
113 * Find the "i"th enabled menu in a menu list. This depends
114 * on menu_state() returning the same status as when the
115 * original list of enabled commands was constructed.
116 */
117 static int (*
118 find_enabled_menu_item(menu, item))()
119 struct menu_item *menu;
120 int item;
121 {
122 struct menu_item *mp;
123
124 for (mp = menu; mp->menu_cmd != NULL; mp++) {
125 if ((*mp->menu_state)()) {
126 if (item-- == 0) {
127 return (mp->menu_func);
128 }
129 }
130 }
131
132 return (NULL);
133 }
134
135 /*
136 * This routine 'runs' a menu. It repeatedly requests a command and
137 * executes the command chosen. It exits when the 'quit' command is
138 * executed.
139 */
140 /*ARGSUSED*/
141 void
142 run_menu(menu, title, prompt, display_flag)
143 struct menu_item *menu;
144 char *title;
145 char *prompt;
146 int display_flag;
147 {
148 char **list;
149 int i;
150 struct env env;
151 u_ioparam_t ioparam;
152 int (*f)();
153
154
155 /*
156 * Create the menu list and display it.
157 */
158 list = create_menu_list(menu);
159 (void) strcpy(cur_title, title);
160 fmt_print("\n\n%s MENU:\n", title);
161 display_menu_list(list);
162 /*
163 * Save the environment so a ctrl-C out of a command lands here.
164 */
165 saveenv(env);
166 for (;;) {
167 /*
168 * Ask the user which command they want to run.
169 */
170 ioparam.io_charlist = list;
171 i = input(FIO_MSTR, prompt, '>', &ioparam,
172 (int *)NULL, CMD_INPUT);
173 /*
174 * If they choose 'quit', the party's over.
175 */
176 if ((f = find_enabled_menu_item(menu, i)) == NULL)
177 break;
178
179 /*
180 * Mark the saved environment active so the user can now
181 * do a ctrl-C to get out of the command.
182 */
183 useenv();
184 /*
185 * Run the command. If it returns an error and we are
186 * running out of a command file, the party's really over.
187 */
188 if ((*f)() && option_f)
189 fullabort();
190 /*
191 * Mark the saved environment inactive so ctrl-C doesn't
192 * work at the menu itself.
193 */
194 unuseenv();
195 /*
196 * Since menu items are dynamic, some commands
197 * cause changes to occur. Destroy the old menu,
198 * and rebuild it, so we're always up-to-date.
199 */
200 destroy_data((char *)list);
201 list = create_menu_list(menu);
202 /*
203 * Redisplay menu, if we're returning to this one.
204 */
205 if (cur_menu != last_menu) {
206 last_menu = cur_menu;
207 (void) strcpy(cur_title, title);
208 fmt_print("\n\n%s MENU:\n", title);
209 display_menu_list(list);
210 }
211 }
212 /*
213 * Clean up the environment stack and throw away the menu list.
214 */
215 clearenv();
216 destroy_data((char *)list);
217 }
218
219 /*
220 * re-display the screen after exiting from shell escape
221 *
222 */
223 void
224 redisplay_menu_list(list)
225 char **list;
226 {
227 fmt_print("\n\n%s MENU:\n", cur_title);
228 display_menu_list(list);
229 }
230
231
232 /*
233 * Glue to always return true. Used for menu items which
234 * are always enabled.
235 */
236 int
237 true()
238 {
239 return (1);
240 }
241
242 /*
243 * Note: The following functions are used to enable the inclusion
244 * of device specific options (see init_menus.c). But when we are
245 * running non interactively with commands taken from a script file,
246 * current disk (cur_disk, cur_type, cur_ctype) may not be defined.
247 * They get defined when the script selects a disk using "disk" option
248 * in the main menu. However, in the normal interactive mode, the disk
249 * selection happens before entering the main menu.
250 */
251 /*
252 * Return true for menu items enabled only for embedded SCSI controllers
253 */
254 int
255 embedded_scsi()
256 {
257 if (cur_ctype == NULL && option_f)
258 return (0);
259 return (EMBEDDED_SCSI);
260 }
261
262 /*
263 * Return false for menu items disabled only for embedded SCSI controllers
264 */
265 int
266 not_embedded_scsi()
267 {
268 if (cur_ctype == NULL && option_f)
269 return (0);
270 return (!EMBEDDED_SCSI);
271 }
272
273 /*
274 * Return false for menu items disabled for scsi controllers
275 */
276 int
277 not_scsi()
278 {
279 if (cur_ctype == NULL && option_f)
280 return (0);
281 return (!SCSI);
282 }
283
284 /*
285 * Return false for menu items disabled for efi labels
286 */
287 int
288 not_efi()
289 {
290 if ((cur_disk == NULL) && option_f)
291 return (0);
292 if (cur_disk->label_type == L_TYPE_EFI)
293 return (0);
294 return (1);
295 }
296
297 int
298 disp_expert_change_expert_efi()
299 {
300 if ((cur_disk == NULL) && option_f)
301 return (0);
302 if ((cur_disk->label_type == L_TYPE_EFI) && expert_mode)
303 return (1);
304 if (cur_disk->label_type != L_TYPE_EFI)
305 return (1);
306 return (0);
307 }
308
309 int
310 disp_all_change_expert_efi()
311 {
312 if ((cur_disk == NULL) && option_f)
313 return (0);
314 if ((cur_disk->label_type != L_TYPE_EFI) || (!expert_mode))
315 return (0);
316 return (1);
317 }
318
319 /*
320 * Return true for menu items enabled scsi controllers
321 */
322 int
323 scsi()
324 {
325 if (cur_ctype == NULL && option_f)
326 return (0);
327 return (SCSI);
328 }
329
330
331 /*
332 * Return true for menu items enabled if expert mode is enabled
333 */
334 int
335 scsi_expert()
336 {
337 if (cur_ctype == NULL && option_f)
338 return (0);
339 return (SCSI && expert_mode);
340 }
341
342 #if defined(i386) || defined(__arm)
343 /*
344 * Return true for menu items enabled if expert mode is enabled
345 */
346 int
347 expert()
348 {
349 return (expert_mode);
350 }
351 #endif /* defined(i386) || defined(__arm) */
352
353 /*
354 * Return true for menu items enabled if developer mode is enabled
355 */
356 int
357 developer()
358 {
359 return (dev_expert);
360 }
361
362 /*
363 * For x86, always return true for menu items enabled
364 * since fdisk is already supported on these two platforms.
365 * For Sparc, only return true for menu items enabled
366 * if a PCATA disk is selected.
367 */
368 int
369 support_fdisk_on_sparc()
370 {
371 #if defined(sparc)
372 /*
373 * If it's a SCSI disk then we don't support fdisk and we
374 * don't need to know the type cause we can ask the disk,
375 * therefore we return true only if we *KNOW* it's an ATA
376 * disk.
377 */
378 if (cur_ctype && cur_ctype->ctype_ctype == DKC_PCMCIA_ATA) {
379 return (1);
380 } else {
381 return (0);
382 }
383 #elif defined(i386) || defined(__arm)
384 return (1);
385 #else
386 #error No Platform defined
387 #endif /* defined(sparc) */
388
389 }