0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
0004 */
0005 %{
0006
0007 #include <ctype.h>
0008 #include <stdarg.h>
0009 #include <stdio.h>
0010 #include <stdlib.h>
0011 #include <string.h>
0012 #include <stdbool.h>
0013
0014 #include "lkc.h"
0015 #include "internal.h"
0016
0017 #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
0018
0019 #define PRINTD 0x0001
0020 #define DEBUG_PARSE 0x0002
0021
0022 int cdebug = PRINTD;
0023
0024 static void yyerror(const char *err);
0025 static void zconfprint(const char *err, ...);
0026 static void zconf_error(const char *err, ...);
0027 static bool zconf_endtoken(const char *tokenname,
0028 const char *expected_tokenname);
0029
0030 struct symbol *symbol_hash[SYMBOL_HASHSIZE];
0031
0032 struct menu *current_menu, *current_entry;
0033
0034 %}
0035
0036 %union
0037 {
0038 char *string;
0039 struct symbol *symbol;
0040 struct expr *expr;
0041 struct menu *menu;
0042 enum symbol_type type;
0043 enum variable_flavor flavor;
0044 }
0045
0046 %token <string> T_HELPTEXT
0047 %token <string> T_WORD
0048 %token <string> T_WORD_QUOTE
0049 %token T_BOOL
0050 %token T_CHOICE
0051 %token T_CLOSE_PAREN
0052 %token T_COLON_EQUAL
0053 %token T_COMMENT
0054 %token T_CONFIG
0055 %token T_DEFAULT
0056 %token T_DEF_BOOL
0057 %token T_DEF_TRISTATE
0058 %token T_DEPENDS
0059 %token T_ENDCHOICE
0060 %token T_ENDIF
0061 %token T_ENDMENU
0062 %token T_HELP
0063 %token T_HEX
0064 %token T_IF
0065 %token T_IMPLY
0066 %token T_INT
0067 %token T_MAINMENU
0068 %token T_MENU
0069 %token T_MENUCONFIG
0070 %token T_MODULES
0071 %token T_ON
0072 %token T_OPEN_PAREN
0073 %token T_OPTIONAL
0074 %token T_PLUS_EQUAL
0075 %token T_PROMPT
0076 %token T_RANGE
0077 %token T_SELECT
0078 %token T_SOURCE
0079 %token T_STRING
0080 %token T_TRISTATE
0081 %token T_VISIBLE
0082 %token T_EOL
0083 %token <string> T_ASSIGN_VAL
0084
0085 %left T_OR
0086 %left T_AND
0087 %left T_EQUAL T_UNEQUAL
0088 %left T_LESS T_LESS_EQUAL T_GREATER T_GREATER_EQUAL
0089 %nonassoc T_NOT
0090
0091 %type <symbol> nonconst_symbol
0092 %type <symbol> symbol
0093 %type <type> type logic_type default
0094 %type <expr> expr
0095 %type <expr> if_expr
0096 %type <string> end
0097 %type <menu> if_entry menu_entry choice_entry
0098 %type <string> word_opt assign_val
0099 %type <flavor> assign_op
0100
0101 %destructor {
0102 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
0103 $$->file->name, $$->lineno);
0104 if (current_menu == $$)
0105 menu_end_menu();
0106 } if_entry menu_entry choice_entry
0107
0108 %%
0109 input: mainmenu_stmt stmt_list | stmt_list;
0110
0111 /* mainmenu entry */
0112
0113 mainmenu_stmt: T_MAINMENU T_WORD_QUOTE T_EOL
0114 {
0115 menu_add_prompt(P_MENU, $2, NULL);
0116 };
0117
0118 stmt_list:
0119 /* empty */
0120 | stmt_list assignment_stmt
0121 | stmt_list choice_stmt
0122 | stmt_list comment_stmt
0123 | stmt_list config_stmt
0124 | stmt_list if_stmt
0125 | stmt_list menu_stmt
0126 | stmt_list menuconfig_stmt
0127 | stmt_list source_stmt
0128 | stmt_list T_WORD error T_EOL { zconf_error("unknown statement \"%s\"", $2); }
0129 | stmt_list error T_EOL { zconf_error("invalid statement"); }
0130 ;
0131
0132 stmt_list_in_choice:
0133 /* empty */
0134 | stmt_list_in_choice comment_stmt
0135 | stmt_list_in_choice config_stmt
0136 | stmt_list_in_choice if_stmt_in_choice
0137 | stmt_list_in_choice error T_EOL { zconf_error("invalid statement"); }
0138 ;
0139
0140 /* config/menuconfig entry */
0141
0142 config_entry_start: T_CONFIG nonconst_symbol T_EOL
0143 {
0144 $2->flags |= SYMBOL_OPTIONAL;
0145 menu_add_entry($2);
0146 printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), $2->name);
0147 };
0148
0149 config_stmt: config_entry_start config_option_list
0150 {
0151 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
0152 };
0153
0154 menuconfig_entry_start: T_MENUCONFIG nonconst_symbol T_EOL
0155 {
0156 $2->flags |= SYMBOL_OPTIONAL;
0157 menu_add_entry($2);
0158 printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), $2->name);
0159 };
0160
0161 menuconfig_stmt: menuconfig_entry_start config_option_list
0162 {
0163 if (current_entry->prompt)
0164 current_entry->prompt->type = P_MENU;
0165 else
0166 zconfprint("warning: menuconfig statement without prompt");
0167 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
0168 };
0169
0170 config_option_list:
0171 /* empty */
0172 | config_option_list config_option
0173 | config_option_list depends
0174 | config_option_list help
0175 ;
0176
0177 config_option: type prompt_stmt_opt T_EOL
0178 {
0179 menu_set_type($1);
0180 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
0181 zconf_curname(), zconf_lineno(),
0182 $1);
0183 };
0184
0185 config_option: T_PROMPT T_WORD_QUOTE if_expr T_EOL
0186 {
0187 menu_add_prompt(P_PROMPT, $2, $3);
0188 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
0189 };
0190
0191 config_option: default expr if_expr T_EOL
0192 {
0193 menu_add_expr(P_DEFAULT, $2, $3);
0194 if ($1 != S_UNKNOWN)
0195 menu_set_type($1);
0196 printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
0197 zconf_curname(), zconf_lineno(),
0198 $1);
0199 };
0200
0201 config_option: T_SELECT nonconst_symbol if_expr T_EOL
0202 {
0203 menu_add_symbol(P_SELECT, $2, $3);
0204 printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
0205 };
0206
0207 config_option: T_IMPLY nonconst_symbol if_expr T_EOL
0208 {
0209 menu_add_symbol(P_IMPLY, $2, $3);
0210 printd(DEBUG_PARSE, "%s:%d:imply\n", zconf_curname(), zconf_lineno());
0211 };
0212
0213 config_option: T_RANGE symbol symbol if_expr T_EOL
0214 {
0215 menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,$2, $3), $4);
0216 printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
0217 };
0218
0219 config_option: T_MODULES T_EOL
0220 {
0221 if (modules_sym)
0222 zconf_error("symbol '%s' redefines option 'modules' already defined by symbol '%s'",
0223 current_entry->sym->name, modules_sym->name);
0224 modules_sym = current_entry->sym;
0225 };
0226
0227 /* choice entry */
0228
0229 choice: T_CHOICE word_opt T_EOL
0230 {
0231 struct symbol *sym = sym_lookup($2, SYMBOL_CHOICE);
0232 sym->flags |= SYMBOL_NO_WRITE;
0233 menu_add_entry(sym);
0234 menu_add_expr(P_CHOICE, NULL, NULL);
0235 free($2);
0236 printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
0237 };
0238
0239 choice_entry: choice choice_option_list
0240 {
0241 $$ = menu_add_menu();
0242 };
0243
0244 choice_end: end
0245 {
0246 if (zconf_endtoken($1, "choice")) {
0247 menu_end_menu();
0248 printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
0249 }
0250 };
0251
0252 choice_stmt: choice_entry stmt_list_in_choice choice_end
0253 ;
0254
0255 choice_option_list:
0256 /* empty */
0257 | choice_option_list choice_option
0258 | choice_option_list depends
0259 | choice_option_list help
0260 ;
0261
0262 choice_option: T_PROMPT T_WORD_QUOTE if_expr T_EOL
0263 {
0264 menu_add_prompt(P_PROMPT, $2, $3);
0265 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
0266 };
0267
0268 choice_option: logic_type prompt_stmt_opt T_EOL
0269 {
0270 menu_set_type($1);
0271 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
0272 zconf_curname(), zconf_lineno(), $1);
0273 };
0274
0275 choice_option: T_OPTIONAL T_EOL
0276 {
0277 current_entry->sym->flags |= SYMBOL_OPTIONAL;
0278 printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
0279 };
0280
0281 choice_option: T_DEFAULT nonconst_symbol if_expr T_EOL
0282 {
0283 menu_add_symbol(P_DEFAULT, $2, $3);
0284 printd(DEBUG_PARSE, "%s:%d:default\n",
0285 zconf_curname(), zconf_lineno());
0286 };
0287
0288 type:
0289 logic_type
0290 | T_INT { $$ = S_INT; }
0291 | T_HEX { $$ = S_HEX; }
0292 | T_STRING { $$ = S_STRING; }
0293
0294 logic_type:
0295 T_BOOL { $$ = S_BOOLEAN; }
0296 | T_TRISTATE { $$ = S_TRISTATE; }
0297
0298 default:
0299 T_DEFAULT { $$ = S_UNKNOWN; }
0300 | T_DEF_BOOL { $$ = S_BOOLEAN; }
0301 | T_DEF_TRISTATE { $$ = S_TRISTATE; }
0302
0303 /* if entry */
0304
0305 if_entry: T_IF expr T_EOL
0306 {
0307 printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
0308 menu_add_entry(NULL);
0309 menu_add_dep($2);
0310 $$ = menu_add_menu();
0311 };
0312
0313 if_end: end
0314 {
0315 if (zconf_endtoken($1, "if")) {
0316 menu_end_menu();
0317 printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
0318 }
0319 };
0320
0321 if_stmt: if_entry stmt_list if_end
0322 ;
0323
0324 if_stmt_in_choice: if_entry stmt_list_in_choice if_end
0325 ;
0326
0327 /* menu entry */
0328
0329 menu: T_MENU T_WORD_QUOTE T_EOL
0330 {
0331 menu_add_entry(NULL);
0332 menu_add_prompt(P_MENU, $2, NULL);
0333 printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
0334 };
0335
0336 menu_entry: menu menu_option_list
0337 {
0338 $$ = menu_add_menu();
0339 };
0340
0341 menu_end: end
0342 {
0343 if (zconf_endtoken($1, "menu")) {
0344 menu_end_menu();
0345 printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
0346 }
0347 };
0348
0349 menu_stmt: menu_entry stmt_list menu_end
0350 ;
0351
0352 menu_option_list:
0353 /* empty */
0354 | menu_option_list visible
0355 | menu_option_list depends
0356 ;
0357
0358 source_stmt: T_SOURCE T_WORD_QUOTE T_EOL
0359 {
0360 printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), $2);
0361 zconf_nextfile($2);
0362 free($2);
0363 };
0364
0365 /* comment entry */
0366
0367 comment: T_COMMENT T_WORD_QUOTE T_EOL
0368 {
0369 menu_add_entry(NULL);
0370 menu_add_prompt(P_COMMENT, $2, NULL);
0371 printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
0372 };
0373
0374 comment_stmt: comment comment_option_list
0375 ;
0376
0377 comment_option_list:
0378 /* empty */
0379 | comment_option_list depends
0380 ;
0381
0382 /* help option */
0383
0384 help_start: T_HELP T_EOL
0385 {
0386 printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
0387 zconf_starthelp();
0388 };
0389
0390 help: help_start T_HELPTEXT
0391 {
0392 if (current_entry->help) {
0393 free(current_entry->help);
0394 zconfprint("warning: '%s' defined with more than one help text -- only the last one will be used",
0395 current_entry->sym->name ?: "<choice>");
0396 }
0397
0398 /* Is the help text empty or all whitespace? */
0399 if ($2[strspn($2, " \f\n\r\t\v")] == '\0')
0400 zconfprint("warning: '%s' defined with blank help text",
0401 current_entry->sym->name ?: "<choice>");
0402
0403 current_entry->help = $2;
0404 };
0405
0406 /* depends option */
0407
0408 depends: T_DEPENDS T_ON expr T_EOL
0409 {
0410 menu_add_dep($3);
0411 printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
0412 };
0413
0414 /* visibility option */
0415 visible: T_VISIBLE if_expr T_EOL
0416 {
0417 menu_add_visibility($2);
0418 };
0419
0420 /* prompt statement */
0421
0422 prompt_stmt_opt:
0423 /* empty */
0424 | T_WORD_QUOTE if_expr
0425 {
0426 menu_add_prompt(P_PROMPT, $1, $2);
0427 };
0428
0429 end: T_ENDMENU T_EOL { $$ = "menu"; }
0430 | T_ENDCHOICE T_EOL { $$ = "choice"; }
0431 | T_ENDIF T_EOL { $$ = "if"; }
0432 ;
0433
0434 if_expr: /* empty */ { $$ = NULL; }
0435 | T_IF expr { $$ = $2; }
0436 ;
0437
0438 expr: symbol { $$ = expr_alloc_symbol($1); }
0439 | symbol T_LESS symbol { $$ = expr_alloc_comp(E_LTH, $1, $3); }
0440 | symbol T_LESS_EQUAL symbol { $$ = expr_alloc_comp(E_LEQ, $1, $3); }
0441 | symbol T_GREATER symbol { $$ = expr_alloc_comp(E_GTH, $1, $3); }
0442 | symbol T_GREATER_EQUAL symbol { $$ = expr_alloc_comp(E_GEQ, $1, $3); }
0443 | symbol T_EQUAL symbol { $$ = expr_alloc_comp(E_EQUAL, $1, $3); }
0444 | symbol T_UNEQUAL symbol { $$ = expr_alloc_comp(E_UNEQUAL, $1, $3); }
0445 | T_OPEN_PAREN expr T_CLOSE_PAREN { $$ = $2; }
0446 | T_NOT expr { $$ = expr_alloc_one(E_NOT, $2); }
0447 | expr T_OR expr { $$ = expr_alloc_two(E_OR, $1, $3); }
0448 | expr T_AND expr { $$ = expr_alloc_two(E_AND, $1, $3); }
0449 ;
0450
0451 /* For symbol definitions, selects, etc., where quotes are not accepted */
0452 nonconst_symbol: T_WORD { $$ = sym_lookup($1, 0); free($1); };
0453
0454 symbol: nonconst_symbol
0455 | T_WORD_QUOTE { $$ = sym_lookup($1, SYMBOL_CONST); free($1); }
0456 ;
0457
0458 word_opt: /* empty */ { $$ = NULL; }
0459 | T_WORD
0460
0461 /* assignment statement */
0462
0463 assignment_stmt: T_WORD assign_op assign_val T_EOL { variable_add($1, $3, $2); free($1); free($3); }
0464
0465 assign_op:
0466 T_EQUAL { $$ = VAR_RECURSIVE; }
0467 | T_COLON_EQUAL { $$ = VAR_SIMPLE; }
0468 | T_PLUS_EQUAL { $$ = VAR_APPEND; }
0469 ;
0470
0471 assign_val:
0472 /* empty */ { $$ = xstrdup(""); };
0473 | T_ASSIGN_VAL
0474 ;
0475
0476 %%
0477
0478 void conf_parse(const char *name)
0479 {
0480 struct symbol *sym;
0481 int i;
0482
0483 zconf_initscan(name);
0484
0485 _menu_init();
0486
0487 if (getenv("ZCONF_DEBUG"))
0488 yydebug = 1;
0489 yyparse();
0490
0491 /* Variables are expanded in the parse phase. We can free them here. */
0492 variable_all_del();
0493
0494 if (yynerrs)
0495 exit(1);
0496 if (!modules_sym)
0497 modules_sym = sym_find( "n" );
0498
0499 if (!menu_has_prompt(&rootmenu)) {
0500 current_entry = &rootmenu;
0501 menu_add_prompt(P_MENU, "Main menu", NULL);
0502 }
0503
0504 menu_finalize(&rootmenu);
0505 for_all_symbols(i, sym) {
0506 if (sym_check_deps(sym))
0507 yynerrs++;
0508 }
0509 if (yynerrs)
0510 exit(1);
0511 conf_set_changed(true);
0512 }
0513
0514 static bool zconf_endtoken(const char *tokenname,
0515 const char *expected_tokenname)
0516 {
0517 if (strcmp(tokenname, expected_tokenname)) {
0518 zconf_error("unexpected '%s' within %s block",
0519 tokenname, expected_tokenname);
0520 yynerrs++;
0521 return false;
0522 }
0523 if (current_menu->file != current_file) {
0524 zconf_error("'%s' in different file than '%s'",
0525 tokenname, expected_tokenname);
0526 fprintf(stderr, "%s:%d: location of the '%s'\n",
0527 current_menu->file->name, current_menu->lineno,
0528 expected_tokenname);
0529 yynerrs++;
0530 return false;
0531 }
0532 return true;
0533 }
0534
0535 static void zconfprint(const char *err, ...)
0536 {
0537 va_list ap;
0538
0539 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
0540 va_start(ap, err);
0541 vfprintf(stderr, err, ap);
0542 va_end(ap);
0543 fprintf(stderr, "\n");
0544 }
0545
0546 static void zconf_error(const char *err, ...)
0547 {
0548 va_list ap;
0549
0550 yynerrs++;
0551 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
0552 va_start(ap, err);
0553 vfprintf(stderr, err, ap);
0554 va_end(ap);
0555 fprintf(stderr, "\n");
0556 }
0557
0558 static void yyerror(const char *err)
0559 {
0560 fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
0561 }
0562
0563 static void print_quoted_string(FILE *out, const char *str)
0564 {
0565 const char *p;
0566 int len;
0567
0568 putc('"', out);
0569 while ((p = strchr(str, '"'))) {
0570 len = p - str;
0571 if (len)
0572 fprintf(out, "%.*s", len, str);
0573 fputs("\\\"", out);
0574 str = p + 1;
0575 }
0576 fputs(str, out);
0577 putc('"', out);
0578 }
0579
0580 static void print_symbol(FILE *out, struct menu *menu)
0581 {
0582 struct symbol *sym = menu->sym;
0583 struct property *prop;
0584
0585 if (sym_is_choice(sym))
0586 fprintf(out, "\nchoice\n");
0587 else
0588 fprintf(out, "\nconfig %s\n", sym->name);
0589 switch (sym->type) {
0590 case S_BOOLEAN:
0591 fputs(" bool\n", out);
0592 break;
0593 case S_TRISTATE:
0594 fputs(" tristate\n", out);
0595 break;
0596 case S_STRING:
0597 fputs(" string\n", out);
0598 break;
0599 case S_INT:
0600 fputs(" integer\n", out);
0601 break;
0602 case S_HEX:
0603 fputs(" hex\n", out);
0604 break;
0605 default:
0606 fputs(" ???\n", out);
0607 break;
0608 }
0609 for (prop = sym->prop; prop; prop = prop->next) {
0610 if (prop->menu != menu)
0611 continue;
0612 switch (prop->type) {
0613 case P_PROMPT:
0614 fputs(" prompt ", out);
0615 print_quoted_string(out, prop->text);
0616 if (!expr_is_yes(prop->visible.expr)) {
0617 fputs(" if ", out);
0618 expr_fprint(prop->visible.expr, out);
0619 }
0620 fputc('\n', out);
0621 break;
0622 case P_DEFAULT:
0623 fputs( " default ", out);
0624 expr_fprint(prop->expr, out);
0625 if (!expr_is_yes(prop->visible.expr)) {
0626 fputs(" if ", out);
0627 expr_fprint(prop->visible.expr, out);
0628 }
0629 fputc('\n', out);
0630 break;
0631 case P_CHOICE:
0632 fputs(" #choice value\n", out);
0633 break;
0634 case P_SELECT:
0635 fputs( " select ", out);
0636 expr_fprint(prop->expr, out);
0637 fputc('\n', out);
0638 break;
0639 case P_IMPLY:
0640 fputs( " imply ", out);
0641 expr_fprint(prop->expr, out);
0642 fputc('\n', out);
0643 break;
0644 case P_RANGE:
0645 fputs( " range ", out);
0646 expr_fprint(prop->expr, out);
0647 fputc('\n', out);
0648 break;
0649 case P_MENU:
0650 fputs( " menu ", out);
0651 print_quoted_string(out, prop->text);
0652 fputc('\n', out);
0653 break;
0654 case P_SYMBOL:
0655 fputs( " symbol ", out);
0656 fprintf(out, "%s\n", prop->menu->sym->name);
0657 break;
0658 default:
0659 fprintf(out, " unknown prop %d!\n", prop->type);
0660 break;
0661 }
0662 }
0663 if (menu->help) {
0664 int len = strlen(menu->help);
0665 while (menu->help[--len] == '\n')
0666 menu->help[len] = 0;
0667 fprintf(out, " help\n%s\n", menu->help);
0668 }
0669 }
0670
0671 void zconfdump(FILE *out)
0672 {
0673 struct property *prop;
0674 struct symbol *sym;
0675 struct menu *menu;
0676
0677 menu = rootmenu.list;
0678 while (menu) {
0679 if ((sym = menu->sym))
0680 print_symbol(out, menu);
0681 else if ((prop = menu->prompt)) {
0682 switch (prop->type) {
0683 case P_COMMENT:
0684 fputs("\ncomment ", out);
0685 print_quoted_string(out, prop->text);
0686 fputs("\n", out);
0687 break;
0688 case P_MENU:
0689 fputs("\nmenu ", out);
0690 print_quoted_string(out, prop->text);
0691 fputs("\n", out);
0692 break;
0693 default:
0694 ;
0695 }
0696 if (!expr_is_yes(prop->visible.expr)) {
0697 fputs(" depends ", out);
0698 expr_fprint(prop->visible.expr, out);
0699 fputc('\n', out);
0700 }
0701 }
0702
0703 if (menu->list)
0704 menu = menu->list;
0705 else if (menu->next)
0706 menu = menu->next;
0707 else while ((menu = menu->parent)) {
0708 if (menu->prompt && menu->prompt->type == P_MENU)
0709 fputs("\nendmenu\n", out);
0710 if (menu->next) {
0711 menu = menu->next;
0712 break;
0713 }
0714 }
0715 }
0716 }
