// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org> */ #include <ctype.h>#include <stdarg.h>#include <stdlib.h>#include <string.h> #include <list.h>#include <xalloc.h>#include "lkc.h"#include "internal.h" static const char nohelp_text[] = "There is no help available for this option."; struct menu rootmenu = { .type = M_MENU };static struct menu **last_entry_ptr; /** * menu_next - return the next menu entry with depth-first traversal * @menu: pointer to the current menu * @root: root of the sub-tree to traverse. If NULL is given, the traveral *        continues until it reaches the end of the entire menu tree. * return: the menu to visit next, or NULL when it reaches the end. */struct menu *menu_next(struct menu *menu, struct menu *root){	if (menu->list)		return menu->list; 	while (menu != root && !menu->next)		menu = menu->parent; 	if (menu == root)		return NULL; 	return menu->next;} void menu_warn(const struct menu *menu, const char *fmt, ...){	va_list ap;	va_start(ap, fmt);	fprintf(stderr, "%s:%d:warning: ", menu->filename, menu->lineno);	vfprintf(stderr, fmt, ap);	fprintf(stderr, "\n");	va_end(ap);} static void prop_warn(const struct property *prop, const char *fmt, ...){	va_list ap;	va_start(ap, fmt);	fprintf(stderr, "%s:%d:warning: ", prop->filename, prop->lineno);	vfprintf(stderr, fmt, ap);	fprintf(stderr, "\n");	va_end(ap);} void _menu_init(void){	current_entry = current_menu = &rootmenu;	last_entry_ptr = &rootmenu.list;} void menu_add_entry(struct symbol *sym, enum menu_type type){	struct menu *menu; 	menu = xmalloc(sizeof(*menu));	memset(menu, 0, sizeof(*menu));	menu->type = type;	menu->sym = sym;	menu->parent = current_menu;	menu->filename = cur_filename;	menu->lineno = cur_lineno; 	*last_entry_ptr = menu;	last_entry_ptr = &menu->next;	current_entry = menu;	if (sym)		list_add_tail(&menu->link, &sym->menus);} struct menu *menu_add_menu(void){	last_entry_ptr = &current_entry->list;	current_menu = current_entry;	return current_menu;} void menu_end_menu(void){	last_entry_ptr = &current_menu->next;	current_menu = current_menu->parent;} /* * Rewrites 'm' to 'm' && MODULES, so that it evaluates to 'n' when running * without modules */static struct expr *rewrite_m(struct expr *e){	if (!e)		return e; 	switch (e->type) {	case E_NOT:		e = expr_alloc_one(E_NOT, rewrite_m(e->left.expr));		break;	case E_OR:	case E_AND:		e = expr_alloc_two(e->type,				   rewrite_m(e->left.expr),				   rewrite_m(e->right.expr));		break;	case E_SYMBOL:		/* change 'm' into 'm' && MODULES */		if (e->left.sym == &symbol_mod)			return expr_alloc_and(e, expr_alloc_symbol(modules_sym));		break;	default:		break;	}	return e;} void menu_add_dep(struct expr *dep, struct expr *cond){	if (cond) {		/*		 * We have "depends on X if Y" and we want:		 *	Y != n --> X		 *	Y == n --> y		 * That simplifies to: (X || (Y == n))		 */		dep = expr_alloc_or(dep,				expr_trans_compare(cond, E_EQUAL, &symbol_no));	}	current_entry->dep = expr_alloc_and(current_entry->dep, dep);} void menu_set_type(int type){	struct symbol *sym = current_entry->sym; 	if (sym->type == type)		return;	if (sym->type == S_UNKNOWN) {		sym->type = type;		return;	}	menu_warn(current_entry,		"ignoring type redefinition of '%s' from '%s' to '%s'",		sym->name ? sym->name : "<choice>",		sym_type_name(sym->type), sym_type_name(type));} static struct property *menu_add_prop(enum prop_type type, struct expr *expr,				      struct expr *dep){	struct property *prop; 	prop = xmalloc(sizeof(*prop));	memset(prop, 0, sizeof(*prop));	prop->type = type;	prop->filename = cur_filename;	prop->lineno = cur_lineno;	prop->menu = current_entry;	prop->expr = expr;	prop->visible.expr = dep; 	/* append property to the prop list of symbol */	if (current_entry->sym) {		struct property **propp; 		for (propp = &current_entry->sym->prop;		     *propp;		     propp = &(*propp)->next)			;		*propp = prop;	} 	return prop;} struct property *menu_add_prompt(enum prop_type type, const char *prompt,				 struct expr *dep){	struct property *prop = menu_add_prop(type, NULL, dep); 	if (isspace(*prompt)) {		prop_warn(prop, "leading whitespace ignored");		while (isspace(*prompt))			prompt++;	}	if (current_entry->prompt)		prop_warn(prop, "prompt redefined"); 	/* Apply all upper menus' visibilities to actual prompts. */	if (type == P_PROMPT) {		struct menu *menu = current_entry; 		while ((menu = menu->parent) != NULL) { 			if (!menu->visibility)				continue;			prop->visible.expr = expr_alloc_and(prop->visible.expr,							    menu->visibility);		}	} 	current_entry->prompt = prop;	prop->text = prompt; 	return prop;} void menu_add_visibility(struct expr *expr){	current_entry->visibility = expr_alloc_and(current_entry->visibility,	    expr);} void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep){	menu_add_prop(type, expr, dep);} void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep){	menu_add_prop(type, expr_alloc_symbol(sym), dep);} static int menu_validate_number(struct symbol *sym, struct symbol *sym2){	return sym2->type == S_INT || sym2->type == S_HEX ||	       (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name));} static void sym_check_prop(struct symbol *sym){	struct property *prop;	struct symbol *sym2;	char *use; 	for (prop = sym->prop; prop; prop = prop->next) {		switch (prop->type) {		case P_DEFAULT:			if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) &&			    prop->expr->type != E_SYMBOL)				prop_warn(prop,				    "default for config symbol '%s'"				    " must be a single symbol", sym->name);			if (prop->expr->type != E_SYMBOL)				break;			sym2 = prop_get_symbol(prop);			if (sym->type == S_HEX || sym->type == S_INT) {				if (!menu_validate_number(sym, sym2))					prop_warn(prop,					    "'%s': number is invalid",					    sym->name);			}			if (sym_is_choice(sym)) {				struct menu *choice = sym_get_choice_menu(sym2); 				if (!choice || choice->sym != sym)					prop_warn(prop,						  "choice default symbol '%s' is not contained in the choice",						  sym2->name);			}			break;		case P_SELECT:		case P_IMPLY:			use = prop->type == P_SELECT ? "select" : "imply";			sym2 = prop_get_symbol(prop);			if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE)				prop_warn(prop,				    "config symbol '%s' uses %s, but is "				    "not bool or tristate", sym->name, use);			else if (sym2->type != S_UNKNOWN &&				 sym2->type != S_BOOLEAN &&				 sym2->type != S_TRISTATE)				prop_warn(prop,				    "'%s' has wrong type. '%s' only "				    "accept arguments of bool and "				    "tristate type", sym2->name, use);			break;		case P_RANGE:			if (sym->type != S_INT && sym->type != S_HEX)				prop_warn(prop, "range is only allowed "						"for int or hex symbols");			if (!menu_validate_number(sym, prop->expr->left.sym) ||			    !menu_validate_number(sym, prop->expr->right.sym))				prop_warn(prop, "range is invalid");			break;		default:			;		}	}} static void _menu_finalize(struct menu *parent, bool inside_choice){	struct menu *menu, *last_menu;	struct symbol *sym;	struct property *prop;	struct expr *basedep, *dep, *dep2; 	sym = parent->sym;	if (parent->list) {		/*		 * This menu node has children. We (recursively) process them		 * and propagate parent dependencies before moving on.		 */ 		/* For each child menu node... */		for (menu = parent->list; menu; menu = menu->next) {			/*			 * Propagate parent dependencies to the child menu			 * node, also rewriting and simplifying expressions			 */			basedep = rewrite_m(menu->dep);			basedep = expr_transform(basedep);			basedep = expr_alloc_and(parent->dep, basedep);			basedep = expr_eliminate_dups(basedep);			menu->dep = basedep; 			if (menu->sym)				/*				 * Note: For symbols, all prompts are included				 * too in the symbol's own property list				 */				prop = menu->sym->prop;			else				/*				 * For non-symbol menu nodes, we just need to				 * handle the prompt				 */				prop = menu->prompt; 			/* For each property... */			for (; prop; prop = prop->next) {				if (prop->menu != menu)					/*					 * Two possibilities:					 *					 * 1. The property lacks dependencies					 *    and so isn't location-specific,					 *    e.g. an 'option'					 *					 * 2. The property belongs to a symbol					 *    defined in multiple locations and					 *    is from some other location. It					 *    will be handled there in that					 *    case.					 *					 * Skip the property.					 */					continue; 				/*				 * Propagate parent dependencies to the				 * property's condition, rewriting and				 * simplifying expressions at the same time				 */				dep = rewrite_m(prop->visible.expr);				dep = expr_transform(dep);				dep = expr_alloc_and(basedep, dep);				dep = expr_eliminate_dups(dep);				prop->visible.expr = dep; 				/*				 * Handle selects and implies, which modify the				 * dependencies of the selected/implied symbol				 */				if (prop->type == P_SELECT) {					struct symbol *es = prop_get_symbol(prop);					es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr,							expr_alloc_and(expr_alloc_symbol(menu->sym), dep));				} else if (prop->type == P_IMPLY) {					struct symbol *es = prop_get_symbol(prop);					es->implied.expr = expr_alloc_or(es->implied.expr,							expr_alloc_and(expr_alloc_symbol(menu->sym), dep));				}			}		} 		/*		 * Recursively process children in the same fashion before		 * moving on		 */		for (menu = parent->list; menu; menu = menu->next)			_menu_finalize(menu, sym && sym_is_choice(sym));	} else if (!inside_choice && sym) {		/*		 * Automatic submenu creation. If sym is a symbol and A, B, C,		 * ... are consecutive items (symbols, menus, ifs, etc.) that		 * all depend on sym, then the following menu structure is		 * created:		 *		 *	sym		 *	 +-A		 *	 +-B		 *	 +-C		 *	 ...		 *		 * This also works recursively, giving the following structure		 * if A is a symbol and B depends on A:		 *		 *	sym		 *	 +-A		 *	 | +-B		 *	 +-C		 *	 ...		 */ 		basedep = parent->prompt ? parent->prompt->visible.expr : NULL;		basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no);		basedep = expr_eliminate_dups(expr_transform(basedep)); 		/* Examine consecutive elements after sym */		last_menu = NULL;		for (menu = parent->next; menu; menu = menu->next) {			dep = menu->prompt ? menu->prompt->visible.expr : menu->dep;			if (!expr_contains_symbol(dep, sym))				/* No dependency, quit */				break;			if (expr_depends_symbol(dep, sym))				/* Absolute dependency, put in submenu */				goto next; 			/*			 * Also consider it a dependency on sym if our			 * dependencies contain sym and are a "superset" of			 * sym's dependencies, e.g. '(sym || Q) && R' when sym			 * depends on R.			 *			 * Note that 'R' might be from an enclosing menu or if,			 * making this a more common case than it might seem.			 */			dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no);			dep = expr_eliminate_dups(expr_transform(dep));			dep2 = basedep;			expr_eliminate_eq(&dep, &dep2);			if (!expr_is_yes(dep2)) {				/* Not superset, quit */				break;			}			/* Superset, put in submenu */		next:			_menu_finalize(menu, false);			menu->parent = parent;			last_menu = menu;		}		if (last_menu) {			parent->list = parent->next;			parent->next = last_menu->next;			last_menu->next = NULL;		} 		sym->dir_dep.expr = expr_alloc_or(sym->dir_dep.expr, parent->dep);	}	for (menu = parent->list; menu; menu = menu->next) {		/*		 * This code serves two purposes:		 *		 * (1) Flattening 'if' blocks, which do not specify a submenu		 *     and only add dependencies.		 *		 *     (Automatic submenu creation might still create a submenu		 *     from an 'if' before this code runs.)		 *		 * (2) "Undoing" any automatic submenus created earlier below		 *     promptless symbols.		 *		 * Before:		 *		 *	A		 *	if ... (or promptless symbol)		 *	 +-B		 *	 +-C		 *	D		 *		 * After:		 *		 *	A		 *	if ... (or promptless symbol)		 *	B		 *	C		 *	D		 */		if (menu->list && (!menu->prompt || !menu->prompt->text)) {			for (last_menu = menu->list; ; last_menu = last_menu->next) {				last_menu->parent = parent;				if (!last_menu->next)					break;			}

Lines 1–500 of 874. Load more