1/* A Bison parser, made by GNU Bison 2.5. */ 2 3/* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20/* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33/* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36/* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43/* Identify Bison output. */ 44#define YYBISON 1 45 46/* Bison version. */ 47#define YYBISON_VERSION "2.5" 48 49/* Skeleton name. */ 50#define YYSKELETON_NAME "yacc.c" 51 52/* Pure parsers. */ 53#define YYPURE 0 54 55/* Push parsers. */ 56#define YYPUSH 0 57 58/* Pull parsers. */ 59#define YYPULL 1 60 61/* Using locations. */ 62#define YYLSP_NEEDED 0 63 64 65 66/* Copy the first part of user declarations. */ 67 68/* Line 268 of yacc.c */ 69#line 1 "winprefsyacc.y" 70 71/* 72 * Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved. 73 * Copyright (C) Colin Harrison 2005-2008 74 * 75 * Permission is hereby granted, free of charge, to any person obtaining 76 * a copy of this software and associated documentation files (the 77 * "Software"), to deal in the Software without restriction, including 78 * without limitation the rights to use, copy, modify, merge, publish, 79 * distribute, sublicense, and/or sell copies of the Software, and to 80 * permit persons to whom the Software is furnished to do so, subject to 81 * the following conditions: 82 * 83 * The above copyright notice and this permission notice shall be 84 * included in all copies or substantial portions of the Software. 85 * 86 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 87 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 88 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 89 * NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR 90 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF 91 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 92 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 93 * 94 * Except as contained in this notice, the name of the XFree86 Project 95 * shall not be used in advertising or otherwise to promote the sale, use 96 * or other dealings in this Software without prior written authorization 97 * from the XFree86 Project. 98 * 99 * Authors: Earle F. Philhower, III 100 * Colin Harrison 101 */ 102/* $XFree86: $ */ 103 104#ifdef HAVE_XWIN_CONFIG_H 105#include <xwin-config.h> 106#endif 107#include <stdio.h> 108#include <stdlib.h> 109#include <string.h> 110#include "winprefs.h" 111 112/* The following give better error messages in bison at the cost of a few KB */ 113#define YYERROR_VERBOSE 1 114 115/* YYLTYPE_IS_TRIVIAL and YYENABLE_NLS defined to suppress warnings */ 116#define YYLTYPE_IS_TRIVIAL 1 117#define YYENABLE_NLS 0 118 119/* The global pref settings */ 120WINPREFS pref; 121 122/* The working menu */ 123static MENUPARSED menu; 124 125/* Functions for parsing the tokens into out structure */ 126/* Defined at the end section of this file */ 127 128static void SetIconDirectory (char *path); 129static void SetDefaultIcon (char *fname); 130static void SetRootMenu (char *menu); 131static void SetDefaultSysMenu (char *menu, int pos); 132static void SetTrayIcon (char *fname); 133 134static void OpenMenu(char *menuname); 135static void AddMenuLine(char *name, MENUCOMMANDTYPE cmd, char *param); 136static void CloseMenu(void); 137 138static void OpenIcons(void); 139static void AddIconLine(char *matchstr, char *iconfile); 140static void CloseIcons(void); 141 142static void OpenStyles(void); 143static void AddStyleLine(char *matchstr, unsigned long style); 144static void CloseStyles(void); 145 146static void OpenSysMenu(void); 147static void AddSysMenuLine(char *matchstr, char *menuname, int pos); 148static void CloseSysMenu(void); 149 150static int yyerror (char *s); 151 152extern void ErrorF (const char* /*f*/, ...); 153extern char *yytext; 154extern int yylex(void); 155 156 157 158/* Line 268 of yacc.c */ 159#line 160 "winprefsyacc.c" 160 161/* Enabling traces. */ 162#ifndef YYDEBUG 163# define YYDEBUG 0 164#endif 165 166/* Enabling verbose error messages. */ 167#ifdef YYERROR_VERBOSE 168# undef YYERROR_VERBOSE 169# define YYERROR_VERBOSE 1 170#else 171# define YYERROR_VERBOSE 0 172#endif 173 174/* Enabling the token table. */ 175#ifndef YYTOKEN_TABLE 176# define YYTOKEN_TABLE 0 177#endif 178 179 180/* Tokens. */ 181#ifndef YYTOKENTYPE 182# define YYTOKENTYPE 183 /* Put the tokens into the symbol table, so that GDB and other debuggers 184 know about them. */ 185 enum yytokentype { 186 NEWLINE = 258, 187 MENU = 259, 188 LB = 260, 189 RB = 261, 190 ICONDIRECTORY = 262, 191 DEFAULTICON = 263, 192 ICONS = 264, 193 STYLES = 265, 194 TOPMOST = 266, 195 MAXIMIZE = 267, 196 MINIMIZE = 268, 197 BOTTOM = 269, 198 NOTITLE = 270, 199 OUTLINE = 271, 200 NOFRAME = 272, 201 DEFAULTSYSMENU = 273, 202 SYSMENU = 274, 203 ROOTMENU = 275, 204 SEPARATOR = 276, 205 ATSTART = 277, 206 ATEND = 278, 207 EXEC = 279, 208 ALWAYSONTOP = 280, 209 DEBUGOUTPUT = 281, 210 RELOAD = 282, 211 TRAYICON = 283, 212 FORCEEXIT = 284, 213 SILENTEXIT = 285, 214 STRING = 286 215 }; 216#endif 217/* Tokens. */ 218#define NEWLINE 258 219#define MENU 259 220#define LB 260 221#define RB 261 222#define ICONDIRECTORY 262 223#define DEFAULTICON 263 224#define ICONS 264 225#define STYLES 265 226#define TOPMOST 266 227#define MAXIMIZE 267 228#define MINIMIZE 268 229#define BOTTOM 269 230#define NOTITLE 270 231#define OUTLINE 271 232#define NOFRAME 272 233#define DEFAULTSYSMENU 273 234#define SYSMENU 274 235#define ROOTMENU 275 236#define SEPARATOR 276 237#define ATSTART 277 238#define ATEND 278 239#define EXEC 279 240#define ALWAYSONTOP 280 241#define DEBUGOUTPUT 281 242#define RELOAD 282 243#define TRAYICON 283 244#define FORCEEXIT 284 245#define SILENTEXIT 285 246#define STRING 286 247 248 249 250 251#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 252typedef union YYSTYPE 253{ 254 255/* Line 293 of yacc.c */ 256#line 89 "winprefsyacc.y" 257 258 char *sVal; 259 unsigned long uVal; 260 int iVal; 261 262 263 264/* Line 293 of yacc.c */ 265#line 266 "winprefsyacc.c" 266} YYSTYPE; 267# define YYSTYPE_IS_TRIVIAL 1 268# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 269# define YYSTYPE_IS_DECLARED 1 270#endif 271 272 273/* Copy the second part of user declarations. */ 274 275 276/* Line 343 of yacc.c */ 277#line 278 "winprefsyacc.c" 278 279#ifdef short 280# undef short 281#endif 282 283#ifdef YYTYPE_UINT8 284typedef YYTYPE_UINT8 yytype_uint8; 285#else 286typedef unsigned char yytype_uint8; 287#endif 288 289#ifdef YYTYPE_INT8 290typedef YYTYPE_INT8 yytype_int8; 291#elif (defined __STDC__ || defined __C99__FUNC__ \ 292 || defined __cplusplus || defined _MSC_VER) 293typedef signed char yytype_int8; 294#else 295typedef short int yytype_int8; 296#endif 297 298#ifdef YYTYPE_UINT16 299typedef YYTYPE_UINT16 yytype_uint16; 300#else 301typedef unsigned short int yytype_uint16; 302#endif 303 304#ifdef YYTYPE_INT16 305typedef YYTYPE_INT16 yytype_int16; 306#else 307typedef short int yytype_int16; 308#endif 309 310#ifndef YYSIZE_T 311# ifdef __SIZE_TYPE__ 312# define YYSIZE_T __SIZE_TYPE__ 313# elif defined size_t 314# define YYSIZE_T size_t 315# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 316 || defined __cplusplus || defined _MSC_VER) 317# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 318# define YYSIZE_T size_t 319# else 320# define YYSIZE_T unsigned int 321# endif 322#endif 323 324#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 325 326#ifndef YY_ 327# if defined YYENABLE_NLS && YYENABLE_NLS 328# if ENABLE_NLS 329# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 330# define YY_(msgid) dgettext ("bison-runtime", msgid) 331# endif 332# endif 333# ifndef YY_ 334# define YY_(msgid) msgid 335# endif 336#endif 337 338/* Suppress unused-variable warnings by "using" E. */ 339#if ! defined lint || defined __GNUC__ 340# define YYUSE(e) ((void) (e)) 341#else 342# define YYUSE(e) /* empty */ 343#endif 344 345/* Identity function, used to suppress warnings about constant conditions. */ 346#ifndef lint 347# define YYID(n) (n) 348#else 349#if (defined __STDC__ || defined __C99__FUNC__ \ 350 || defined __cplusplus || defined _MSC_VER) 351static int 352YYID (int yyi) 353#else 354static int 355YYID (yyi) 356 int yyi; 357#endif 358{ 359 return yyi; 360} 361#endif 362 363#if ! defined yyoverflow || YYERROR_VERBOSE 364 365/* The parser invokes alloca or malloc; define the necessary symbols. */ 366 367# ifdef YYSTACK_USE_ALLOCA 368# if YYSTACK_USE_ALLOCA 369# ifdef __GNUC__ 370# define YYSTACK_ALLOC __builtin_alloca 371# elif defined __BUILTIN_VA_ARG_INCR 372# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 373# elif defined _AIX 374# define YYSTACK_ALLOC __alloca 375# elif defined _MSC_VER 376# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 377# define alloca _alloca 378# else 379# define YYSTACK_ALLOC alloca 380# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 381 || defined __cplusplus || defined _MSC_VER) 382# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 383# ifndef EXIT_SUCCESS 384# define EXIT_SUCCESS 0 385# endif 386# endif 387# endif 388# endif 389# endif 390 391# ifdef YYSTACK_ALLOC 392 /* Pacify GCC's `empty if-body' warning. */ 393# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 394# ifndef YYSTACK_ALLOC_MAXIMUM 395 /* The OS might guarantee only one guard page at the bottom of the stack, 396 and a page size can be as small as 4096 bytes. So we cannot safely 397 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 398 to allow for a few compiler-allocated temporary stack slots. */ 399# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 400# endif 401# else 402# define YYSTACK_ALLOC YYMALLOC 403# define YYSTACK_FREE YYFREE 404# ifndef YYSTACK_ALLOC_MAXIMUM 405# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 406# endif 407# if (defined __cplusplus && ! defined EXIT_SUCCESS \ 408 && ! ((defined YYMALLOC || defined malloc) \ 409 && (defined YYFREE || defined free))) 410# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 411# ifndef EXIT_SUCCESS 412# define EXIT_SUCCESS 0 413# endif 414# endif 415# ifndef YYMALLOC 416# define YYMALLOC malloc 417# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 418 || defined __cplusplus || defined _MSC_VER) 419void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 420# endif 421# endif 422# ifndef YYFREE 423# define YYFREE free 424# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 425 || defined __cplusplus || defined _MSC_VER) 426void free (void *); /* INFRINGES ON USER NAME SPACE */ 427# endif 428# endif 429# endif 430#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 431 432 433#if (! defined yyoverflow \ 434 && (! defined __cplusplus \ 435 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 436 437/* A type that is properly aligned for any stack member. */ 438union yyalloc 439{ 440 yytype_int16 yyss_alloc; 441 YYSTYPE yyvs_alloc; 442}; 443 444/* The size of the maximum gap between one aligned stack and the next. */ 445# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 446 447/* The size of an array large to enough to hold all stacks, each with 448 N elements. */ 449# define YYSTACK_BYTES(N) \ 450 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 451 + YYSTACK_GAP_MAXIMUM) 452 453# define YYCOPY_NEEDED 1 454 455/* Relocate STACK from its old location to the new one. The 456 local variables YYSIZE and YYSTACKSIZE give the old and new number of 457 elements in the stack, and YYPTR gives the new location of the 458 stack. Advance YYPTR to a properly aligned location for the next 459 stack. */ 460# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 461 do \ 462 { \ 463 YYSIZE_T yynewbytes; \ 464 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 465 Stack = &yyptr->Stack_alloc; \ 466 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 467 yyptr += yynewbytes / sizeof (*yyptr); \ 468 } \ 469 while (YYID (0)) 470 471#endif 472 473#if defined YYCOPY_NEEDED && YYCOPY_NEEDED 474/* Copy COUNT objects from FROM to TO. The source and destination do 475 not overlap. */ 476# ifndef YYCOPY 477# if defined __GNUC__ && 1 < __GNUC__ 478# define YYCOPY(To, From, Count) \ 479 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 480# else 481# define YYCOPY(To, From, Count) \ 482 do \ 483 { \ 484 YYSIZE_T yyi; \ 485 for (yyi = 0; yyi < (Count); yyi++) \ 486 (To)[yyi] = (From)[yyi]; \ 487 } \ 488 while (YYID (0)) 489# endif 490# endif 491#endif /* !YYCOPY_NEEDED */ 492 493/* YYFINAL -- State number of the termination state. */ 494#define YYFINAL 2 495/* YYLAST -- Last index in YYTABLE. */ 496#define YYLAST 98 497 498/* YYNTOKENS -- Number of terminals. */ 499#define YYNTOKENS 32 500/* YYNNTS -- Number of nonterminals. */ 501#define YYNNTS 33 502/* YYNRULES -- Number of rules. */ 503#define YYNRULES 65 504/* YYNRULES -- Number of states. */ 505#define YYNSTATES 121 506 507/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 508#define YYUNDEFTOK 2 509#define YYMAXUTOK 286 510 511#define YYTRANSLATE(YYX) \ 512 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 513 514/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 515static const yytype_uint8 yytranslate[] = 516{ 517 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 518 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 521 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 523 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 524 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 540 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 542 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 543 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 544 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 545 25, 26, 27, 28, 29, 30, 31 546}; 547 548#if YYDEBUG 549/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 550 YYRHS. */ 551static const yytype_uint8 yyprhs[] = 552{ 553 0, 0, 3, 4, 7, 9, 11, 12, 15, 17, 554 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 555 39, 43, 47, 52, 56, 60, 64, 69, 75, 81, 556 86, 88, 91, 92, 100, 105, 107, 110, 111, 118, 557 120, 122, 124, 126, 128, 130, 132, 134, 136, 139, 558 142, 147, 149, 152, 153, 160, 161, 163, 165, 171, 559 173, 176, 177, 185, 188, 191 560}; 561 562/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 563static const yytype_int8 yyrhs[] = 564{ 565 33, 0, -1, -1, 33, 34, -1, 3, -1, 36, 566 -1, -1, 3, 35, -1, 40, -1, 41, -1, 44, 567 -1, 48, -1, 55, -1, 60, -1, 38, -1, 39, 568 -1, 64, -1, 37, -1, 62, -1, 63, -1, 28, 569 31, 3, -1, 20, 31, 3, -1, 18, 31, 57, 570 3, -1, 8, 31, 3, -1, 7, 31, 3, -1, 571 21, 3, 35, -1, 31, 25, 3, 35, -1, 31, 572 24, 31, 3, 35, -1, 31, 4, 31, 3, 35, 573 -1, 31, 27, 3, 35, -1, 42, -1, 42, 43, 574 -1, -1, 4, 31, 5, 45, 35, 43, 6, -1, 575 31, 31, 3, 35, -1, 46, -1, 46, 47, -1, 576 -1, 9, 5, 49, 35, 47, 6, -1, 11, -1, 577 12, -1, 13, -1, 14, -1, 15, -1, 16, -1, 578 17, -1, 50, -1, 51, -1, 50, 51, -1, 51, 579 50, -1, 31, 52, 3, 35, -1, 53, -1, 53, 580 54, -1, -1, 10, 5, 56, 35, 54, 6, -1, 581 -1, 22, -1, 23, -1, 31, 31, 57, 3, 35, 582 -1, 58, -1, 58, 59, -1, -1, 19, 5, 3, 583 61, 35, 59, 6, -1, 29, 3, -1, 30, 3, 584 -1, 26, 31, 3, -1 585}; 586 587/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 588static const yytype_uint8 yyrline[] = 589{ 590 0, 132, 132, 133, 136, 137, 141, 142, 145, 146, 591 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 592 159, 162, 165, 168, 171, 174, 175, 176, 177, 178, 593 181, 182, 185, 185, 188, 191, 192, 195, 195, 198, 594 199, 200, 201, 204, 205, 206, 209, 210, 211, 212, 595 215, 218, 219, 222, 222, 225, 226, 227, 230, 233, 596 234, 237, 237, 240, 243, 246 597}; 598#endif 599 600#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 601/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 602 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 603static const char *const yytname[] = 604{ 605 "$end", "error", "$undefined", "NEWLINE", "MENU", "LB", "RB", 606 "ICONDIRECTORY", "DEFAULTICON", "ICONS", "STYLES", "TOPMOST", "MAXIMIZE", 607 "MINIMIZE", "BOTTOM", "NOTITLE", "OUTLINE", "NOFRAME", "DEFAULTSYSMENU", 608 "SYSMENU", "ROOTMENU", "SEPARATOR", "ATSTART", "ATEND", "EXEC", 609 "ALWAYSONTOP", "\"DEBUG\"", "RELOAD", "TRAYICON", "FORCEEXIT", 610 "SILENTEXIT", "STRING", "$accept", "input", "line", "newline_or_nada", 611 "command", "trayicon", "rootmenu", "defaultsysmenu", "defaulticon", 612 "icondirectory", "menuline", "menulist", "menu", "$@1", "iconline", 613 "iconlist", "icons", "$@2", "group1", "group2", "stylecombo", 614 "styleline", "stylelist", "styles", "$@3", "atspot", "sysmenuline", 615 "sysmenulist", "sysmenu", "$@4", "forceexit", "silentexit", "debug", 0 616}; 617#endif 618 619# ifdef YYPRINT 620/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 621 token YYLEX-NUM. */ 622static const yytype_uint16 yytoknum[] = 623{ 624 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 625 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 626 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 627 285, 286 628}; 629# endif 630 631/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 632static const yytype_uint8 yyr1[] = 633{ 634 0, 32, 33, 33, 34, 34, 35, 35, 36, 36, 635 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 636 37, 38, 39, 40, 41, 42, 42, 42, 42, 42, 637 43, 43, 45, 44, 46, 47, 47, 49, 48, 50, 638 50, 50, 50, 51, 51, 51, 52, 52, 52, 52, 639 53, 54, 54, 56, 55, 57, 57, 57, 58, 59, 640 59, 61, 60, 62, 63, 64 641}; 642 643/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 644static const yytype_uint8 yyr2[] = 645{ 646 0, 2, 0, 2, 1, 1, 0, 2, 1, 1, 647 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 648 3, 3, 4, 3, 3, 3, 4, 5, 5, 4, 649 1, 2, 0, 7, 4, 1, 2, 0, 6, 1, 650 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 651 4, 1, 2, 0, 6, 0, 1, 1, 5, 1, 652 2, 0, 7, 2, 2, 3 653}; 654 655/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 656 Performed when YYTABLE doesn't specify something else to do. Zero 657 means the default is an error. */ 658static const yytype_uint8 yydefact[] = 659{ 660 2, 0, 1, 4, 0, 0, 0, 0, 0, 0, 661 0, 0, 0, 0, 0, 0, 3, 5, 17, 14, 662 15, 8, 9, 10, 11, 12, 13, 18, 19, 16, 663 0, 0, 0, 37, 53, 55, 0, 0, 0, 0, 664 63, 64, 32, 24, 23, 6, 6, 56, 57, 0, 665 61, 21, 65, 20, 6, 6, 0, 0, 22, 6, 666 0, 7, 0, 35, 0, 0, 51, 0, 0, 0, 667 0, 30, 0, 0, 36, 38, 39, 40, 41, 42, 668 43, 44, 45, 46, 47, 0, 52, 54, 0, 59, 669 0, 6, 0, 0, 0, 0, 31, 33, 6, 48, 670 49, 6, 55, 60, 62, 25, 0, 0, 6, 6, 671 34, 50, 0, 6, 6, 26, 29, 6, 28, 27, 672 58 673}; 674 675/* YYDEFGOTO[NTERM-NUM]. */ 676static const yytype_int8 yydefgoto[] = 677{ 678 -1, 1, 16, 56, 17, 18, 19, 20, 21, 22, 679 71, 72, 23, 54, 63, 64, 24, 45, 83, 84, 680 85, 66, 67, 25, 46, 49, 89, 90, 26, 59, 681 27, 28, 29 682}; 683 684/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 685 STATE-NUM. */ 686#define YYPACT_NINF -47 687static const yytype_int8 yypact[] = 688{ 689 -47, 7, -47, -47, -1, 0, 1, 18, 29, 15, 690 42, 17, 19, 20, 46, 50, -47, -47, -47, -47, 691 -47, -47, -47, -47, -47, -47, -47, -47, -47, -47, 692 49, 53, 54, -47, -47, 6, 55, 56, 57, 58, 693 -47, -47, -47, -47, -47, 61, 61, -47, -47, 62, 694 -47, -47, -47, -47, 61, 61, 35, 38, -47, 61, 695 -19, -47, 39, 35, 66, 27, 38, 67, 43, 72, 696 -3, -19, 70, 74, -47, -47, -47, -47, -47, -47, 697 -47, -47, -47, 3, -8, 75, -47, -47, 48, 43, 698 76, 61, 52, 59, 77, 78, -47, -47, 61, -47, 699 -47, 61, 6, -47, -47, -47, 81, 82, 61, 61, 700 -47, -47, 83, 61, 61, -47, -47, 61, -47, -47, 701 -47 702}; 703 704/* YYPGOTO[NTERM-NUM]. */ 705static const yytype_int8 yypgoto[] = 706{ 707 -47, -47, -47, -46, -47, -47, -47, -47, -47, -47, 708 -47, 16, -47, -47, -47, 25, -47, -47, 5, 8, 709 -47, -47, 26, -47, -47, -9, -47, 9, -47, -47, 710 -47, -47, -47 711}; 712 713/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 714 positive, shift that token. If negative, reduce the rule which 715 number is the opposite. If YYTABLE_NINF, syntax error. */ 716#define YYTABLE_NINF -1 717static const yytype_uint8 yytable[] = 718{ 719 57, 92, 69, 76, 77, 78, 79, 2, 60, 61, 720 3, 4, 70, 68, 5, 6, 7, 8, 80, 81, 721 82, 93, 94, 33, 95, 9, 10, 11, 47, 48, 722 30, 31, 32, 12, 34, 13, 14, 15, 76, 77, 723 78, 79, 80, 81, 82, 105, 35, 36, 37, 40, 724 38, 39, 110, 41, 42, 111, 43, 44, 50, 51, 725 52, 53, 115, 116, 55, 58, 62, 118, 119, 65, 726 73, 120, 75, 87, 88, 91, 97, 98, 101, 102, 727 108, 109, 104, 106, 113, 114, 117, 96, 74, 100, 728 107, 99, 86, 112, 0, 0, 0, 0, 103 729}; 730 731#define yypact_value_is_default(yystate) \ 732 ((yystate) == (-47)) 733 734#define yytable_value_is_error(yytable_value) \ 735 YYID (0) 736 737static const yytype_int8 yycheck[] = 738{ 739 46, 4, 21, 11, 12, 13, 14, 0, 54, 55, 740 3, 4, 31, 59, 7, 8, 9, 10, 15, 16, 741 17, 24, 25, 5, 27, 18, 19, 20, 22, 23, 742 31, 31, 31, 26, 5, 28, 29, 30, 11, 12, 743 13, 14, 15, 16, 17, 91, 31, 5, 31, 3, 744 31, 31, 98, 3, 5, 101, 3, 3, 3, 3, 745 3, 3, 108, 109, 3, 3, 31, 113, 114, 31, 746 31, 117, 6, 6, 31, 3, 6, 3, 3, 31, 747 3, 3, 6, 31, 3, 3, 3, 71, 63, 84, 748 31, 83, 66, 102, -1, -1, -1, -1, 89 749}; 750 751/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 752 symbol of state STATE-NUM. */ 753static const yytype_uint8 yystos[] = 754{ 755 0, 33, 0, 3, 4, 7, 8, 9, 10, 18, 756 19, 20, 26, 28, 29, 30, 34, 36, 37, 38, 757 39, 40, 41, 44, 48, 55, 60, 62, 63, 64, 758 31, 31, 31, 5, 5, 31, 5, 31, 31, 31, 759 3, 3, 5, 3, 3, 49, 56, 22, 23, 57, 760 3, 3, 3, 3, 45, 3, 35, 35, 3, 61, 761 35, 35, 31, 46, 47, 31, 53, 54, 35, 21, 762 31, 42, 43, 31, 47, 6, 11, 12, 13, 14, 763 15, 16, 17, 50, 51, 52, 54, 6, 31, 58, 764 59, 3, 4, 24, 25, 27, 43, 6, 3, 51, 765 50, 3, 31, 59, 6, 35, 31, 31, 3, 3, 766 35, 35, 57, 3, 3, 35, 35, 3, 35, 35, 767 35 768}; 769 770#define yyerrok (yyerrstatus = 0) 771#define yyclearin (yychar = YYEMPTY) 772#define YYEMPTY (-2) 773#define YYEOF 0 774 775#define YYACCEPT goto yyacceptlab 776#define YYABORT goto yyabortlab 777#define YYERROR goto yyerrorlab 778 779 780/* Like YYERROR except do call yyerror. This remains here temporarily 781 to ease the transition to the new meaning of YYERROR, for GCC. 782 Once GCC version 2 has supplanted version 1, this can go. However, 783 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 784 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 785 discussed. */ 786 787#define YYFAIL goto yyerrlab 788#if defined YYFAIL 789 /* This is here to suppress warnings from the GCC cpp's 790 -Wunused-macros. Normally we don't worry about that warning, but 791 some users do, and we want to make it easy for users to remove 792 YYFAIL uses, which will produce warnings from Bison 2.5. */ 793#endif 794 795#define YYRECOVERING() (!!yyerrstatus) 796 797#define YYBACKUP(Token, Value) \ 798do \ 799 if (yychar == YYEMPTY && yylen == 1) \ 800 { \ 801 yychar = (Token); \ 802 yylval = (Value); \ 803 YYPOPSTACK (1); \ 804 goto yybackup; \ 805 } \ 806 else \ 807 { \ 808 yyerror (YY_("syntax error: cannot back up")); \ 809 YYERROR; \ 810 } \ 811while (YYID (0)) 812 813 814#define YYTERROR 1 815#define YYERRCODE 256 816 817 818/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 819 If N is 0, then set CURRENT to the empty location which ends 820 the previous symbol: RHS[0] (always defined). */ 821 822#define YYRHSLOC(Rhs, K) ((Rhs)[K]) 823#ifndef YYLLOC_DEFAULT 824# define YYLLOC_DEFAULT(Current, Rhs, N) \ 825 do \ 826 if (YYID (N)) \ 827 { \ 828 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 829 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 830 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 831 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 832 } \ 833 else \ 834 { \ 835 (Current).first_line = (Current).last_line = \ 836 YYRHSLOC (Rhs, 0).last_line; \ 837 (Current).first_column = (Current).last_column = \ 838 YYRHSLOC (Rhs, 0).last_column; \ 839 } \ 840 while (YYID (0)) 841#endif 842 843 844/* This macro is provided for backward compatibility. */ 845 846#ifndef YY_LOCATION_PRINT 847# define YY_LOCATION_PRINT(File, Loc) ((void) 0) 848#endif 849 850 851/* YYLEX -- calling `yylex' with the right arguments. */ 852 853#ifdef YYLEX_PARAM 854# define YYLEX yylex (YYLEX_PARAM) 855#else 856# define YYLEX yylex () 857#endif 858 859/* Enable debugging if requested. */ 860#if YYDEBUG 861 862# ifndef YYFPRINTF 863# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 864# define YYFPRINTF fprintf 865# endif 866 867# define YYDPRINTF(Args) \ 868do { \ 869 if (yydebug) \ 870 YYFPRINTF Args; \ 871} while (YYID (0)) 872 873# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 874do { \ 875 if (yydebug) \ 876 { \ 877 YYFPRINTF (stderr, "%s ", Title); \ 878 yy_symbol_print (stderr, \ 879 Type, Value); \ 880 YYFPRINTF (stderr, "\n"); \ 881 } \ 882} while (YYID (0)) 883 884 885/*--------------------------------. 886| Print this symbol on YYOUTPUT. | 887`--------------------------------*/ 888 889/*ARGSUSED*/ 890#if (defined __STDC__ || defined __C99__FUNC__ \ 891 || defined __cplusplus || defined _MSC_VER) 892static void 893yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 894#else 895static void 896yy_symbol_value_print (yyoutput, yytype, yyvaluep) 897 FILE *yyoutput; 898 int yytype; 899 YYSTYPE const * const yyvaluep; 900#endif 901{ 902 if (!yyvaluep) 903 return; 904# ifdef YYPRINT 905 if (yytype < YYNTOKENS) 906 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 907# else 908 YYUSE (yyoutput); 909# endif 910 switch (yytype) 911 { 912 default: 913 break; 914 } 915} 916 917 918/*--------------------------------. 919| Print this symbol on YYOUTPUT. | 920`--------------------------------*/ 921 922#if (defined __STDC__ || defined __C99__FUNC__ \ 923 || defined __cplusplus || defined _MSC_VER) 924static void 925yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 926#else 927static void 928yy_symbol_print (yyoutput, yytype, yyvaluep) 929 FILE *yyoutput; 930 int yytype; 931 YYSTYPE const * const yyvaluep; 932#endif 933{ 934 if (yytype < YYNTOKENS) 935 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 936 else 937 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 938 939 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 940 YYFPRINTF (yyoutput, ")"); 941} 942 943/*------------------------------------------------------------------. 944| yy_stack_print -- Print the state stack from its BOTTOM up to its | 945| TOP (included). | 946`------------------------------------------------------------------*/ 947 948#if (defined __STDC__ || defined __C99__FUNC__ \ 949 || defined __cplusplus || defined _MSC_VER) 950static void 951yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 952#else 953static void 954yy_stack_print (yybottom, yytop) 955 yytype_int16 *yybottom; 956 yytype_int16 *yytop; 957#endif 958{ 959 YYFPRINTF (stderr, "Stack now"); 960 for (; yybottom <= yytop; yybottom++) 961 { 962 int yybot = *yybottom; 963 YYFPRINTF (stderr, " %d", yybot); 964 } 965 YYFPRINTF (stderr, "\n"); 966} 967 968# define YY_STACK_PRINT(Bottom, Top) \ 969do { \ 970 if (yydebug) \ 971 yy_stack_print ((Bottom), (Top)); \ 972} while (YYID (0)) 973 974 975/*------------------------------------------------. 976| Report that the YYRULE is going to be reduced. | 977`------------------------------------------------*/ 978 979#if (defined __STDC__ || defined __C99__FUNC__ \ 980 || defined __cplusplus || defined _MSC_VER) 981static void 982yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 983#else 984static void 985yy_reduce_print (yyvsp, yyrule) 986 YYSTYPE *yyvsp; 987 int yyrule; 988#endif 989{ 990 int yynrhs = yyr2[yyrule]; 991 int yyi; 992 unsigned long int yylno = yyrline[yyrule]; 993 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 994 yyrule - 1, yylno); 995 /* The symbols being reduced. */ 996 for (yyi = 0; yyi < yynrhs; yyi++) 997 { 998 YYFPRINTF (stderr, " $%d = ", yyi + 1); 999 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1000 &(yyvsp[(yyi + 1) - (yynrhs)]) 1001 ); 1002 YYFPRINTF (stderr, "\n"); 1003 } 1004} 1005 1006# define YY_REDUCE_PRINT(Rule) \ 1007do { \ 1008 if (yydebug) \ 1009 yy_reduce_print (yyvsp, Rule); \ 1010} while (YYID (0)) 1011 1012/* Nonzero means print parse trace. It is left uninitialized so that 1013 multiple parsers can coexist. */ 1014int yydebug; 1015#else /* !YYDEBUG */ 1016# define YYDPRINTF(Args) 1017# define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1018# define YY_STACK_PRINT(Bottom, Top) 1019# define YY_REDUCE_PRINT(Rule) 1020#endif /* !YYDEBUG */ 1021 1022 1023/* YYINITDEPTH -- initial size of the parser's stacks. */ 1024#ifndef YYINITDEPTH 1025# define YYINITDEPTH 200 1026#endif 1027 1028/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1029 if the built-in stack extension method is used). 1030 1031 Do not make this value too large; the results are undefined if 1032 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1033 evaluated with infinite-precision integer arithmetic. */ 1034 1035#ifndef YYMAXDEPTH 1036# define YYMAXDEPTH 10000 1037#endif 1038 1039 1040#if YYERROR_VERBOSE 1041 1042# ifndef yystrlen 1043# if defined __GLIBC__ && defined _STRING_H 1044# define yystrlen strlen 1045# else 1046/* Return the length of YYSTR. */ 1047#if (defined __STDC__ || defined __C99__FUNC__ \ 1048 || defined __cplusplus || defined _MSC_VER) 1049static YYSIZE_T 1050yystrlen (const char *yystr) 1051#else 1052static YYSIZE_T 1053yystrlen (yystr) 1054 const char *yystr; 1055#endif 1056{ 1057 YYSIZE_T yylen; 1058 for (yylen = 0; yystr[yylen]; yylen++) 1059 continue; 1060 return yylen; 1061} 1062# endif 1063# endif 1064 1065# ifndef yystpcpy 1066# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1067# define yystpcpy stpcpy 1068# else 1069/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1070 YYDEST. */ 1071#if (defined __STDC__ || defined __C99__FUNC__ \ 1072 || defined __cplusplus || defined _MSC_VER) 1073static char * 1074yystpcpy (char *yydest, const char *yysrc) 1075#else 1076static char * 1077yystpcpy (yydest, yysrc) 1078 char *yydest; 1079 const char *yysrc; 1080#endif 1081{ 1082 char *yyd = yydest; 1083 const char *yys = yysrc; 1084 1085 while ((*yyd++ = *yys++) != '\0') 1086 continue; 1087 1088 return yyd - 1; 1089} 1090# endif 1091# endif 1092 1093# ifndef yytnamerr 1094/* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1095 quotes and backslashes, so that it's suitable for yyerror. The 1096 heuristic is that double-quoting is unnecessary unless the string 1097 contains an apostrophe, a comma, or backslash (other than 1098 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1099 null, do not copy; instead, return the length of what the result 1100 would have been. */ 1101static YYSIZE_T 1102yytnamerr (char *yyres, const char *yystr) 1103{ 1104 if (*yystr == '"') 1105 { 1106 YYSIZE_T yyn = 0; 1107 char const *yyp = yystr; 1108 1109 for (;;) 1110 switch (*++yyp) 1111 { 1112 case '\'': 1113 case ',': 1114 goto do_not_strip_quotes; 1115 1116 case '\\': 1117 if (*++yyp != '\\') 1118 goto do_not_strip_quotes; 1119 /* Fall through. */ 1120 default: 1121 if (yyres) 1122 yyres[yyn] = *yyp; 1123 yyn++; 1124 break; 1125 1126 case '"': 1127 if (yyres) 1128 yyres[yyn] = '\0'; 1129 return yyn; 1130 } 1131 do_not_strip_quotes: ; 1132 } 1133 1134 if (! yyres) 1135 return yystrlen (yystr); 1136 1137 return yystpcpy (yyres, yystr) - yyres; 1138} 1139# endif 1140 1141/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1142 about the unexpected token YYTOKEN for the state stack whose top is 1143 YYSSP. 1144 1145 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1146 not large enough to hold the message. In that case, also set 1147 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1148 required number of bytes is too large to store. */ 1149static int 1150yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1151 yytype_int16 *yyssp, int yytoken) 1152{ 1153 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 1154 YYSIZE_T yysize = yysize0; 1155 YYSIZE_T yysize1; 1156 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1157 /* Internationalized format string. */ 1158 const char *yyformat = 0; 1159 /* Arguments of yyformat. */ 1160 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1161 /* Number of reported tokens (one for the "unexpected", one per 1162 "expected"). */ 1163 int yycount = 0; 1164 1165 /* There are many possibilities here to consider: 1166 - Assume YYFAIL is not used. It's too flawed to consider. See 1167 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1168 for details. YYERROR is fine as it does not invoke this 1169 function. 1170 - If this state is a consistent state with a default action, then 1171 the only way this function was invoked is if the default action 1172 is an error action. In that case, don't check for expected 1173 tokens because there are none. 1174 - The only way there can be no lookahead present (in yychar) is if 1175 this state is a consistent state with a default action. Thus, 1176 detecting the absence of a lookahead is sufficient to determine 1177 that there is no unexpected or expected token to report. In that 1178 case, just report a simple "syntax error". 1179 - Don't assume there isn't a lookahead just because this state is a 1180 consistent state with a default action. There might have been a 1181 previous inconsistent state, consistent state with a non-default 1182 action, or user semantic action that manipulated yychar. 1183 - Of course, the expected token list depends on states to have 1184 correct lookahead information, and it depends on the parser not 1185 to perform extra reductions after fetching a lookahead from the 1186 scanner and before detecting a syntax error. Thus, state merging 1187 (from LALR or IELR) and default reductions corrupt the expected 1188 token list. However, the list is correct for canonical LR with 1189 one exception: it will still contain any token that will not be 1190 accepted due to an error action in a later state. 1191 */ 1192 if (yytoken != YYEMPTY) 1193 { 1194 int yyn = yypact[*yyssp]; 1195 yyarg[yycount++] = yytname[yytoken]; 1196 if (!yypact_value_is_default (yyn)) 1197 { 1198 /* Start YYX at -YYN if negative to avoid negative indexes in 1199 YYCHECK. In other words, skip the first -YYN actions for 1200 this state because they are default actions. */ 1201 int yyxbegin = yyn < 0 ? -yyn : 0; 1202 /* Stay within bounds of both yycheck and yytname. */ 1203 int yychecklim = YYLAST - yyn + 1; 1204 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1205 int yyx; 1206 1207 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1208 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1209 && !yytable_value_is_error (yytable[yyx + yyn])) 1210 { 1211 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1212 { 1213 yycount = 1; 1214 yysize = yysize0; 1215 break; 1216 } 1217 yyarg[yycount++] = yytname[yyx]; 1218 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1219 if (! (yysize <= yysize1 1220 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1221 return 2; 1222 yysize = yysize1; 1223 } 1224 } 1225 } 1226 1227 switch (yycount) 1228 { 1229# define YYCASE_(N, S) \ 1230 case N: \ 1231 yyformat = S; \ 1232 break 1233 YYCASE_(0, YY_("syntax error")); 1234 YYCASE_(1, YY_("syntax error, unexpected %s")); 1235 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1236 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1237 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1238 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1239# undef YYCASE_ 1240 } 1241 1242 yysize1 = yysize + yystrlen (yyformat); 1243 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1244 return 2; 1245 yysize = yysize1; 1246 1247 if (*yymsg_alloc < yysize) 1248 { 1249 *yymsg_alloc = 2 * yysize; 1250 if (! (yysize <= *yymsg_alloc 1251 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1252 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1253 return 1; 1254 } 1255 1256 /* Avoid sprintf, as that infringes on the user's name space. 1257 Don't have undefined behavior even if the translation 1258 produced a string with the wrong number of "%s"s. */ 1259 { 1260 char *yyp = *yymsg; 1261 int yyi = 0; 1262 while ((*yyp = *yyformat) != '\0') 1263 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1264 { 1265 yyp += yytnamerr (yyp, yyarg[yyi++]); 1266 yyformat += 2; 1267 } 1268 else 1269 { 1270 yyp++; 1271 yyformat++; 1272 } 1273 } 1274 return 0; 1275} 1276#endif /* YYERROR_VERBOSE */ 1277 1278/*-----------------------------------------------. 1279| Release the memory associated to this symbol. | 1280`-----------------------------------------------*/ 1281 1282/*ARGSUSED*/ 1283#if (defined __STDC__ || defined __C99__FUNC__ \ 1284 || defined __cplusplus || defined _MSC_VER) 1285static void 1286yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1287#else 1288static void 1289yydestruct (yymsg, yytype, yyvaluep) 1290 const char *yymsg; 1291 int yytype; 1292 YYSTYPE *yyvaluep; 1293#endif 1294{ 1295 YYUSE (yyvaluep); 1296 1297 if (!yymsg) 1298 yymsg = "Deleting"; 1299 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1300 1301 switch (yytype) 1302 { 1303 1304 default: 1305 break; 1306 } 1307} 1308 1309 1310/* Prevent warnings from -Wmissing-prototypes. */ 1311#ifdef YYPARSE_PARAM 1312#if defined __STDC__ || defined __cplusplus 1313int yyparse (void *YYPARSE_PARAM); 1314#else 1315int yyparse (); 1316#endif 1317#else /* ! YYPARSE_PARAM */ 1318#if defined __STDC__ || defined __cplusplus 1319int yyparse (void); 1320#else 1321int yyparse (); 1322#endif 1323#endif /* ! YYPARSE_PARAM */ 1324 1325 1326/* The lookahead symbol. */ 1327int yychar; 1328 1329/* The semantic value of the lookahead symbol. */ 1330YYSTYPE yylval; 1331 1332/* Number of syntax errors so far. */ 1333int yynerrs; 1334 1335 1336/*----------. 1337| yyparse. | 1338`----------*/ 1339 1340#ifdef YYPARSE_PARAM 1341#if (defined __STDC__ || defined __C99__FUNC__ \ 1342 || defined __cplusplus || defined _MSC_VER) 1343int 1344yyparse (void *YYPARSE_PARAM) 1345#else 1346int 1347yyparse (YYPARSE_PARAM) 1348 void *YYPARSE_PARAM; 1349#endif 1350#else /* ! YYPARSE_PARAM */ 1351#if (defined __STDC__ || defined __C99__FUNC__ \ 1352 || defined __cplusplus || defined _MSC_VER) 1353int 1354yyparse (void) 1355#else 1356int 1357yyparse () 1358 1359#endif 1360#endif 1361{ 1362 int yystate; 1363 /* Number of tokens to shift before error messages enabled. */ 1364 int yyerrstatus; 1365 1366 /* The stacks and their tools: 1367 `yyss': related to states. 1368 `yyvs': related to semantic values. 1369 1370 Refer to the stacks thru separate pointers, to allow yyoverflow 1371 to reallocate them elsewhere. */ 1372 1373 /* The state stack. */ 1374 yytype_int16 yyssa[YYINITDEPTH]; 1375 yytype_int16 *yyss; 1376 yytype_int16 *yyssp; 1377 1378 /* The semantic value stack. */ 1379 YYSTYPE yyvsa[YYINITDEPTH]; 1380 YYSTYPE *yyvs; 1381 YYSTYPE *yyvsp; 1382 1383 YYSIZE_T yystacksize; 1384 1385 int yyn; 1386 int yyresult; 1387 /* Lookahead token as an internal (translated) token number. */ 1388 int yytoken; 1389 /* The variables used to return semantic value and location from the 1390 action routines. */ 1391 YYSTYPE yyval; 1392 1393#if YYERROR_VERBOSE 1394 /* Buffer for error messages, and its allocated size. */ 1395 char yymsgbuf[128]; 1396 char *yymsg = yymsgbuf; 1397 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1398#endif 1399 1400#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1401 1402 /* The number of symbols on the RHS of the reduced rule. 1403 Keep to zero when no symbol should be popped. */ 1404 int yylen = 0; 1405 1406 yytoken = 0; 1407 yyss = yyssa; 1408 yyvs = yyvsa; 1409 yystacksize = YYINITDEPTH; 1410 1411 YYDPRINTF ((stderr, "Starting parse\n")); 1412 1413 yystate = 0; 1414 yyerrstatus = 0; 1415 yynerrs = 0; 1416 yychar = YYEMPTY; /* Cause a token to be read. */ 1417 1418 /* Initialize stack pointers. 1419 Waste one element of value and location stack 1420 so that they stay on the same level as the state stack. 1421 The wasted elements are never initialized. */ 1422 yyssp = yyss; 1423 yyvsp = yyvs; 1424 1425 goto yysetstate; 1426 1427/*------------------------------------------------------------. 1428| yynewstate -- Push a new state, which is found in yystate. | 1429`------------------------------------------------------------*/ 1430 yynewstate: 1431 /* In all cases, when you get here, the value and location stacks 1432 have just been pushed. So pushing a state here evens the stacks. */ 1433 yyssp++; 1434 1435 yysetstate: 1436 *yyssp = yystate; 1437 1438 if (yyss + yystacksize - 1 <= yyssp) 1439 { 1440 /* Get the current used size of the three stacks, in elements. */ 1441 YYSIZE_T yysize = yyssp - yyss + 1; 1442 1443#ifdef yyoverflow 1444 { 1445 /* Give user a chance to reallocate the stack. Use copies of 1446 these so that the &'s don't force the real ones into 1447 memory. */ 1448 YYSTYPE *yyvs1 = yyvs; 1449 yytype_int16 *yyss1 = yyss; 1450 1451 /* Each stack pointer address is followed by the size of the 1452 data in use in that stack, in bytes. This used to be a 1453 conditional around just the two extra args, but that might 1454 be undefined if yyoverflow is a macro. */ 1455 yyoverflow (YY_("memory exhausted"), 1456 &yyss1, yysize * sizeof (*yyssp), 1457 &yyvs1, yysize * sizeof (*yyvsp), 1458 &yystacksize); 1459 1460 yyss = yyss1; 1461 yyvs = yyvs1; 1462 } 1463#else /* no yyoverflow */ 1464# ifndef YYSTACK_RELOCATE 1465 goto yyexhaustedlab; 1466# else 1467 /* Extend the stack our own way. */ 1468 if (YYMAXDEPTH <= yystacksize) 1469 goto yyexhaustedlab; 1470 yystacksize *= 2; 1471 if (YYMAXDEPTH < yystacksize) 1472 yystacksize = YYMAXDEPTH; 1473 1474 { 1475 yytype_int16 *yyss1 = yyss; 1476 union yyalloc *yyptr = 1477 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1478 if (! yyptr) 1479 goto yyexhaustedlab; 1480 YYSTACK_RELOCATE (yyss_alloc, yyss); 1481 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1482# undef YYSTACK_RELOCATE 1483 if (yyss1 != yyssa) 1484 YYSTACK_FREE (yyss1); 1485 } 1486# endif 1487#endif /* no yyoverflow */ 1488 1489 yyssp = yyss + yysize - 1; 1490 yyvsp = yyvs + yysize - 1; 1491 1492 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1493 (unsigned long int) yystacksize)); 1494 1495 if (yyss + yystacksize - 1 <= yyssp) 1496 YYABORT; 1497 } 1498 1499 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1500 1501 if (yystate == YYFINAL) 1502 YYACCEPT; 1503 1504 goto yybackup; 1505 1506/*-----------. 1507| yybackup. | 1508`-----------*/ 1509yybackup: 1510 1511 /* Do appropriate processing given the current state. Read a 1512 lookahead token if we need one and don't already have one. */ 1513 1514 /* First try to decide what to do without reference to lookahead token. */ 1515 yyn = yypact[yystate]; 1516 if (yypact_value_is_default (yyn)) 1517 goto yydefault; 1518 1519 /* Not known => get a lookahead token if don't already have one. */ 1520 1521 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1522 if (yychar == YYEMPTY) 1523 { 1524 YYDPRINTF ((stderr, "Reading a token: ")); 1525 yychar = YYLEX; 1526 } 1527 1528 if (yychar <= YYEOF) 1529 { 1530 yychar = yytoken = YYEOF; 1531 YYDPRINTF ((stderr, "Now at end of input.\n")); 1532 } 1533 else 1534 { 1535 yytoken = YYTRANSLATE (yychar); 1536 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1537 } 1538 1539 /* If the proper action on seeing token YYTOKEN is to reduce or to 1540 detect an error, take that action. */ 1541 yyn += yytoken; 1542 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1543 goto yydefault; 1544 yyn = yytable[yyn]; 1545 if (yyn <= 0) 1546 { 1547 if (yytable_value_is_error (yyn)) 1548 goto yyerrlab; 1549 yyn = -yyn; 1550 goto yyreduce; 1551 } 1552 1553 /* Count tokens shifted since error; after three, turn off error 1554 status. */ 1555 if (yyerrstatus) 1556 yyerrstatus--; 1557 1558 /* Shift the lookahead token. */ 1559 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1560 1561 /* Discard the shifted token. */ 1562 yychar = YYEMPTY; 1563 1564 yystate = yyn; 1565 *++yyvsp = yylval; 1566 1567 goto yynewstate; 1568 1569 1570/*-----------------------------------------------------------. 1571| yydefault -- do the default action for the current state. | 1572`-----------------------------------------------------------*/ 1573yydefault: 1574 yyn = yydefact[yystate]; 1575 if (yyn == 0) 1576 goto yyerrlab; 1577 goto yyreduce; 1578 1579 1580/*-----------------------------. 1581| yyreduce -- Do a reduction. | 1582`-----------------------------*/ 1583yyreduce: 1584 /* yyn is the number of a rule to reduce with. */ 1585 yylen = yyr2[yyn]; 1586 1587 /* If YYLEN is nonzero, implement the default value of the action: 1588 `$$ = $1'. 1589 1590 Otherwise, the following line sets YYVAL to garbage. 1591 This behavior is undocumented and Bison 1592 users should not rely upon it. Assigning to YYVAL 1593 unconditionally makes the parser a bit smaller, and it avoids a 1594 GCC warning that YYVAL may be used uninitialized. */ 1595 yyval = yyvsp[1-yylen]; 1596 1597 1598 YY_REDUCE_PRINT (yyn); 1599 switch (yyn) 1600 { 1601 case 20: 1602 1603/* Line 1806 of yacc.c */ 1604#line 159 "winprefsyacc.y" 1605 { SetTrayIcon((yyvsp[(2) - (3)].sVal)); free((yyvsp[(2) - (3)].sVal)); } 1606 break; 1607 1608 case 21: 1609 1610/* Line 1806 of yacc.c */ 1611#line 162 "winprefsyacc.y" 1612 { SetRootMenu((yyvsp[(2) - (3)].sVal)); free((yyvsp[(2) - (3)].sVal)); } 1613 break; 1614 1615 case 22: 1616 1617/* Line 1806 of yacc.c */ 1618#line 165 "winprefsyacc.y" 1619 { SetDefaultSysMenu((yyvsp[(2) - (4)].sVal), (yyvsp[(3) - (4)].iVal)); free((yyvsp[(2) - (4)].sVal)); } 1620 break; 1621 1622 case 23: 1623 1624/* Line 1806 of yacc.c */ 1625#line 168 "winprefsyacc.y" 1626 { SetDefaultIcon((yyvsp[(2) - (3)].sVal)); free((yyvsp[(2) - (3)].sVal)); } 1627 break; 1628 1629 case 24: 1630 1631/* Line 1806 of yacc.c */ 1632#line 171 "winprefsyacc.y" 1633 { SetIconDirectory((yyvsp[(2) - (3)].sVal)); free((yyvsp[(2) - (3)].sVal)); } 1634 break; 1635 1636 case 25: 1637 1638/* Line 1806 of yacc.c */ 1639#line 174 "winprefsyacc.y" 1640 { AddMenuLine("-", CMD_SEPARATOR, ""); } 1641 break; 1642 1643 case 26: 1644 1645/* Line 1806 of yacc.c */ 1646#line 175 "winprefsyacc.y" 1647 { AddMenuLine((yyvsp[(1) - (4)].sVal), CMD_ALWAYSONTOP, ""); free((yyvsp[(1) - (4)].sVal)); } 1648 break; 1649 1650 case 27: 1651 1652/* Line 1806 of yacc.c */ 1653#line 176 "winprefsyacc.y" 1654 { AddMenuLine((yyvsp[(1) - (5)].sVal), CMD_EXEC, (yyvsp[(3) - (5)].sVal)); free((yyvsp[(1) - (5)].sVal)); free((yyvsp[(3) - (5)].sVal)); } 1655 break; 1656 1657 case 28: 1658 1659/* Line 1806 of yacc.c */ 1660#line 177 "winprefsyacc.y" 1661 { AddMenuLine((yyvsp[(1) - (5)].sVal), CMD_MENU, (yyvsp[(3) - (5)].sVal)); free((yyvsp[(1) - (5)].sVal)); free((yyvsp[(3) - (5)].sVal)); } 1662 break; 1663 1664 case 29: 1665 1666/* Line 1806 of yacc.c */ 1667#line 178 "winprefsyacc.y" 1668 { AddMenuLine((yyvsp[(1) - (4)].sVal), CMD_RELOAD, ""); free((yyvsp[(1) - (4)].sVal)); } 1669 break; 1670 1671 case 32: 1672 1673/* Line 1806 of yacc.c */ 1674#line 185 "winprefsyacc.y" 1675 { OpenMenu((yyvsp[(2) - (3)].sVal)); free((yyvsp[(2) - (3)].sVal)); } 1676 break; 1677 1678 case 33: 1679 1680/* Line 1806 of yacc.c */ 1681#line 185 "winprefsyacc.y" 1682 {CloseMenu();} 1683 break; 1684 1685 case 34: 1686 1687/* Line 1806 of yacc.c */ 1688#line 188 "winprefsyacc.y" 1689 { AddIconLine((yyvsp[(1) - (4)].sVal), (yyvsp[(2) - (4)].sVal)); free((yyvsp[(1) - (4)].sVal)); free((yyvsp[(2) - (4)].sVal)); } 1690 break; 1691 1692 case 37: 1693 1694/* Line 1806 of yacc.c */ 1695#line 195 "winprefsyacc.y" 1696 {OpenIcons();} 1697 break; 1698 1699 case 38: 1700 1701/* Line 1806 of yacc.c */ 1702#line 195 "winprefsyacc.y" 1703 {CloseIcons();} 1704 break; 1705 1706 case 39: 1707 1708/* Line 1806 of yacc.c */ 1709#line 198 "winprefsyacc.y" 1710 { (yyval.uVal)=STYLE_TOPMOST; } 1711 break; 1712 1713 case 40: 1714 1715/* Line 1806 of yacc.c */ 1716#line 199 "winprefsyacc.y" 1717 { (yyval.uVal)=STYLE_MAXIMIZE; } 1718 break; 1719 1720 case 41: 1721 1722/* Line 1806 of yacc.c */ 1723#line 200 "winprefsyacc.y" 1724 { (yyval.uVal)=STYLE_MINIMIZE; } 1725 break; 1726 1727 case 42: 1728 1729/* Line 1806 of yacc.c */ 1730#line 201 "winprefsyacc.y" 1731 { (yyval.uVal)=STYLE_BOTTOM; } 1732 break; 1733 1734 case 43: 1735 1736/* Line 1806 of yacc.c */ 1737#line 204 "winprefsyacc.y" 1738 { (yyval.uVal)=STYLE_NOTITLE; } 1739 break; 1740 1741 case 44: 1742 1743/* Line 1806 of yacc.c */ 1744#line 205 "winprefsyacc.y" 1745 { (yyval.uVal)=STYLE_OUTLINE; } 1746 break; 1747 1748 case 45: 1749 1750/* Line 1806 of yacc.c */ 1751#line 206 "winprefsyacc.y" 1752 { (yyval.uVal)=STYLE_NOFRAME; } 1753 break; 1754 1755 case 46: 1756 1757/* Line 1806 of yacc.c */ 1758#line 209 "winprefsyacc.y" 1759 { (yyval.uVal)=(yyvsp[(1) - (1)].uVal); } 1760 break; 1761 1762 case 47: 1763 1764/* Line 1806 of yacc.c */ 1765#line 210 "winprefsyacc.y" 1766 { (yyval.uVal)=(yyvsp[(1) - (1)].uVal); } 1767 break; 1768 1769 case 48: 1770 1771/* Line 1806 of yacc.c */ 1772#line 211 "winprefsyacc.y" 1773 { (yyval.uVal)=(yyvsp[(1) - (2)].uVal)|(yyvsp[(2) - (2)].uVal); } 1774 break; 1775 1776 case 49: 1777 1778/* Line 1806 of yacc.c */ 1779#line 212 "winprefsyacc.y" 1780 { (yyval.uVal)=(yyvsp[(1) - (2)].uVal)|(yyvsp[(2) - (2)].uVal); } 1781 break; 1782 1783 case 50: 1784 1785/* Line 1806 of yacc.c */ 1786#line 215 "winprefsyacc.y" 1787 { AddStyleLine((yyvsp[(1) - (4)].sVal), (yyvsp[(2) - (4)].uVal)); free((yyvsp[(1) - (4)].sVal)); } 1788 break; 1789 1790 case 53: 1791 1792/* Line 1806 of yacc.c */ 1793#line 222 "winprefsyacc.y" 1794 {OpenStyles();} 1795 break; 1796 1797 case 54: 1798 1799/* Line 1806 of yacc.c */ 1800#line 222 "winprefsyacc.y" 1801 {CloseStyles();} 1802 break; 1803 1804 case 55: 1805 1806/* Line 1806 of yacc.c */ 1807#line 225 "winprefsyacc.y" 1808 { (yyval.iVal)=AT_END; } 1809 break; 1810 1811 case 56: 1812 1813/* Line 1806 of yacc.c */ 1814#line 226 "winprefsyacc.y" 1815 { (yyval.iVal)=AT_START; } 1816 break; 1817 1818 case 57: 1819 1820/* Line 1806 of yacc.c */ 1821#line 227 "winprefsyacc.y" 1822 { (yyval.iVal)=AT_END; } 1823 break; 1824 1825 case 58: 1826 1827/* Line 1806 of yacc.c */ 1828#line 230 "winprefsyacc.y" 1829 { AddSysMenuLine((yyvsp[(1) - (5)].sVal), (yyvsp[(2) - (5)].sVal), (yyvsp[(3) - (5)].iVal)); free((yyvsp[(1) - (5)].sVal)); free((yyvsp[(2) - (5)].sVal)); } 1830 break; 1831 1832 case 61: 1833 1834/* Line 1806 of yacc.c */ 1835#line 237 "winprefsyacc.y" 1836 {OpenSysMenu();} 1837 break; 1838 1839 case 62: 1840 1841/* Line 1806 of yacc.c */ 1842#line 237 "winprefsyacc.y" 1843 {CloseSysMenu();} 1844 break; 1845 1846 case 63: 1847 1848/* Line 1806 of yacc.c */ 1849#line 240 "winprefsyacc.y" 1850 { pref.fForceExit = TRUE; } 1851 break; 1852 1853 case 64: 1854 1855/* Line 1806 of yacc.c */ 1856#line 243 "winprefsyacc.y" 1857 { pref.fSilentExit = TRUE; } 1858 break; 1859 1860 case 65: 1861 1862/* Line 1806 of yacc.c */ 1863#line 246 "winprefsyacc.y" 1864 { ErrorF("LoadPreferences: %s\n", (yyvsp[(2) - (3)].sVal)); free((yyvsp[(2) - (3)].sVal)); } 1865 break; 1866 1867 1868 1869/* Line 1806 of yacc.c */ 1870#line 1871 "winprefsyacc.c" 1871 default: break; 1872 } 1873 /* User semantic actions sometimes alter yychar, and that requires 1874 that yytoken be updated with the new translation. We take the 1875 approach of translating immediately before every use of yytoken. 1876 One alternative is translating here after every semantic action, 1877 but that translation would be missed if the semantic action invokes 1878 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1879 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1880 incorrect destructor might then be invoked immediately. In the 1881 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1882 to an incorrect destructor call or verbose syntax error message 1883 before the lookahead is translated. */ 1884 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1885 1886 YYPOPSTACK (yylen); 1887 yylen = 0; 1888 YY_STACK_PRINT (yyss, yyssp); 1889 1890 *++yyvsp = yyval; 1891 1892 /* Now `shift' the result of the reduction. Determine what state 1893 that goes to, based on the state we popped back to and the rule 1894 number reduced by. */ 1895 1896 yyn = yyr1[yyn]; 1897 1898 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1899 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1900 yystate = yytable[yystate]; 1901 else 1902 yystate = yydefgoto[yyn - YYNTOKENS]; 1903 1904 goto yynewstate; 1905 1906 1907/*------------------------------------. 1908| yyerrlab -- here on detecting error | 1909`------------------------------------*/ 1910yyerrlab: 1911 /* Make sure we have latest lookahead translation. See comments at 1912 user semantic actions for why this is necessary. */ 1913 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 1914 1915 /* If not already recovering from an error, report this error. */ 1916 if (!yyerrstatus) 1917 { 1918 ++yynerrs; 1919#if ! YYERROR_VERBOSE 1920 yyerror (YY_("syntax error")); 1921#else 1922# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 1923 yyssp, yytoken) 1924 { 1925 char const *yymsgp = YY_("syntax error"); 1926 int yysyntax_error_status; 1927 yysyntax_error_status = YYSYNTAX_ERROR; 1928 if (yysyntax_error_status == 0) 1929 yymsgp = yymsg; 1930 else if (yysyntax_error_status == 1) 1931 { 1932 if (yymsg != yymsgbuf) 1933 YYSTACK_FREE (yymsg); 1934 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 1935 if (!yymsg) 1936 { 1937 yymsg = yymsgbuf; 1938 yymsg_alloc = sizeof yymsgbuf; 1939 yysyntax_error_status = 2; 1940 } 1941 else 1942 { 1943 yysyntax_error_status = YYSYNTAX_ERROR; 1944 yymsgp = yymsg; 1945 } 1946 } 1947 yyerror (yymsgp); 1948 if (yysyntax_error_status == 2) 1949 goto yyexhaustedlab; 1950 } 1951# undef YYSYNTAX_ERROR 1952#endif 1953 } 1954 1955 1956 1957 if (yyerrstatus == 3) 1958 { 1959 /* If just tried and failed to reuse lookahead token after an 1960 error, discard it. */ 1961 1962 if (yychar <= YYEOF) 1963 { 1964 /* Return failure if at end of input. */ 1965 if (yychar == YYEOF) 1966 YYABORT; 1967 } 1968 else 1969 { 1970 yydestruct ("Error: discarding", 1971 yytoken, &yylval); 1972 yychar = YYEMPTY; 1973 } 1974 } 1975 1976 /* Else will try to reuse lookahead token after shifting the error 1977 token. */ 1978 goto yyerrlab1; 1979 1980 1981/*---------------------------------------------------. 1982| yyerrorlab -- error raised explicitly by YYERROR. | 1983`---------------------------------------------------*/ 1984yyerrorlab: 1985 1986 /* Pacify compilers like GCC when the user code never invokes 1987 YYERROR and the label yyerrorlab therefore never appears in user 1988 code. */ 1989 if (/*CONSTCOND*/ 0) 1990 goto yyerrorlab; 1991 1992 /* Do not reclaim the symbols of the rule which action triggered 1993 this YYERROR. */ 1994 YYPOPSTACK (yylen); 1995 yylen = 0; 1996 YY_STACK_PRINT (yyss, yyssp); 1997 yystate = *yyssp; 1998 goto yyerrlab1; 1999 2000 2001/*-------------------------------------------------------------. 2002| yyerrlab1 -- common code for both syntax error and YYERROR. | 2003`-------------------------------------------------------------*/ 2004yyerrlab1: 2005 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2006 2007 for (;;) 2008 { 2009 yyn = yypact[yystate]; 2010 if (!yypact_value_is_default (yyn)) 2011 { 2012 yyn += YYTERROR; 2013 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2014 { 2015 yyn = yytable[yyn]; 2016 if (0 < yyn) 2017 break; 2018 } 2019 } 2020 2021 /* Pop the current state because it cannot handle the error token. */ 2022 if (yyssp == yyss) 2023 YYABORT; 2024 2025 2026 yydestruct ("Error: popping", 2027 yystos[yystate], yyvsp); 2028 YYPOPSTACK (1); 2029 yystate = *yyssp; 2030 YY_STACK_PRINT (yyss, yyssp); 2031 } 2032 2033 *++yyvsp = yylval; 2034 2035 2036 /* Shift the error token. */ 2037 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2038 2039 yystate = yyn; 2040 goto yynewstate; 2041 2042 2043/*-------------------------------------. 2044| yyacceptlab -- YYACCEPT comes here. | 2045`-------------------------------------*/ 2046yyacceptlab: 2047 yyresult = 0; 2048 goto yyreturn; 2049 2050/*-----------------------------------. 2051| yyabortlab -- YYABORT comes here. | 2052`-----------------------------------*/ 2053yyabortlab: 2054 yyresult = 1; 2055 goto yyreturn; 2056 2057#if !defined(yyoverflow) || YYERROR_VERBOSE 2058/*-------------------------------------------------. 2059| yyexhaustedlab -- memory exhaustion comes here. | 2060`-------------------------------------------------*/ 2061yyexhaustedlab: 2062 yyerror (YY_("memory exhausted")); 2063 yyresult = 2; 2064 /* Fall through. */ 2065#endif 2066 2067yyreturn: 2068 if (yychar != YYEMPTY) 2069 { 2070 /* Make sure we have latest lookahead translation. See comments at 2071 user semantic actions for why this is necessary. */ 2072 yytoken = YYTRANSLATE (yychar); 2073 yydestruct ("Cleanup: discarding lookahead", 2074 yytoken, &yylval); 2075 } 2076 /* Do not reclaim the symbols of the rule which action triggered 2077 this YYABORT or YYACCEPT. */ 2078 YYPOPSTACK (yylen); 2079 YY_STACK_PRINT (yyss, yyssp); 2080 while (yyssp != yyss) 2081 { 2082 yydestruct ("Cleanup: popping", 2083 yystos[*yyssp], yyvsp); 2084 YYPOPSTACK (1); 2085 } 2086#ifndef yyoverflow 2087 if (yyss != yyssa) 2088 YYSTACK_FREE (yyss); 2089#endif 2090#if YYERROR_VERBOSE 2091 if (yymsg != yymsgbuf) 2092 YYSTACK_FREE (yymsg); 2093#endif 2094 /* Make sure YYID is used. */ 2095 return YYID (yyresult); 2096} 2097 2098 2099 2100/* Line 2067 of yacc.c */ 2101#line 250 "winprefsyacc.y" 2102 2103/* 2104 * Errors in parsing abort and print log messages 2105 */ 2106static int 2107yyerror (char *s) 2108{ 2109 extern int yylineno; /* Handled by flex internally */ 2110 2111 ErrorF("LoadPreferences: %s line %d\n", s, yylineno); 2112 return 1; 2113} 2114 2115/* Miscellaneous functions to store TOKENs into the structure */ 2116static void 2117SetIconDirectory (char *path) 2118{ 2119 strncpy (pref.iconDirectory, path, PATH_MAX); 2120 pref.iconDirectory[PATH_MAX] = 0; 2121} 2122 2123static void 2124SetDefaultIcon (char *fname) 2125{ 2126 strncpy (pref.defaultIconName, fname, NAME_MAX); 2127 pref.defaultIconName[NAME_MAX] = 0; 2128} 2129 2130static void 2131SetTrayIcon (char *fname) 2132{ 2133 strncpy (pref.trayIconName, fname, NAME_MAX); 2134 pref.trayIconName[NAME_MAX] = 0; 2135} 2136 2137static void 2138SetRootMenu (char *menu) 2139{ 2140 strncpy (pref.rootMenuName, menu, MENU_MAX); 2141 pref.rootMenuName[MENU_MAX] = 0; 2142} 2143 2144static void 2145SetDefaultSysMenu (char *menu, int pos) 2146{ 2147 strncpy (pref.defaultSysMenuName, menu, MENU_MAX); 2148 pref.defaultSysMenuName[MENU_MAX] = 0; 2149 pref.defaultSysMenuPos = pos; 2150} 2151 2152static void 2153OpenMenu (char *menuname) 2154{ 2155 if (menu.menuItem) free(menu.menuItem); 2156 menu.menuItem = NULL; 2157 strncpy(menu.menuName, menuname, MENU_MAX); 2158 menu.menuName[MENU_MAX] = 0; 2159 menu.menuItems = 0; 2160} 2161 2162static void 2163AddMenuLine (char *text, MENUCOMMANDTYPE cmd, char *param) 2164{ 2165 if (menu.menuItem==NULL) 2166 menu.menuItem = (MENUITEM*)malloc(sizeof(MENUITEM)); 2167 else 2168 menu.menuItem = (MENUITEM*) 2169 realloc(menu.menuItem, sizeof(MENUITEM)*(menu.menuItems+1)); 2170 2171 strncpy (menu.menuItem[menu.menuItems].text, text, MENU_MAX); 2172 menu.menuItem[menu.menuItems].text[MENU_MAX] = 0; 2173 2174 menu.menuItem[menu.menuItems].cmd = cmd; 2175 2176 strncpy(menu.menuItem[menu.menuItems].param, param, PARAM_MAX); 2177 menu.menuItem[menu.menuItems].param[PARAM_MAX] = 0; 2178 2179 menu.menuItem[menu.menuItems].commandID = 0; 2180 2181 menu.menuItems++; 2182} 2183 2184static void 2185CloseMenu (void) 2186{ 2187 if (menu.menuItem==NULL || menu.menuItems==0) 2188 { 2189 ErrorF("LoadPreferences: Empty menu detected\n"); 2190 return; 2191 } 2192 2193 if (pref.menuItems) 2194 pref.menu = (MENUPARSED*) 2195 realloc (pref.menu, (pref.menuItems+1)*sizeof(MENUPARSED)); 2196 else 2197 pref.menu = (MENUPARSED*)malloc (sizeof(MENUPARSED)); 2198 2199 memcpy (pref.menu+pref.menuItems, &menu, sizeof(MENUPARSED)); 2200 pref.menuItems++; 2201 2202 memset (&menu, 0, sizeof(MENUPARSED)); 2203} 2204 2205static void 2206OpenIcons (void) 2207{ 2208 if (pref.icon != NULL) { 2209 ErrorF("LoadPreferences: Redefining icon mappings\n"); 2210 free(pref.icon); 2211 pref.icon = NULL; 2212 } 2213 pref.iconItems = 0; 2214} 2215 2216static void 2217AddIconLine (char *matchstr, char *iconfile) 2218{ 2219 if (pref.icon==NULL) 2220 pref.icon = (ICONITEM*)malloc(sizeof(ICONITEM)); 2221 else 2222 pref.icon = (ICONITEM*) 2223 realloc(pref.icon, sizeof(ICONITEM)*(pref.iconItems+1)); 2224 2225 strncpy(pref.icon[pref.iconItems].match, matchstr, MENU_MAX); 2226 pref.icon[pref.iconItems].match[MENU_MAX] = 0; 2227 2228 strncpy(pref.icon[pref.iconItems].iconFile, iconfile, PATH_MAX+NAME_MAX+1); 2229 pref.icon[pref.iconItems].iconFile[PATH_MAX+NAME_MAX+1] = 0; 2230 2231 pref.icon[pref.iconItems].hicon = 0; 2232 2233 pref.iconItems++; 2234} 2235 2236static void 2237CloseIcons (void) 2238{ 2239} 2240 2241static void 2242OpenStyles (void) 2243{ 2244 if (pref.style != NULL) { 2245 ErrorF("LoadPreferences: Redefining window style\n"); 2246 free(pref.style); 2247 pref.style = NULL; 2248 } 2249 pref.styleItems = 0; 2250} 2251 2252static void 2253AddStyleLine (char *matchstr, unsigned long style) 2254{ 2255 if (pref.style==NULL) 2256 pref.style = (STYLEITEM*)malloc(sizeof(STYLEITEM)); 2257 else 2258 pref.style = (STYLEITEM*) 2259 realloc(pref.style, sizeof(STYLEITEM)*(pref.styleItems+1)); 2260 2261 strncpy(pref.style[pref.styleItems].match, matchstr, MENU_MAX); 2262 pref.style[pref.styleItems].match[MENU_MAX] = 0; 2263 2264 pref.style[pref.styleItems].type = style; 2265 2266 pref.styleItems++; 2267} 2268 2269static void 2270CloseStyles (void) 2271{ 2272} 2273 2274static void 2275OpenSysMenu (void) 2276{ 2277 if (pref.sysMenu != NULL) { 2278 ErrorF("LoadPreferences: Redefining system menu\n"); 2279 free(pref.sysMenu); 2280 pref.sysMenu = NULL; 2281 } 2282 pref.sysMenuItems = 0; 2283} 2284 2285static void 2286AddSysMenuLine (char *matchstr, char *menuname, int pos) 2287{ 2288 if (pref.sysMenu==NULL) 2289 pref.sysMenu = (SYSMENUITEM*)malloc(sizeof(SYSMENUITEM)); 2290 else 2291 pref.sysMenu = (SYSMENUITEM*) 2292 realloc(pref.sysMenu, sizeof(SYSMENUITEM)*(pref.sysMenuItems+1)); 2293 2294 strncpy (pref.sysMenu[pref.sysMenuItems].match, matchstr, MENU_MAX); 2295 pref.sysMenu[pref.sysMenuItems].match[MENU_MAX] = 0; 2296 2297 strncpy (pref.sysMenu[pref.sysMenuItems].menuName, menuname, MENU_MAX); 2298 pref.sysMenu[pref.sysMenuItems].menuName[MENU_MAX] = 0; 2299 2300 pref.sysMenu[pref.sysMenuItems].menuPos = pos; 2301 2302 pref.sysMenuItems++; 2303} 2304 2305static void 2306CloseSysMenu (void) 2307{ 2308} 2309 2310 2311