00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046 #define YYBISON 1
00047
00048
00049 #define YYBISON_VERSION "2.4.1"
00050
00051
00052 #define YYSKELETON_NAME "yacc.c"
00053
00054
00055 #define YYPURE 0
00056
00057
00058 #define YYPUSH 0
00059
00060
00061 #define YYPULL 1
00062
00063
00064 #define YYLSP_NEEDED 0
00065
00066
00067
00068
00069
00070
00071 #line 1 "src/cfgparse.y"
00072
00073
00074
00075
00076
00077 #include <stdio.h>
00078 #include <string.h>
00079 #include <xcb/xcb.h>
00080 #include <sys/types.h>
00081 #include <sys/stat.h>
00082 #include <unistd.h>
00083 #include <fcntl.h>
00084 #include <stdlib.h>
00085 #include <errno.h>
00086
00087 #include "data.h"
00088 #include "config.h"
00089 #include "i3.h"
00090 #include "util.h"
00091 #include "queue.h"
00092 #include "table.h"
00093 #include "workspace.h"
00094 #include "xcb.h"
00095 #include "log.h"
00096
00097 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00098 extern int yylex(struct context *context);
00099 extern int yyparse(void);
00100 extern FILE *yyin;
00101 YY_BUFFER_STATE yy_scan_string(const char *);
00102
00103 static struct bindings_head *current_bindings;
00104 static struct context *context;
00105
00106
00107
00108
00109
00110
00111 void yyerror(const char *error_message) {
00112 ELOG("\n");
00113 ELOG("CONFIG: %s\n", error_message);
00114 ELOG("CONFIG: in file \"%s\", line %d:\n",
00115 context->filename, context->line_number);
00116 ELOG("CONFIG: %s\n", context->line_copy);
00117 ELOG("CONFIG: ");
00118 for (int c = 1; c <= context->last_column; c++)
00119 if (c >= context->first_column)
00120 printf("^");
00121 else printf(" ");
00122 printf("\n");
00123 ELOG("\n");
00124 }
00125
00126 int yywrap() {
00127 return 1;
00128 }
00129
00130 void parse_file(const char *f) {
00131 SLIST_HEAD(variables_head, Variable) variables = SLIST_HEAD_INITIALIZER(&variables);
00132 int fd, ret, read_bytes = 0;
00133 struct stat stbuf;
00134 char *buf;
00135 FILE *fstr;
00136 char buffer[1026], key[512], value[512];
00137
00138 if ((fd = open(f, O_RDONLY)) == -1)
00139 die("Could not open configuration file: %s\n", strerror(errno));
00140
00141 if (fstat(fd, &stbuf) == -1)
00142 die("Could not fstat file: %s\n", strerror(errno));
00143
00144 buf = scalloc((stbuf.st_size + 1) * sizeof(char));
00145 while (read_bytes < stbuf.st_size) {
00146 if ((ret = read(fd, buf + read_bytes, (stbuf.st_size - read_bytes))) < 0)
00147 die("Could not read(): %s\n", strerror(errno));
00148 read_bytes += ret;
00149 }
00150
00151 if (lseek(fd, 0, SEEK_SET) == (off_t)-1)
00152 die("Could not lseek: %s\n", strerror(errno));
00153
00154 if ((fstr = fdopen(fd, "r")) == NULL)
00155 die("Could not fdopen: %s\n", strerror(errno));
00156
00157 while (!feof(fstr)) {
00158 if (fgets(buffer, 1024, fstr) == NULL) {
00159 if (feof(fstr))
00160 break;
00161 die("Could not read configuration file\n");
00162 }
00163
00164
00165 if (sscanf(buffer, "%s %[^\n]", key, value) < 1 ||
00166 key[0] == '#' || strlen(key) < 3)
00167 continue;
00168
00169 if (strcasecmp(key, "set") == 0) {
00170 if (value[0] != '$')
00171 die("Malformed variable assignment, name has to start with $\n");
00172
00173
00174 char *v_key = value, *v_value;
00175 if ((v_value = strstr(value, " ")) == NULL)
00176 die("Malformed variable assignment, need a value\n");
00177
00178 *(v_value++) = '\0';
00179
00180 struct Variable *new = scalloc(sizeof(struct Variable));
00181 new->key = sstrdup(v_key);
00182 new->value = sstrdup(v_value);
00183 SLIST_INSERT_HEAD(&variables, new, variables);
00184 DLOG("Got new variable %s = %s\n", v_key, v_value);
00185 continue;
00186 }
00187 }
00188
00189
00190
00191 struct Variable *current, *nearest;
00192 int extra_bytes = 0;
00193 SLIST_FOREACH(current, &variables, variables) {
00194 int extra = (strlen(current->value) - strlen(current->key));
00195 char *next;
00196 for (next = buf;
00197 (next = strcasestr(buf + (next - buf), current->key)) != NULL;
00198 next += strlen(current->key))
00199 extra_bytes += extra;
00200 }
00201
00202
00203
00204 char *walk = buf, *destwalk;
00205 char *new = smalloc((stbuf.st_size + extra_bytes + 1) * sizeof(char));
00206 destwalk = new;
00207 while (walk < (buf + stbuf.st_size)) {
00208
00209 SLIST_FOREACH(current, &variables, variables)
00210 current->next_match = strcasestr(walk, current->key);
00211 nearest = NULL;
00212 int distance = stbuf.st_size;
00213 SLIST_FOREACH(current, &variables, variables) {
00214 if (current->next_match == NULL)
00215 continue;
00216 if ((current->next_match - walk) < distance) {
00217 distance = (current->next_match - walk);
00218 nearest = current;
00219 }
00220 }
00221 if (nearest == NULL) {
00222
00223 strncpy(destwalk, walk, (buf + stbuf.st_size) - walk);
00224 destwalk += (buf + stbuf.st_size) - walk;
00225 *destwalk = '\0';
00226 break;
00227 } else {
00228
00229 strncpy(destwalk, walk, distance);
00230 strncpy(destwalk + distance, nearest->value, strlen(nearest->value));
00231 walk += distance + strlen(nearest->key);
00232 destwalk += distance + strlen(nearest->value);
00233 }
00234 }
00235
00236 yy_scan_string(new);
00237
00238 context = scalloc(sizeof(struct context));
00239 context->filename = f;
00240
00241 if (yyparse() != 0) {
00242 fprintf(stderr, "Could not parse configfile\n");
00243 exit(1);
00244 }
00245
00246 FREE(context->line_copy);
00247 free(context);
00248 free(new);
00249 free(buf);
00250
00251 while (!SLIST_EMPTY(&variables)) {
00252 current = SLIST_FIRST(&variables);
00253 FREE(current->key);
00254 FREE(current->value);
00255 SLIST_REMOVE_HEAD(&variables, variables);
00256 FREE(current);
00257 }
00258 fclose(fstr);
00259 close(fd);
00260 }
00261
00262
00263
00264
00265 #line 266 "src/cfgparse.tab.c"
00266
00267
00268 #ifndef YYDEBUG
00269 # define YYDEBUG 1
00270 #endif
00271
00272
00273 #ifdef YYERROR_VERBOSE
00274 # undef YYERROR_VERBOSE
00275 # define YYERROR_VERBOSE 1
00276 #else
00277 # define YYERROR_VERBOSE 1
00278 #endif
00279
00280
00281 #ifndef YYTOKEN_TABLE
00282 # define YYTOKEN_TABLE 0
00283 #endif
00284
00285
00286
00287 #ifndef YYTOKENTYPE
00288 # define YYTOKENTYPE
00289
00290
00291 enum yytokentype {
00292 NUMBER = 258,
00293 WORD = 259,
00294 STR = 260,
00295 STR_NG = 261,
00296 HEX = 262,
00297 OUTPUT = 263,
00298 TOKBIND = 264,
00299 TOKTERMINAL = 265,
00300 TOKCOMMENT = 266,
00301 TOKFONT = 267,
00302 TOKBINDSYM = 268,
00303 MODIFIER = 269,
00304 TOKCONTROL = 270,
00305 TOKSHIFT = 271,
00306 WHITESPACE = 272,
00307 TOKFLOATING_MODIFIER = 273,
00308 QUOTEDSTRING = 274,
00309 TOKWORKSPACE = 275,
00310 TOKOUTPUT = 276,
00311 TOKASSIGN = 277,
00312 TOKSET = 278,
00313 TOKIPCSOCKET = 279,
00314 TOKEXEC = 280,
00315 TOKCOLOR = 281,
00316 TOKARROW = 282,
00317 TOKMODE = 283,
00318 TOKNEWCONTAINER = 284,
00319 TOKNEWWINDOW = 285,
00320 TOKFOCUSFOLLOWSMOUSE = 286,
00321 TOKWORKSPACEBAR = 287,
00322 TOKCONTAINERMODE = 288,
00323 TOKSTACKLIMIT = 289
00324 };
00325 #endif
00326
00327
00328
00329 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00330 typedef union YYSTYPE
00331 {
00332
00333
00334 #line 197 "src/cfgparse.y"
00335
00336 int number;
00337 char *string;
00338 struct Colortriple *color;
00339 struct Assignment *assignment;
00340 struct Binding *binding;
00341
00342
00343
00344
00345 #line 346 "src/cfgparse.tab.c"
00346 } YYSTYPE;
00347 # define YYSTYPE_IS_TRIVIAL 1
00348 # define yystype YYSTYPE
00349 # define YYSTYPE_IS_DECLARED 1
00350 #endif
00351
00352
00353
00354
00355
00356
00357 #line 358 "src/cfgparse.tab.c"
00358
00359 #ifdef short
00360 # undef short
00361 #endif
00362
00363 #ifdef YYTYPE_UINT8
00364 typedef YYTYPE_UINT8 yytype_uint8;
00365 #else
00366 typedef unsigned char yytype_uint8;
00367 #endif
00368
00369 #ifdef YYTYPE_INT8
00370 typedef YYTYPE_INT8 yytype_int8;
00371 #elif (defined __STDC__ || defined __C99__FUNC__ \
00372 || defined __cplusplus || defined _MSC_VER)
00373 typedef signed char yytype_int8;
00374 #else
00375 typedef short int yytype_int8;
00376 #endif
00377
00378 #ifdef YYTYPE_UINT16
00379 typedef YYTYPE_UINT16 yytype_uint16;
00380 #else
00381 typedef unsigned short int yytype_uint16;
00382 #endif
00383
00384 #ifdef YYTYPE_INT16
00385 typedef YYTYPE_INT16 yytype_int16;
00386 #else
00387 typedef short int yytype_int16;
00388 #endif
00389
00390 #ifndef YYSIZE_T
00391 # ifdef __SIZE_TYPE__
00392 # define YYSIZE_T __SIZE_TYPE__
00393 # elif defined size_t
00394 # define YYSIZE_T size_t
00395 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00396 || defined __cplusplus || defined _MSC_VER)
00397 # include <stddef.h>
00398 # define YYSIZE_T size_t
00399 # else
00400 # define YYSIZE_T unsigned int
00401 # endif
00402 #endif
00403
00404 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00405
00406 #ifndef YY_
00407 # if YYENABLE_NLS
00408 # if ENABLE_NLS
00409 # include <libintl.h>
00410 # define YY_(msgid) dgettext ("bison-runtime", msgid)
00411 # endif
00412 # endif
00413 # ifndef YY_
00414 # define YY_(msgid) msgid
00415 # endif
00416 #endif
00417
00418
00419 #if ! defined lint || defined __GNUC__
00420 # define YYUSE(e) ((void) (e))
00421 #else
00422 # define YYUSE(e)
00423 #endif
00424
00425
00426 #ifndef lint
00427 # define YYID(n) (n)
00428 #else
00429 #if (defined __STDC__ || defined __C99__FUNC__ \
00430 || defined __cplusplus || defined _MSC_VER)
00431 static int
00432 YYID (int yyi)
00433 #else
00434 static int
00435 YYID (yyi)
00436 int yyi;
00437 #endif
00438 {
00439 return yyi;
00440 }
00441 #endif
00442
00443 #if ! defined yyoverflow || YYERROR_VERBOSE
00444
00445
00446
00447 # ifdef YYSTACK_USE_ALLOCA
00448 # if YYSTACK_USE_ALLOCA
00449 # ifdef __GNUC__
00450 # define YYSTACK_ALLOC __builtin_alloca
00451 # elif defined __BUILTIN_VA_ARG_INCR
00452 # include <alloca.h>
00453 # elif defined _AIX
00454 # define YYSTACK_ALLOC __alloca
00455 # elif defined _MSC_VER
00456 # include <malloc.h>
00457 # define alloca _alloca
00458 # else
00459 # define YYSTACK_ALLOC alloca
00460 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00461 || defined __cplusplus || defined _MSC_VER)
00462 # include <stdlib.h>
00463 # ifndef _STDLIB_H
00464 # define _STDLIB_H 1
00465 # endif
00466 # endif
00467 # endif
00468 # endif
00469 # endif
00470
00471 # ifdef YYSTACK_ALLOC
00472
00473 # define YYSTACK_FREE(Ptr) do { ; } while (YYID (0))
00474 # ifndef YYSTACK_ALLOC_MAXIMUM
00475
00476
00477
00478
00479 # define YYSTACK_ALLOC_MAXIMUM 4032
00480 # endif
00481 # else
00482 # define YYSTACK_ALLOC YYMALLOC
00483 # define YYSTACK_FREE YYFREE
00484 # ifndef YYSTACK_ALLOC_MAXIMUM
00485 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00486 # endif
00487 # if (defined __cplusplus && ! defined _STDLIB_H \
00488 && ! ((defined YYMALLOC || defined malloc) \
00489 && (defined YYFREE || defined free)))
00490 # include <stdlib.h>
00491 # ifndef _STDLIB_H
00492 # define _STDLIB_H 1
00493 # endif
00494 # endif
00495 # ifndef YYMALLOC
00496 # define YYMALLOC malloc
00497 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00498 || defined __cplusplus || defined _MSC_VER)
00499 void *malloc (YYSIZE_T);
00500 # endif
00501 # endif
00502 # ifndef YYFREE
00503 # define YYFREE free
00504 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00505 || defined __cplusplus || defined _MSC_VER)
00506 void free (void *);
00507 # endif
00508 # endif
00509 # endif
00510 #endif
00511
00512
00513 #if (! defined yyoverflow \
00514 && (! defined __cplusplus \
00515 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00516
00517
00518 union yyalloc
00519 {
00520 yytype_int16 yyss_alloc;
00521 YYSTYPE yyvs_alloc;
00522 };
00523
00524
00525 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00526
00527
00528
00529 # define YYSTACK_BYTES(N) \
00530 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
00531 + YYSTACK_GAP_MAXIMUM)
00532
00533
00534
00535 # ifndef YYCOPY
00536 # if defined __GNUC__ && 1 < __GNUC__
00537 # define YYCOPY(To, From, Count) \
00538 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00539 # else
00540 # define YYCOPY(To, From, Count) \
00541 do \
00542 { \
00543 YYSIZE_T yyi; \
00544 for (yyi = 0; yyi < (Count); yyi++) \
00545 (To)[yyi] = (From)[yyi]; \
00546 } \
00547 while (YYID (0))
00548 # endif
00549 # endif
00550
00551
00552
00553
00554
00555
00556 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
00557 do \
00558 { \
00559 YYSIZE_T yynewbytes; \
00560 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
00561 Stack = &yyptr->Stack_alloc; \
00562 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00563 yyptr += yynewbytes / sizeof (*yyptr); \
00564 } \
00565 while (YYID (0))
00566
00567 #endif
00568
00569
00570 #define YYFINAL 2
00571
00572 #define YYLAST 117
00573
00574
00575 #define YYNTOKENS 40
00576
00577 #define YYNNTS 34
00578
00579 #define YYNRULES 71
00580
00581 #define YYNSTATES 128
00582
00583
00584 #define YYUNDEFTOK 2
00585 #define YYMAXUTOK 289
00586
00587 #define YYTRANSLATE(YYX) \
00588 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00589
00590
00591 static const yytype_uint8 yytranslate[] =
00592 {
00593 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00594 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00595 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00596 2, 2, 2, 2, 2, 38, 2, 2, 2, 2,
00597 2, 2, 2, 39, 2, 2, 2, 2, 2, 2,
00598 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00599 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00600 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00601 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00602 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00603 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00604 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00605 2, 2, 2, 35, 2, 36, 37, 2, 2, 2,
00606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00607 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00608 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00609 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00610 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00611 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00612 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00613 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00614 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00615 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00618 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
00619 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
00620 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
00621 25, 26, 27, 28, 29, 30, 31, 32, 33, 34
00622 };
00623
00624 #if YYDEBUG
00625
00626
00627 static const yytype_uint8 yyprhs[] =
00628 {
00629 0, 0, 3, 4, 8, 11, 14, 16, 18, 20,
00630 22, 24, 26, 28, 30, 32, 34, 36, 38, 40,
00631 42, 44, 46, 48, 50, 54, 58, 63, 68, 70,
00632 72, 80, 81, 84, 86, 88, 90, 94, 98, 106,
00633 110, 112, 114, 118, 122, 131, 137, 138, 141, 143,
00634 145, 147, 154, 156, 158, 161, 163, 165, 166, 169,
00635 173, 177, 181, 185, 193, 196, 197, 199, 203, 206,
00636 208, 210
00637 };
00638
00639
00640 static const yytype_int8 yyrhs[] =
00641 {
00642 41, 0, -1, -1, 41, 17, 42, -1, 41, 1,
00643 -1, 41, 42, -1, 45, -1, 50, -1, 53, -1,
00644 54, -1, 55, -1, 57, -1, 58, -1, 59, -1,
00645 62, -1, 66, -1, 67, -1, 70, -1, 68, -1,
00646 69, -1, 43, -1, 11, -1, 5, -1, 46, -1,
00647 9, 17, 47, -1, 13, 17, 48, -1, 72, 3,
00648 17, 44, -1, 72, 49, 17, 44, -1, 4, -1,
00649 3, -1, 28, 17, 19, 17, 35, 51, 36, -1,
00650 -1, 51, 52, -1, 17, -1, 43, -1, 46, -1,
00651 18, 17, 72, -1, 29, 17, 33, -1, 29, 17,
00652 34, 17, 34, 17, 3, -1, 30, 17, 4, -1,
00653 3, -1, 4, -1, 31, 17, 56, -1, 32, 17,
00654 56, -1, 20, 17, 3, 17, 21, 17, 8, 60,
00655 -1, 20, 17, 3, 17, 61, -1, -1, 17, 61,
00656 -1, 19, -1, 5, -1, 4, -1, 22, 17, 64,
00657 17, 65, 63, -1, 3, -1, 37, -1, 37, 3,
00658 -1, 19, -1, 6, -1, -1, 27, 17, -1, 24,
00659 17, 5, -1, 25, 17, 5, -1, 10, 17, 5,
00660 -1, 12, 17, 5, -1, 26, 17, 71, 17, 71,
00661 17, 71, -1, 38, 7, -1, -1, 73, -1, 72,
00662 39, 73, -1, 72, 39, -1, 14, -1, 15, -1,
00663 16, -1
00664 };
00665
00666
00667 static const yytype_uint16 yyrline[] =
00668 {
00669 0, 240, 240, 241, 242, 243, 247, 248, 249, 250,
00670 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
00671 261, 265, 269, 273, 280, 281, 285, 299, 313, 314,
00672 321, 344, 346, 350, 351, 352, 364, 372, 394, 413,
00673 421, 425, 437, 445, 453, 467, 483, 484, 488, 489,
00674 490, 494, 507, 514, 520, 530, 531, 534, 536, 540,
00675 547, 556, 564, 573, 584, 596, 597, 598, 599, 603,
00676 604, 605
00677 };
00678 #endif
00679
00680 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00681
00682
00683 static const char *const yytname[] =
00684 {
00685 "$end", "error", "$undefined", "\"<number>\"", "\"<word>\"",
00686 "\"<string>\"", "\"<string (non-greedy)>\"", "\"<hex>\"",
00687 "\"<RandR output>\"", "TOKBIND", "TOKTERMINAL", "\"<comment>\"",
00688 "\"font\"", "\"bindsym\"", "\"<modifier>\"", "\"control\"", "\"shift\"",
00689 "\"<whitespace>\"", "\"floating_modifier\"", "\"<quoted string>\"",
00690 "\"workspace\"", "\"output\"", "\"assign\"", "TOKSET", "\"ipc_socket\"",
00691 "\"exec\"", "TOKCOLOR", "\"\\342\\206\\222\"", "\"mode\"",
00692 "\"new_container\"", "\"new_window\"", "\"focus_follows_mouse\"",
00693 "\"workspace_bar\"", "\"default/stacking/tabbed\"", "\"stack-limit\"",
00694 "'{'", "'}'", "'~'", "'#'", "'+'", "$accept", "lines", "line", "comment",
00695 "command", "bindline", "binding", "bind", "bindsym", "word_or_number",
00696 "mode", "modelines", "modeline", "floating_modifier", "new_container",
00697 "new_window", "bool", "focus_follows_mouse", "workspace_bar",
00698 "workspace", "optional_workspace_name", "workspace_name", "assign",
00699 "assign_target", "window_class", "optional_arrow", "ipcsocket", "exec",
00700 "terminal", "font", "color", "colorpixel", "binding_modifiers",
00701 "binding_modifier", 0
00702 };
00703 #endif
00704
00705 # ifdef YYPRINT
00706
00707
00708 static const yytype_uint16 yytoknum[] =
00709 {
00710 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
00711 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
00712 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
00713 285, 286, 287, 288, 289, 123, 125, 126, 35, 43
00714 };
00715 # endif
00716
00717
00718 static const yytype_uint8 yyr1[] =
00719 {
00720 0, 40, 41, 41, 41, 41, 42, 42, 42, 42,
00721 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
00722 42, 43, 44, 45, 46, 46, 47, 48, 49, 49,
00723 50, 51, 51, 52, 52, 52, 53, 54, 54, 55,
00724 56, 56, 57, 58, 59, 59, 60, 60, 61, 61,
00725 61, 62, 63, 63, 63, 64, 64, 65, 65, 66,
00726 67, 68, 69, 70, 71, 72, 72, 72, 72, 73,
00727 73, 73
00728 };
00729
00730
00731 static const yytype_uint8 yyr2[] =
00732 {
00733 0, 2, 0, 3, 2, 2, 1, 1, 1, 1,
00734 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00735 1, 1, 1, 1, 3, 3, 4, 4, 1, 1,
00736 7, 0, 2, 1, 1, 1, 3, 3, 7, 3,
00737 1, 1, 3, 3, 8, 5, 0, 2, 1, 1,
00738 1, 6, 1, 1, 2, 1, 1, 0, 2, 3,
00739 3, 3, 3, 7, 2, 0, 1, 3, 2, 1,
00740 1, 1
00741 };
00742
00743
00744
00745
00746 static const yytype_uint8 yydefact[] =
00747 {
00748 2, 0, 1, 4, 0, 0, 21, 0, 0, 0,
00749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00750 0, 5, 20, 6, 23, 7, 8, 9, 10, 11,
00751 12, 13, 14, 15, 16, 18, 19, 17, 65, 0,
00752 0, 65, 3, 65, 0, 0, 0, 0, 0, 0,
00753 0, 0, 0, 0, 69, 70, 71, 24, 0, 66,
00754 61, 62, 25, 0, 36, 0, 56, 55, 0, 59,
00755 60, 0, 0, 0, 37, 0, 39, 40, 41, 42,
00756 43, 0, 68, 29, 28, 0, 0, 57, 64, 0,
00757 0, 0, 0, 67, 0, 50, 49, 48, 0, 45,
00758 0, 0, 0, 31, 0, 22, 26, 27, 0, 58,
00759 52, 53, 51, 0, 0, 0, 46, 54, 63, 33,
00760 30, 34, 35, 32, 38, 0, 44, 47
00761 };
00762
00763
00764 static const yytype_int8 yydefgoto[] =
00765 {
00766 -1, 1, 21, 22, 106, 23, 24, 57, 62, 85,
00767 25, 114, 123, 26, 27, 28, 79, 29, 30, 31,
00768 126, 99, 32, 112, 68, 101, 33, 34, 35, 36,
00769 37, 72, 58, 59
00770 };
00771
00772
00773
00774 #define YYPACT_NINF -86
00775 static const yytype_int8 yypact[] =
00776 {
00777 -86, 22, -86, -86, -12, 9, -86, 12, 24, 46,
00778 28, 32, 44, 48, 50, 52, 56, 64, 65, 66,
00779 67, -86, -86, -86, -86, -86, -86, -86, -86, -86,
00780 -86, -86, -86, -86, -86, -86, -86, -86, -2, 10,
00781 14, -2, -86, -2, 60, 11, 80, 81, 49, 69,
00782 -25, 85, 76, 76, -86, -86, -86, -86, -1, -86,
00783 -86, -86, -86, -3, 51, 74, -86, -86, 75, -86,
00784 -86, 86, 77, 78, -86, 79, -86, -86, -86, -86,
00785 -86, 82, -2, -86, -86, 83, 6, 70, -86, 49,
00786 63, 68, 96, -86, 96, -86, -86, -86, 87, -86,
00787 88, 0, 89, -86, 90, -86, -86, -86, 95, -86,
00788 -86, 105, -86, 49, 7, 106, 93, -86, -86, -86,
00789 -86, -86, -86, -86, -86, 2, -86, -86
00790 };
00791
00792
00793 static const yytype_int8 yypgoto[] =
00794 {
00795 -86, -86, 102, 1, 18, -86, 3, -86, -86, -86,
00796 -86, -86, -86, -86, -86, -86, 61, -86, -86, -86,
00797 -86, -9, -86, -86, -86, -86, -86, -86, -86, -86,
00798 -86, -85, 19, 31
00799 };
00800
00801
00802
00803
00804
00805 #define YYTABLE_NINF -1
00806 static const yytype_uint8 yytable[] =
00807 {
00808 83, 84, 81, 110, 102, 38, 95, 96, 74, 75,
00809 95, 96, 54, 55, 56, 60, 4, 66, 6, 61,
00810 8, 97, 2, 3, 119, 97, 39, 98, 118, 40,
00811 67, 4, 5, 6, 7, 8, 82, 111, 82, 9,
00812 10, 41, 11, 120, 12, 43, 13, 14, 15, 44,
00813 16, 17, 18, 19, 20, 4, 5, 6, 7, 8,
00814 63, 45, 64, 65, 10, 46, 11, 47, 12, 48,
00815 13, 14, 15, 49, 16, 17, 18, 19, 20, 77,
00816 78, 50, 51, 52, 53, 69, 70, 71, 73, 76,
00817 82, 86, 87, 88, 89, 90, 91, 100, 103, 92,
00818 94, 105, 104, 116, 108, 109, 113, 115, 117, 124,
00819 125, 42, 107, 93, 80, 121, 127, 122
00820 };
00821
00822 static const yytype_uint8 yycheck[] =
00823 {
00824 3, 4, 3, 3, 89, 17, 4, 5, 33, 34,
00825 4, 5, 14, 15, 16, 5, 9, 6, 11, 5,
00826 13, 19, 0, 1, 17, 19, 17, 21, 113, 17,
00827 19, 9, 10, 11, 12, 13, 39, 37, 39, 17,
00828 18, 17, 20, 36, 22, 17, 24, 25, 26, 17,
00829 28, 29, 30, 31, 32, 9, 10, 11, 12, 13,
00830 41, 17, 43, 3, 18, 17, 20, 17, 22, 17,
00831 24, 25, 26, 17, 28, 29, 30, 31, 32, 3,
00832 4, 17, 17, 17, 17, 5, 5, 38, 19, 4,
00833 39, 17, 17, 7, 17, 17, 17, 27, 35, 17,
00834 17, 5, 34, 8, 17, 17, 17, 17, 3, 3,
00835 17, 9, 94, 82, 53, 114, 125, 114
00836 };
00837
00838
00839
00840 static const yytype_uint8 yystos[] =
00841 {
00842 0, 41, 0, 1, 9, 10, 11, 12, 13, 17,
00843 18, 20, 22, 24, 25, 26, 28, 29, 30, 31,
00844 32, 42, 43, 45, 46, 50, 53, 54, 55, 57,
00845 58, 59, 62, 66, 67, 68, 69, 70, 17, 17,
00846 17, 17, 42, 17, 17, 17, 17, 17, 17, 17,
00847 17, 17, 17, 17, 14, 15, 16, 47, 72, 73,
00848 5, 5, 48, 72, 72, 3, 6, 19, 64, 5,
00849 5, 38, 71, 19, 33, 34, 4, 3, 4, 56,
00850 56, 3, 39, 3, 4, 49, 17, 17, 7, 17,
00851 17, 17, 17, 73, 17, 4, 5, 19, 21, 61,
00852 27, 65, 71, 35, 34, 5, 44, 44, 17, 17,
00853 3, 37, 63, 17, 51, 17, 8, 3, 71, 17,
00854 36, 43, 46, 52, 3, 17, 60, 61
00855 };
00856
00857 #define yyerrok (yyerrstatus = 0)
00858 #define yyclearin (yychar = YYEMPTY)
00859 #define YYEMPTY (-2)
00860 #define YYEOF 0
00861
00862 #define YYACCEPT goto yyacceptlab
00863 #define YYABORT goto yyabortlab
00864 #define YYERROR goto yyerrorlab
00865
00866
00867
00868
00869
00870
00871 #define YYFAIL goto yyerrlab
00872
00873 #define YYRECOVERING() (!!yyerrstatus)
00874
00875 #define YYBACKUP(Token, Value) \
00876 do \
00877 if (yychar == YYEMPTY && yylen == 1) \
00878 { \
00879 yychar = (Token); \
00880 yylval = (Value); \
00881 yytoken = YYTRANSLATE (yychar); \
00882 YYPOPSTACK (1); \
00883 goto yybackup; \
00884 } \
00885 else \
00886 { \
00887 yyerror (YY_("syntax error: cannot back up")); \
00888 YYERROR; \
00889 } \
00890 while (YYID (0))
00891
00892
00893 #define YYTERROR 1
00894 #define YYERRCODE 256
00895
00896
00897
00898
00899
00900
00901 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00902 #ifndef YYLLOC_DEFAULT
00903 # define YYLLOC_DEFAULT(Current, Rhs, N) \
00904 do \
00905 if (YYID (N)) \
00906 { \
00907 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
00908 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
00909 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
00910 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
00911 } \
00912 else \
00913 { \
00914 (Current).first_line = (Current).last_line = \
00915 YYRHSLOC (Rhs, 0).last_line; \
00916 (Current).first_column = (Current).last_column = \
00917 YYRHSLOC (Rhs, 0).last_column; \
00918 } \
00919 while (YYID (0))
00920 #endif
00921
00922
00923
00924
00925
00926
00927 #ifndef YY_LOCATION_PRINT
00928 # if YYLTYPE_IS_TRIVIAL
00929 # define YY_LOCATION_PRINT(File, Loc) \
00930 fprintf (File, "%d.%d-%d.%d", \
00931 (Loc).first_line, (Loc).first_column, \
00932 (Loc).last_line, (Loc).last_column)
00933 # else
00934 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00935 # endif
00936 #endif
00937
00938
00939
00940
00941 #ifdef YYLEX_PARAM
00942 # define YYLEX yylex (YYLEX_PARAM)
00943 #else
00944 # define YYLEX yylex (context)
00945 #endif
00946
00947
00948 #if YYDEBUG
00949
00950 # ifndef YYFPRINTF
00951 # include <stdio.h>
00952 # define YYFPRINTF fprintf
00953 # endif
00954
00955 # define YYDPRINTF(Args) \
00956 do { \
00957 if (yydebug) \
00958 YYFPRINTF Args; \
00959 } while (YYID (0))
00960
00961 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
00962 do { \
00963 if (yydebug) \
00964 { \
00965 YYFPRINTF (stderr, "%s ", Title); \
00966 yy_symbol_print (stderr, \
00967 Type, Value); \
00968 YYFPRINTF (stderr, "\n"); \
00969 } \
00970 } while (YYID (0))
00971
00972
00973
00974
00975
00976
00977
00978 #if (defined __STDC__ || defined __C99__FUNC__ \
00979 || defined __cplusplus || defined _MSC_VER)
00980 static void
00981 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
00982 #else
00983 static void
00984 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
00985 FILE *yyoutput;
00986 int yytype;
00987 YYSTYPE const * const yyvaluep;
00988 #endif
00989 {
00990 if (!yyvaluep)
00991 return;
00992 # ifdef YYPRINT
00993 if (yytype < YYNTOKENS)
00994 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00995 # else
00996 YYUSE (yyoutput);
00997 # endif
00998 switch (yytype)
00999 {
01000 default:
01001 break;
01002 }
01003 }
01004
01005
01006
01007
01008
01009
01010 #if (defined __STDC__ || defined __C99__FUNC__ \
01011 || defined __cplusplus || defined _MSC_VER)
01012 static void
01013 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
01014 #else
01015 static void
01016 yy_symbol_print (yyoutput, yytype, yyvaluep)
01017 FILE *yyoutput;
01018 int yytype;
01019 YYSTYPE const * const yyvaluep;
01020 #endif
01021 {
01022 if (yytype < YYNTOKENS)
01023 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01024 else
01025 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01026
01027 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
01028 YYFPRINTF (yyoutput, ")");
01029 }
01030
01031
01032
01033
01034
01035
01036 #if (defined __STDC__ || defined __C99__FUNC__ \
01037 || defined __cplusplus || defined _MSC_VER)
01038 static void
01039 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
01040 #else
01041 static void
01042 yy_stack_print (yybottom, yytop)
01043 yytype_int16 *yybottom;
01044 yytype_int16 *yytop;
01045 #endif
01046 {
01047 YYFPRINTF (stderr, "Stack now");
01048 for (; yybottom <= yytop; yybottom++)
01049 {
01050 int yybot = *yybottom;
01051 YYFPRINTF (stderr, " %d", yybot);
01052 }
01053 YYFPRINTF (stderr, "\n");
01054 }
01055
01056 # define YY_STACK_PRINT(Bottom, Top) \
01057 do { \
01058 if (yydebug) \
01059 yy_stack_print ((Bottom), (Top)); \
01060 } while (YYID (0))
01061
01062
01063
01064
01065
01066
01067 #if (defined __STDC__ || defined __C99__FUNC__ \
01068 || defined __cplusplus || defined _MSC_VER)
01069 static void
01070 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
01071 #else
01072 static void
01073 yy_reduce_print (yyvsp, yyrule)
01074 YYSTYPE *yyvsp;
01075 int yyrule;
01076 #endif
01077 {
01078 int yynrhs = yyr2[yyrule];
01079 int yyi;
01080 unsigned long int yylno = yyrline[yyrule];
01081 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
01082 yyrule - 1, yylno);
01083
01084 for (yyi = 0; yyi < yynrhs; yyi++)
01085 {
01086 YYFPRINTF (stderr, " $%d = ", yyi + 1);
01087 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
01088 &(yyvsp[(yyi + 1) - (yynrhs)])
01089 );
01090 YYFPRINTF (stderr, "\n");
01091 }
01092 }
01093
01094 # define YY_REDUCE_PRINT(Rule) \
01095 do { \
01096 if (yydebug) \
01097 yy_reduce_print (yyvsp, Rule); \
01098 } while (YYID (0))
01099
01100
01101
01102 int yydebug;
01103 #else
01104 # define YYDPRINTF(Args)
01105 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
01106 # define YY_STACK_PRINT(Bottom, Top)
01107 # define YY_REDUCE_PRINT(Rule)
01108 #endif
01109
01110
01111
01112 #ifndef YYINITDEPTH
01113 # define YYINITDEPTH 200
01114 #endif
01115
01116
01117
01118
01119
01120
01121
01122
01123 #ifndef YYMAXDEPTH
01124 # define YYMAXDEPTH 10000
01125 #endif
01126
01127
01128
01129 #if YYERROR_VERBOSE
01130
01131 # ifndef yystrlen
01132 # if defined __GLIBC__ && defined _STRING_H
01133 # define yystrlen strlen
01134 # else
01135
01136 #if (defined __STDC__ || defined __C99__FUNC__ \
01137 || defined __cplusplus || defined _MSC_VER)
01138 static YYSIZE_T
01139 yystrlen (const char *yystr)
01140 #else
01141 static YYSIZE_T
01142 yystrlen (yystr)
01143 const char *yystr;
01144 #endif
01145 {
01146 YYSIZE_T yylen;
01147 for (yylen = 0; yystr[yylen]; yylen++)
01148 continue;
01149 return yylen;
01150 }
01151 # endif
01152 # endif
01153
01154 # ifndef yystpcpy
01155 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
01156 # define yystpcpy stpcpy
01157 # else
01158
01159
01160 #if (defined __STDC__ || defined __C99__FUNC__ \
01161 || defined __cplusplus || defined _MSC_VER)
01162 static char *
01163 yystpcpy (char *yydest, const char *yysrc)
01164 #else
01165 static char *
01166 yystpcpy (yydest, yysrc)
01167 char *yydest;
01168 const char *yysrc;
01169 #endif
01170 {
01171 char *yyd = yydest;
01172 const char *yys = yysrc;
01173
01174 while ((*yyd++ = *yys++) != '\0')
01175 continue;
01176
01177 return yyd - 1;
01178 }
01179 # endif
01180 # endif
01181
01182 # ifndef yytnamerr
01183
01184
01185
01186
01187
01188
01189
01190 static YYSIZE_T
01191 yytnamerr (char *yyres, const char *yystr)
01192 {
01193 if (*yystr == '"')
01194 {
01195 YYSIZE_T yyn = 0;
01196 char const *yyp = yystr;
01197
01198 for (;;)
01199 switch (*++yyp)
01200 {
01201 case '\'':
01202 case ',':
01203 goto do_not_strip_quotes;
01204
01205 case '\\':
01206 if (*++yyp != '\\')
01207 goto do_not_strip_quotes;
01208
01209 default:
01210 if (yyres)
01211 yyres[yyn] = *yyp;
01212 yyn++;
01213 break;
01214
01215 case '"':
01216 if (yyres)
01217 yyres[yyn] = '\0';
01218 return yyn;
01219 }
01220 do_not_strip_quotes: ;
01221 }
01222
01223 if (! yyres)
01224 return yystrlen (yystr);
01225
01226 return yystpcpy (yyres, yystr) - yyres;
01227 }
01228 # endif
01229
01230
01231
01232
01233
01234
01235
01236
01237 static YYSIZE_T
01238 yysyntax_error (char *yyresult, int yystate, int yychar)
01239 {
01240 int yyn = yypact[yystate];
01241
01242 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
01243 return 0;
01244 else
01245 {
01246 int yytype = YYTRANSLATE (yychar);
01247 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
01248 YYSIZE_T yysize = yysize0;
01249 YYSIZE_T yysize1;
01250 int yysize_overflow = 0;
01251 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01252 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01253 int yyx;
01254
01255 # if 0
01256
01257
01258 YY_("syntax error, unexpected %s");
01259 YY_("syntax error, unexpected %s, expecting %s");
01260 YY_("syntax error, unexpected %s, expecting %s or %s");
01261 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
01262 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
01263 # endif
01264 char *yyfmt;
01265 char const *yyf;
01266 static char const yyunexpected[] = "syntax error, unexpected %s";
01267 static char const yyexpecting[] = ", expecting %s";
01268 static char const yyor[] = " or %s";
01269 char yyformat[sizeof yyunexpected
01270 + sizeof yyexpecting - 1
01271 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
01272 * (sizeof yyor - 1))];
01273 char const *yyprefix = yyexpecting;
01274
01275
01276
01277 int yyxbegin = yyn < 0 ? -yyn : 0;
01278
01279
01280 int yychecklim = YYLAST - yyn + 1;
01281 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01282 int yycount = 1;
01283
01284 yyarg[0] = yytname[yytype];
01285 yyfmt = yystpcpy (yyformat, yyunexpected);
01286
01287 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01288 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01289 {
01290 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01291 {
01292 yycount = 1;
01293 yysize = yysize0;
01294 yyformat[sizeof yyunexpected - 1] = '\0';
01295 break;
01296 }
01297 yyarg[yycount++] = yytname[yyx];
01298 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01299 yysize_overflow |= (yysize1 < yysize);
01300 yysize = yysize1;
01301 yyfmt = yystpcpy (yyfmt, yyprefix);
01302 yyprefix = yyor;
01303 }
01304
01305 yyf = YY_(yyformat);
01306 yysize1 = yysize + yystrlen (yyf);
01307 yysize_overflow |= (yysize1 < yysize);
01308 yysize = yysize1;
01309
01310 if (yysize_overflow)
01311 return YYSIZE_MAXIMUM;
01312
01313 if (yyresult)
01314 {
01315
01316
01317
01318 char *yyp = yyresult;
01319 int yyi = 0;
01320 while ((*yyp = *yyf) != '\0')
01321 {
01322 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01323 {
01324 yyp += yytnamerr (yyp, yyarg[yyi++]);
01325 yyf += 2;
01326 }
01327 else
01328 {
01329 yyp++;
01330 yyf++;
01331 }
01332 }
01333 }
01334 return yysize;
01335 }
01336 }
01337 #endif
01338
01339
01340
01341
01342
01343
01344
01345 #if (defined __STDC__ || defined __C99__FUNC__ \
01346 || defined __cplusplus || defined _MSC_VER)
01347 static void
01348 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
01349 #else
01350 static void
01351 yydestruct (yymsg, yytype, yyvaluep)
01352 const char *yymsg;
01353 int yytype;
01354 YYSTYPE *yyvaluep;
01355 #endif
01356 {
01357 YYUSE (yyvaluep);
01358
01359 if (!yymsg)
01360 yymsg = "Deleting";
01361 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01362
01363 switch (yytype)
01364 {
01365
01366 default:
01367 break;
01368 }
01369 }
01370
01371
01372 #ifdef YYPARSE_PARAM
01373 #if defined __STDC__ || defined __cplusplus
01374 int yyparse (void *YYPARSE_PARAM);
01375 #else
01376 int yyparse ();
01377 #endif
01378 #else
01379 #if defined __STDC__ || defined __cplusplus
01380 int yyparse (void);
01381 #else
01382 int yyparse ();
01383 #endif
01384 #endif
01385
01386
01387
01388 int yychar;
01389
01390
01391 YYSTYPE yylval;
01392
01393
01394 int yynerrs;
01395
01396
01397
01398
01399
01400
01401
01402 #ifdef YYPARSE_PARAM
01403 #if (defined __STDC__ || defined __C99__FUNC__ \
01404 || defined __cplusplus || defined _MSC_VER)
01405 int
01406 yyparse (void *YYPARSE_PARAM)
01407 #else
01408 int
01409 yyparse (YYPARSE_PARAM)
01410 void *YYPARSE_PARAM;
01411 #endif
01412 #else
01413 #if (defined __STDC__ || defined __C99__FUNC__ \
01414 || defined __cplusplus || defined _MSC_VER)
01415 int
01416 yyparse (void)
01417 #else
01418 int
01419 yyparse ()
01420
01421 #endif
01422 #endif
01423 {
01424
01425
01426 int yystate;
01427
01428 int yyerrstatus;
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438 yytype_int16 yyssa[YYINITDEPTH];
01439 yytype_int16 *yyss;
01440 yytype_int16 *yyssp;
01441
01442
01443 YYSTYPE yyvsa[YYINITDEPTH];
01444 YYSTYPE *yyvs;
01445 YYSTYPE *yyvsp;
01446
01447 YYSIZE_T yystacksize;
01448
01449 int yyn;
01450 int yyresult;
01451
01452 int yytoken;
01453
01454
01455 YYSTYPE yyval;
01456
01457 #if YYERROR_VERBOSE
01458
01459 char yymsgbuf[128];
01460 char *yymsg = yymsgbuf;
01461 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
01462 #endif
01463
01464 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
01465
01466
01467
01468 int yylen = 0;
01469
01470 yytoken = 0;
01471 yyss = yyssa;
01472 yyvs = yyvsa;
01473 yystacksize = YYINITDEPTH;
01474
01475 YYDPRINTF ((stderr, "Starting parse\n"));
01476
01477 yystate = 0;
01478 yyerrstatus = 0;
01479 yynerrs = 0;
01480 yychar = YYEMPTY;
01481
01482
01483
01484
01485
01486 yyssp = yyss;
01487 yyvsp = yyvs;
01488
01489 goto yysetstate;
01490
01491
01492
01493
01494 yynewstate:
01495
01496
01497 yyssp++;
01498
01499 yysetstate:
01500 *yyssp = yystate;
01501
01502 if (yyss + yystacksize - 1 <= yyssp)
01503 {
01504
01505 YYSIZE_T yysize = yyssp - yyss + 1;
01506
01507 #ifdef yyoverflow
01508 {
01509
01510
01511
01512 YYSTYPE *yyvs1 = yyvs;
01513 yytype_int16 *yyss1 = yyss;
01514
01515
01516
01517
01518
01519 yyoverflow (YY_("memory exhausted"),
01520 &yyss1, yysize * sizeof (*yyssp),
01521 &yyvs1, yysize * sizeof (*yyvsp),
01522 &yystacksize);
01523
01524 yyss = yyss1;
01525 yyvs = yyvs1;
01526 }
01527 #else
01528 # ifndef YYSTACK_RELOCATE
01529 goto yyexhaustedlab;
01530 # else
01531
01532 if (YYMAXDEPTH <= yystacksize)
01533 goto yyexhaustedlab;
01534 yystacksize *= 2;
01535 if (YYMAXDEPTH < yystacksize)
01536 yystacksize = YYMAXDEPTH;
01537
01538 {
01539 yytype_int16 *yyss1 = yyss;
01540 union yyalloc *yyptr =
01541 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01542 if (! yyptr)
01543 goto yyexhaustedlab;
01544 YYSTACK_RELOCATE (yyss_alloc, yyss);
01545 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
01546 # undef YYSTACK_RELOCATE
01547 if (yyss1 != yyssa)
01548 YYSTACK_FREE (yyss1);
01549 }
01550 # endif
01551 #endif
01552
01553 yyssp = yyss + yysize - 1;
01554 yyvsp = yyvs + yysize - 1;
01555
01556 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01557 (unsigned long int) yystacksize));
01558
01559 if (yyss + yystacksize - 1 <= yyssp)
01560 YYABORT;
01561 }
01562
01563 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01564
01565 if (yystate == YYFINAL)
01566 YYACCEPT;
01567
01568 goto yybackup;
01569
01570
01571
01572
01573 yybackup:
01574
01575
01576
01577
01578
01579 yyn = yypact[yystate];
01580 if (yyn == YYPACT_NINF)
01581 goto yydefault;
01582
01583
01584
01585
01586 if (yychar == YYEMPTY)
01587 {
01588 YYDPRINTF ((stderr, "Reading a token: "));
01589 yychar = YYLEX;
01590 }
01591
01592 if (yychar <= YYEOF)
01593 {
01594 yychar = yytoken = YYEOF;
01595 YYDPRINTF ((stderr, "Now at end of input.\n"));
01596 }
01597 else
01598 {
01599 yytoken = YYTRANSLATE (yychar);
01600 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01601 }
01602
01603
01604
01605 yyn += yytoken;
01606 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01607 goto yydefault;
01608 yyn = yytable[yyn];
01609 if (yyn <= 0)
01610 {
01611 if (yyn == 0 || yyn == YYTABLE_NINF)
01612 goto yyerrlab;
01613 yyn = -yyn;
01614 goto yyreduce;
01615 }
01616
01617
01618
01619 if (yyerrstatus)
01620 yyerrstatus--;
01621
01622
01623 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01624
01625
01626 yychar = YYEMPTY;
01627
01628 yystate = yyn;
01629 *++yyvsp = yylval;
01630
01631 goto yynewstate;
01632
01633
01634
01635
01636
01637 yydefault:
01638 yyn = yydefact[yystate];
01639 if (yyn == 0)
01640 goto yyerrlab;
01641 goto yyreduce;
01642
01643
01644
01645
01646
01647 yyreduce:
01648
01649 yylen = yyr2[yyn];
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659 yyval = yyvsp[1-yylen];
01660
01661
01662 YY_REDUCE_PRINT (yyn);
01663 switch (yyn)
01664 {
01665 case 23:
01666
01667
01668 #line 274 "src/cfgparse.y"
01669 {
01670 TAILQ_INSERT_TAIL(bindings, (yyvsp[(1) - (1)].binding), bindings);
01671 ;}
01672 break;
01673
01674 case 24:
01675
01676
01677 #line 280 "src/cfgparse.y"
01678 { (yyval.binding) = (yyvsp[(3) - (3)].binding); ;}
01679 break;
01680
01681 case 25:
01682
01683
01684 #line 281 "src/cfgparse.y"
01685 { (yyval.binding) = (yyvsp[(3) - (3)].binding); ;}
01686 break;
01687
01688 case 26:
01689
01690
01691 #line 286 "src/cfgparse.y"
01692 {
01693 printf("\tFound binding mod%d with key %d and command %s\n", (yyvsp[(1) - (4)].number), (yyvsp[(2) - (4)].number), (yyvsp[(4) - (4)].string));
01694 Binding *new = scalloc(sizeof(Binding));
01695
01696 new->keycode = (yyvsp[(2) - (4)].number);
01697 new->mods = (yyvsp[(1) - (4)].number);
01698 new->command = (yyvsp[(4) - (4)].string);
01699
01700 (yyval.binding) = new;
01701 ;}
01702 break;
01703
01704 case 27:
01705
01706
01707 #line 300 "src/cfgparse.y"
01708 {
01709 printf("\tFound symbolic mod%d with key %s and command %s\n", (yyvsp[(1) - (4)].number), (yyvsp[(2) - (4)].string), (yyvsp[(4) - (4)].string));
01710 Binding *new = scalloc(sizeof(Binding));
01711
01712 new->symbol = (yyvsp[(2) - (4)].string);
01713 new->mods = (yyvsp[(1) - (4)].number);
01714 new->command = (yyvsp[(4) - (4)].string);
01715
01716 (yyval.binding) = new;
01717 ;}
01718 break;
01719
01720 case 29:
01721
01722
01723 #line 315 "src/cfgparse.y"
01724 {
01725 asprintf(&(yyval.string), "%d", (yyvsp[(1) - (1)].number));
01726 ;}
01727 break;
01728
01729 case 30:
01730
01731
01732 #line 322 "src/cfgparse.y"
01733 {
01734 if (strcasecmp((yyvsp[(3) - (7)].string), "default") == 0) {
01735 printf("You cannot use the name \"default\" for your mode\n");
01736 exit(1);
01737 }
01738 printf("\t now in mode %s\n", (yyvsp[(3) - (7)].string));
01739 printf("\t current bindings = %p\n", current_bindings);
01740 Binding *binding;
01741 TAILQ_FOREACH(binding, current_bindings, bindings) {
01742 printf("got binding on mods %d, keycode %d, symbol %s, command %s\n",
01743 binding->mods, binding->keycode, binding->symbol, binding->command);
01744 }
01745
01746 struct Mode *mode = scalloc(sizeof(struct Mode));
01747 mode->name = (yyvsp[(3) - (7)].string);
01748 mode->bindings = current_bindings;
01749 current_bindings = NULL;
01750 SLIST_INSERT_HEAD(&modes, mode, modes);
01751 ;}
01752 break;
01753
01754 case 35:
01755
01756
01757 #line 353 "src/cfgparse.y"
01758 {
01759 if (current_bindings == NULL) {
01760 current_bindings = scalloc(sizeof(struct bindings_head));
01761 TAILQ_INIT(current_bindings);
01762 }
01763
01764 TAILQ_INSERT_TAIL(current_bindings, (yyvsp[(1) - (1)].binding), bindings);
01765 ;}
01766 break;
01767
01768 case 36:
01769
01770
01771 #line 365 "src/cfgparse.y"
01772 {
01773 DLOG("floating modifier = %d\n", (yyvsp[(3) - (3)].number));
01774 config.floating_modifier = (yyvsp[(3) - (3)].number);
01775 ;}
01776 break;
01777
01778 case 37:
01779
01780
01781 #line 373 "src/cfgparse.y"
01782 {
01783 DLOG("new containers will be in mode %d\n", (yyvsp[(3) - (3)].number));
01784 config.container_mode = (yyvsp[(3) - (3)].number);
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794 Workspace *ws;
01795 TAILQ_FOREACH(ws, workspaces, workspaces) {
01796 if (ws->table == NULL)
01797 continue;
01798 switch_layout_mode(global_conn,
01799 ws->table[0][0],
01800 config.container_mode);
01801 }
01802 ;}
01803 break;
01804
01805 case 38:
01806
01807
01808 #line 395 "src/cfgparse.y"
01809 {
01810 DLOG("stack-limit %d with val %d\n", (yyvsp[(5) - (7)].number), (yyvsp[(7) - (7)].number));
01811 config.container_stack_limit = (yyvsp[(5) - (7)].number);
01812 config.container_stack_limit_value = (yyvsp[(7) - (7)].number);
01813
01814
01815 Workspace *ws;
01816 TAILQ_FOREACH(ws, workspaces, workspaces) {
01817 if (ws->table == NULL)
01818 continue;
01819 Container *con = ws->table[0][0];
01820 con->stack_limit = config.container_stack_limit;
01821 con->stack_limit_value = config.container_stack_limit_value;
01822 }
01823 ;}
01824 break;
01825
01826 case 39:
01827
01828
01829 #line 414 "src/cfgparse.y"
01830 {
01831 DLOG("new windows should start in mode %s\n", (yyvsp[(3) - (3)].string));
01832 config.default_border = sstrdup((yyvsp[(3) - (3)].string));
01833 ;}
01834 break;
01835
01836 case 40:
01837
01838
01839 #line 422 "src/cfgparse.y"
01840 {
01841 (yyval.number) = ((yyvsp[(1) - (1)].number) == 1);
01842 ;}
01843 break;
01844
01845 case 41:
01846
01847
01848 #line 426 "src/cfgparse.y"
01849 {
01850 DLOG("checking word \"%s\"\n", (yyvsp[(1) - (1)].string));
01851 (yyval.number) = (strcasecmp((yyvsp[(1) - (1)].string), "yes") == 0 ||
01852 strcasecmp((yyvsp[(1) - (1)].string), "true") == 0 ||
01853 strcasecmp((yyvsp[(1) - (1)].string), "on") == 0 ||
01854 strcasecmp((yyvsp[(1) - (1)].string), "enable") == 0 ||
01855 strcasecmp((yyvsp[(1) - (1)].string), "active") == 0);
01856 ;}
01857 break;
01858
01859 case 42:
01860
01861
01862 #line 438 "src/cfgparse.y"
01863 {
01864 DLOG("focus follows mouse = %d\n", (yyvsp[(3) - (3)].number));
01865 config.disable_focus_follows_mouse = !((yyvsp[(3) - (3)].number));
01866 ;}
01867 break;
01868
01869 case 43:
01870
01871
01872 #line 446 "src/cfgparse.y"
01873 {
01874 DLOG("workspace bar = %d\n", (yyvsp[(3) - (3)].number));
01875 config.disable_workspace_bar = !((yyvsp[(3) - (3)].number));
01876 ;}
01877 break;
01878
01879 case 44:
01880
01881
01882 #line 454 "src/cfgparse.y"
01883 {
01884 int ws_num = (yyvsp[(3) - (8)].number);
01885 if (ws_num < 1) {
01886 DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
01887 } else {
01888 Workspace *ws = workspace_get(ws_num - 1);
01889 ws->preferred_output = (yyvsp[(7) - (8)].string);
01890 if ((yyvsp[(8) - (8)].string) != NULL) {
01891 workspace_set_name(ws, (yyvsp[(8) - (8)].string));
01892 free((yyvsp[(8) - (8)].string));
01893 }
01894 }
01895 ;}
01896 break;
01897
01898 case 45:
01899
01900
01901 #line 468 "src/cfgparse.y"
01902 {
01903 int ws_num = (yyvsp[(3) - (5)].number);
01904 if (ws_num < 1) {
01905 DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
01906 } else {
01907 DLOG("workspace name to: %s\n", (yyvsp[(5) - (5)].string));
01908 if ((yyvsp[(5) - (5)].string) != NULL) {
01909 workspace_set_name(workspace_get(ws_num - 1), (yyvsp[(5) - (5)].string));
01910 free((yyvsp[(5) - (5)].string));
01911 }
01912 }
01913 ;}
01914 break;
01915
01916 case 46:
01917
01918
01919 #line 483 "src/cfgparse.y"
01920 { (yyval.string) = NULL; ;}
01921 break;
01922
01923 case 47:
01924
01925
01926 #line 484 "src/cfgparse.y"
01927 { (yyval.string) = (yyvsp[(2) - (2)].string); ;}
01928 break;
01929
01930 case 48:
01931
01932
01933 #line 488 "src/cfgparse.y"
01934 { (yyval.string) = (yyvsp[(1) - (1)].string); ;}
01935 break;
01936
01937 case 49:
01938
01939
01940 #line 489 "src/cfgparse.y"
01941 { (yyval.string) = (yyvsp[(1) - (1)].string); ;}
01942 break;
01943
01944 case 50:
01945
01946
01947 #line 490 "src/cfgparse.y"
01948 { (yyval.string) = (yyvsp[(1) - (1)].string); ;}
01949 break;
01950
01951 case 51:
01952
01953
01954 #line 495 "src/cfgparse.y"
01955 {
01956 printf("assignment of %s\n", (yyvsp[(3) - (6)].string));
01957
01958 struct Assignment *new = (yyvsp[(6) - (6)].assignment);
01959 printf(" to %d\n", new->workspace);
01960 printf(" floating = %d\n", new->floating);
01961 new->windowclass_title = (yyvsp[(3) - (6)].string);
01962 TAILQ_INSERT_TAIL(&assignments, new, assignments);
01963 ;}
01964 break;
01965
01966 case 52:
01967
01968
01969 #line 508 "src/cfgparse.y"
01970 {
01971 struct Assignment *new = scalloc(sizeof(struct Assignment));
01972 new->workspace = (yyvsp[(1) - (1)].number);
01973 new->floating = ASSIGN_FLOATING_NO;
01974 (yyval.assignment) = new;
01975 ;}
01976 break;
01977
01978 case 53:
01979
01980
01981 #line 515 "src/cfgparse.y"
01982 {
01983 struct Assignment *new = scalloc(sizeof(struct Assignment));
01984 new->floating = ASSIGN_FLOATING_ONLY;
01985 (yyval.assignment) = new;
01986 ;}
01987 break;
01988
01989 case 54:
01990
01991
01992 #line 521 "src/cfgparse.y"
01993 {
01994 struct Assignment *new = scalloc(sizeof(struct Assignment));
01995 new->workspace = (yyvsp[(2) - (2)].number);
01996 new->floating = ASSIGN_FLOATING;
01997 (yyval.assignment) = new;
01998 ;}
01999 break;
02000
02001 case 59:
02002
02003
02004 #line 541 "src/cfgparse.y"
02005 {
02006 config.ipc_socket_path = (yyvsp[(3) - (3)].string);
02007 ;}
02008 break;
02009
02010 case 60:
02011
02012
02013 #line 548 "src/cfgparse.y"
02014 {
02015 struct Autostart *new = smalloc(sizeof(struct Autostart));
02016 new->command = (yyvsp[(3) - (3)].string);
02017 TAILQ_INSERT_TAIL(&autostarts, new, autostarts);
02018 ;}
02019 break;
02020
02021 case 61:
02022
02023
02024 #line 557 "src/cfgparse.y"
02025 {
02026 ELOG("The terminal option is DEPRECATED and has no effect. "
02027 "Please remove it from your configuration file.\n");
02028 ;}
02029 break;
02030
02031 case 62:
02032
02033
02034 #line 565 "src/cfgparse.y"
02035 {
02036 config.font = (yyvsp[(3) - (3)].string);
02037 printf("font %s\n", config.font);
02038 ;}
02039 break;
02040
02041 case 63:
02042
02043
02044 #line 574 "src/cfgparse.y"
02045 {
02046 struct Colortriple *dest = (yyvsp[(1) - (7)].color);
02047
02048 dest->border = (yyvsp[(3) - (7)].number);
02049 dest->background = (yyvsp[(5) - (7)].number);
02050 dest->text = (yyvsp[(7) - (7)].number);
02051 ;}
02052 break;
02053
02054 case 64:
02055
02056
02057 #line 585 "src/cfgparse.y"
02058 {
02059 char *hex;
02060 if (asprintf(&hex, "#%s", (yyvsp[(2) - (2)].string)) == -1)
02061 die("asprintf()");
02062 (yyval.number) = get_colorpixel(global_conn, hex);
02063 free(hex);
02064 ;}
02065 break;
02066
02067 case 65:
02068
02069
02070 #line 596 "src/cfgparse.y"
02071 { (yyval.number) = 0; ;}
02072 break;
02073
02074 case 67:
02075
02076
02077 #line 598 "src/cfgparse.y"
02078 { (yyval.number) = (yyvsp[(1) - (3)].number) | (yyvsp[(3) - (3)].number); ;}
02079 break;
02080
02081 case 68:
02082
02083
02084 #line 599 "src/cfgparse.y"
02085 { (yyval.number) = (yyvsp[(1) - (2)].number); ;}
02086 break;
02087
02088 case 69:
02089
02090
02091 #line 603 "src/cfgparse.y"
02092 { (yyval.number) = (yyvsp[(1) - (1)].number); ;}
02093 break;
02094
02095 case 70:
02096
02097
02098 #line 604 "src/cfgparse.y"
02099 { (yyval.number) = BIND_CONTROL; ;}
02100 break;
02101
02102 case 71:
02103
02104
02105 #line 605 "src/cfgparse.y"
02106 { (yyval.number) = BIND_SHIFT; ;}
02107 break;
02108
02109
02110
02111
02112 #line 2113 "src/cfgparse.tab.c"
02113 default: break;
02114 }
02115 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
02116
02117 YYPOPSTACK (yylen);
02118 yylen = 0;
02119 YY_STACK_PRINT (yyss, yyssp);
02120
02121 *++yyvsp = yyval;
02122
02123
02124
02125
02126
02127 yyn = yyr1[yyn];
02128
02129 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
02130 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
02131 yystate = yytable[yystate];
02132 else
02133 yystate = yydefgoto[yyn - YYNTOKENS];
02134
02135 goto yynewstate;
02136
02137
02138
02139
02140
02141 yyerrlab:
02142
02143 if (!yyerrstatus)
02144 {
02145 ++yynerrs;
02146 #if ! YYERROR_VERBOSE
02147 yyerror (YY_("syntax error"));
02148 #else
02149 {
02150 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
02151 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
02152 {
02153 YYSIZE_T yyalloc = 2 * yysize;
02154 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
02155 yyalloc = YYSTACK_ALLOC_MAXIMUM;
02156 if (yymsg != yymsgbuf)
02157 YYSTACK_FREE (yymsg);
02158 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
02159 if (yymsg)
02160 yymsg_alloc = yyalloc;
02161 else
02162 {
02163 yymsg = yymsgbuf;
02164 yymsg_alloc = sizeof yymsgbuf;
02165 }
02166 }
02167
02168 if (0 < yysize && yysize <= yymsg_alloc)
02169 {
02170 (void) yysyntax_error (yymsg, yystate, yychar);
02171 yyerror (yymsg);
02172 }
02173 else
02174 {
02175 yyerror (YY_("syntax error"));
02176 if (yysize != 0)
02177 goto yyexhaustedlab;
02178 }
02179 }
02180 #endif
02181 }
02182
02183
02184
02185 if (yyerrstatus == 3)
02186 {
02187
02188
02189
02190 if (yychar <= YYEOF)
02191 {
02192
02193 if (yychar == YYEOF)
02194 YYABORT;
02195 }
02196 else
02197 {
02198 yydestruct ("Error: discarding",
02199 yytoken, &yylval);
02200 yychar = YYEMPTY;
02201 }
02202 }
02203
02204
02205
02206 goto yyerrlab1;
02207
02208
02209
02210
02211
02212 yyerrorlab:
02213
02214
02215
02216
02217 if ( 0)
02218 goto yyerrorlab;
02219
02220
02221
02222 YYPOPSTACK (yylen);
02223 yylen = 0;
02224 YY_STACK_PRINT (yyss, yyssp);
02225 yystate = *yyssp;
02226 goto yyerrlab1;
02227
02228
02229
02230
02231
02232 yyerrlab1:
02233 yyerrstatus = 3;
02234
02235 for (;;)
02236 {
02237 yyn = yypact[yystate];
02238 if (yyn != YYPACT_NINF)
02239 {
02240 yyn += YYTERROR;
02241 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
02242 {
02243 yyn = yytable[yyn];
02244 if (0 < yyn)
02245 break;
02246 }
02247 }
02248
02249
02250 if (yyssp == yyss)
02251 YYABORT;
02252
02253
02254 yydestruct ("Error: popping",
02255 yystos[yystate], yyvsp);
02256 YYPOPSTACK (1);
02257 yystate = *yyssp;
02258 YY_STACK_PRINT (yyss, yyssp);
02259 }
02260
02261 *++yyvsp = yylval;
02262
02263
02264
02265 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
02266
02267 yystate = yyn;
02268 goto yynewstate;
02269
02270
02271
02272
02273
02274 yyacceptlab:
02275 yyresult = 0;
02276 goto yyreturn;
02277
02278
02279
02280
02281 yyabortlab:
02282 yyresult = 1;
02283 goto yyreturn;
02284
02285 #if !defined(yyoverflow) || YYERROR_VERBOSE
02286
02287
02288
02289 yyexhaustedlab:
02290 yyerror (YY_("memory exhausted"));
02291 yyresult = 2;
02292
02293 #endif
02294
02295 yyreturn:
02296 if (yychar != YYEMPTY)
02297 yydestruct ("Cleanup: discarding lookahead",
02298 yytoken, &yylval);
02299
02300
02301 YYPOPSTACK (yylen);
02302 YY_STACK_PRINT (yyss, yyssp);
02303 while (yyssp != yyss)
02304 {
02305 yydestruct ("Cleanup: popping",
02306 yystos[*yyssp], yyvsp);
02307 YYPOPSTACK (1);
02308 }
02309 #ifndef yyoverflow
02310 if (yyss != yyssa)
02311 YYSTACK_FREE (yyss);
02312 #endif
02313 #if YYERROR_VERBOSE
02314 if (yymsg != yymsgbuf)
02315 YYSTACK_FREE (yymsg);
02316 #endif
02317
02318 return YYID (yyresult);
02319 }
02320
02321
02322