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