]> Dogcows Code - chaz/openbox/blob - util/epist/yacc_parser.cc
projects / chaz / openbox / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add the otk::Point type
[chaz/openbox] / util / epist / yacc_parser.cc
1
2 /* A Bison parser, made from epist.y
3 by GNU Bison version 1.28 */
4
5 #define YYBISON 1 /* Identify Bison output. */
6
7 #define OBRACE 257
8 #define EBRACE 258
9 #define SEMICOLON 259
10 #define DASH 260
11 #define NUMBER 261
12 #define QUOTES 262
13 #define WORD 263
14 #define BINDING 264
15 #define OPTIONS 265
16 #define TRUE 266
17 #define FALSE 267
18
19 #line 1 "epist.y"
20
21 #ifdef HAVE_CONFIG_H
22 # include "../../config.h"
23 #endif // HAVE_CONFIG_H
24
25 #include <stdio.h>
26 #include <string.h>
27 #include "parser.hh"
28
29 #define YYPARSE_PARAM parser_obj
30 #define YYSTYPE char*
31
32 extern int yylineno;
33 extern char *yytext;
34
35 extern "C" {
36 int yylex();
37 int yywrap() {
38 return 1;
39 }
40 }
41
42 void yyerror(const char *c)
43 {
44 printf("ERROR: %s, on line %d, near %s\n", c, yylineno, yytext);
45 }
46
47 #ifndef YYSTYPE
48 #define YYSTYPE int
49 #endif
50 #include <stdio.h>
51
52 #ifndef __cplusplus
53 #ifndef __STDC__
54 #define const
55 #endif
56 #endif
57
58
59
60 #define YYFINAL 42
61 #define YYFLAG -32768
62 #define YYNTBASE 14
63
64 #define YYTRANSLATE(x) ((unsigned)(x) <= 267 ? yytranslate[x] : 28)
65
66 static const char yytranslate[] = { 0,
67 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
70 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
72 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
73 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
74 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
75 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
76 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
77 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
78 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
79 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
80 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
81 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
82 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
90 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
91 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
92 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
93 7, 8, 9, 10, 11, 12, 13
94 };
95
96 #if YYDEBUG != 0
97 static const short yyprhs[] = { 0,
98 0, 1, 4, 7, 9, 11, 16, 21, 26, 29,
99 31, 33, 34, 38, 40, 42, 44, 46, 48, 50,
100 51, 53, 56, 58, 60, 62, 64, 65, 68
101 };
102
103 static const short yyrhs[] = { -1,
104 14, 15, 0, 14, 18, 0, 16, 0, 17, 0,
105 19, 9, 24, 5, 0, 19, 20, 14, 21, 0,
106 25, 3, 26, 4, 0, 22, 23, 0, 3, 0,
107 4, 0, 0, 10, 6, 22, 0, 3, 0, 4,
108 0, 6, 0, 5, 0, 7, 0, 9, 0, 0,
109 7, 0, 6, 7, 0, 8, 0, 12, 0, 13,
110 0, 11, 0, 0, 26, 27, 0, 9, 24, 5,
111 0
112 };
113
114 #endif
115
116 #if YYDEBUG != 0
117 static const short yyrline[] = { 0,
118 35, 36, 37, 40, 41, 44, 53, 60, 64, 68,
119 72, 76, 77, 80, 82, 83, 84, 85, 86, 89,
120 90, 91, 92, 93, 94, 97, 101, 102, 105
121 };
122 #endif
123
124
125 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
126
127 static const char * const yytname[] = { "$","error","$undefined.","OBRACE",
128 "EBRACE","SEMICOLON","DASH","NUMBER","QUOTES","WORD","BINDING","OPTIONS","TRUE",
129 "FALSE","commands","command","action_command","chain_command","options_block",
130 "binding","obrace","ebrace","binding_w_modifier","bind_key","parameter","options_keyword",
131 "options","option", NULL
132 };
133 #endif
134
135 static const short yyr1[] = { 0,
136 14, 14, 14, 15, 15, 16, 17, 18, 19, 20,
137 21, 22, 22, 23, 23, 23, 23, 23, 23, 24,
138 24, 24, 24, 24, 24, 25, 26, 26, 27
139 };
140
141 static const short yyr2[] = { 0,
142 0, 2, 2, 1, 1, 4, 4, 4, 2, 1,
143 1, 0, 3, 1, 1, 1, 1, 1, 1, 0,
144 1, 2, 1, 1, 1, 1, 0, 2, 3
145 };
146
147 static const short yydefact[] = { 1,
148 12, 0, 26, 2, 4, 5, 3, 0, 0, 0,
149 12, 10, 20, 1, 14, 15, 17, 16, 18, 19,
150 9, 27, 13, 0, 21, 23, 24, 25, 0, 12,
151 0, 22, 6, 11, 7, 8, 20, 28, 0, 29,
152 0, 0
153 };
154
155 static const short yydefgoto[] = { 1,
156 4, 5, 6, 7, 8, 14, 35, 9, 21, 29,
157 10, 31, 38
158 };
159
160 static const short yypact[] = {-32768,
161 0, -2,-32768,-32768,-32768,-32768,-32768, 16, 11, 6,
162 12,-32768, -5,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
163 -32768,-32768,-32768, 20,-32768,-32768,-32768,-32768, 18, 2,
164 17,-32768,-32768,-32768,-32768,-32768, -5,-32768, 19,-32768,
165 5,-32768
166 };
167
168 static const short yypgoto[] = { 14,
169 -32768,-32768,-32768,-32768,-32768,-32768,-32768, 21,-32768, -8,
170 -32768,-32768,-32768
171 };
172
173
174 #define YYLAST 32
175
176
177 static const short yytable[] = { 41,
178 24, 25, 26, 11, 42, 34, 27, 28, 22, 2,
179 3, 2, 3, 15, 16, 17, 18, 19, 12, 20,
180 36, 2, 33, 40, 13, 37, 32, 30, 39, 0,
181 0, 23
182 };
183
184 static const short yycheck[] = { 0,
185 6, 7, 8, 6, 0, 4, 12, 13, 3, 10,
186 11, 10, 11, 3, 4, 5, 6, 7, 3, 9,
187 4, 10, 5, 5, 9, 9, 7, 14, 37, -1,
188 -1, 11
189 };
190 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
191 #line 3 "/usr/share/misc/bison.simple"
192 /* This file comes from bison-1.28. */
193
194 /* Skeleton output parser for bison,
195 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
196
197 This program is free software; you can redistribute it and/or modify
198 it under the terms of the GNU General Public License as published by
199 the Free Software Foundation; either version 2, or (at your option)
200 any later version.
201
202 This program is distributed in the hope that it will be useful,
203 but WITHOUT ANY WARRANTY; without even the implied warranty of
204 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
205 GNU General Public License for more details.
206
207 You should have received a copy of the GNU General Public License
208 along with this program; if not, write to the Free Software
209 Foundation, Inc., 59 Temple Place - Suite 330,
210 Boston, MA 02111-1307, USA. */
211
212 /* As a special exception, when this file is copied by Bison into a
213 Bison output file, you may use that output file without restriction.
214 This special exception was added by the Free Software Foundation
215 in version 1.24 of Bison. */
216
217 /* This is the parser code that is written into each bison parser
218 when the %semantic_parser declaration is not specified in the grammar.
219 It was written by Richard Stallman by simplifying the hairy parser
220 used when %semantic_parser is specified. */
221
222 #ifndef YYSTACK_USE_ALLOCA
223 #ifdef alloca
224 #define YYSTACK_USE_ALLOCA
225 #else /* alloca not defined */
226 #ifdef __GNUC__
227 #define YYSTACK_USE_ALLOCA
228 #define alloca __builtin_alloca
229 #else /* not GNU C. */
230 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
231 #define YYSTACK_USE_ALLOCA
232 #include <alloca.h>
233 #else /* not sparc */
234 /* We think this test detects Watcom and Microsoft C. */
235 /* This used to test MSDOS, but that is a bad idea
236 since that symbol is in the user namespace. */
237 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
238 #if 0 /* No need for malloc.h, which pollutes the namespace;
239 instead, just don't use alloca. */
240 #include <malloc.h>
241 #endif
242 #else /* not MSDOS, or __TURBOC__ */
243 #if defined(_AIX)
244 /* I don't know what this was needed for, but it pollutes the namespace.
245 So I turned it off. rms, 2 May 1997. */
246 /* #include <malloc.h> */
247 #pragma alloca
248 #define YYSTACK_USE_ALLOCA
249 #else /* not MSDOS, or __TURBOC__, or _AIX */
250 #if 0
251 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
252 and on HPUX 10. Eventually we can turn this on. */
253 #define YYSTACK_USE_ALLOCA
254 #define alloca __builtin_alloca
255 #endif /* __hpux */
256 #endif
257 #endif /* not _AIX */
258 #endif /* not MSDOS, or __TURBOC__ */
259 #endif /* not sparc */
260 #endif /* not GNU C */
261 #endif /* alloca not defined */
262 #endif /* YYSTACK_USE_ALLOCA not defined */
263
264 #ifdef YYSTACK_USE_ALLOCA
265 #define YYSTACK_ALLOC alloca
266 #else
267 #define YYSTACK_ALLOC malloc
268 #endif
269
270 /* Note: there must be only one dollar sign in this file.
271 It is replaced by the list of actions, each action
272 as one case of the switch. */
273
274 #define yyerrok (yyerrstatus = 0)
275 #define yyclearin (yychar = YYEMPTY)
276 #define YYEMPTY -2
277 #define YYEOF 0
278 #define YYACCEPT goto yyacceptlab
279 #define YYABORT goto yyabortlab
280 #define YYERROR goto yyerrlab1
281 /* Like YYERROR except do call yyerror.
282 This remains here temporarily to ease the
283 transition to the new meaning of YYERROR, for GCC.
284 Once GCC version 2 has supplanted version 1, this can go. */
285 #define YYFAIL goto yyerrlab
286 #define YYRECOVERING() (!!yyerrstatus)
287 #define YYBACKUP(token, value) \
288 do \
289 if (yychar == YYEMPTY && yylen == 1) \
290 { yychar = (token), yylval = (value); \
291 yychar1 = YYTRANSLATE (yychar); \
292 YYPOPSTACK; \
293 goto yybackup; \
294 } \
295 else \
296 { yyerror ("syntax error: cannot back up"); YYERROR; } \
297 while (0)
298
299 #define YYTERROR 1
300 #define YYERRCODE 256
301
302 #ifndef YYPURE
303 #define YYLEX yylex()
304 #endif
305
306 #ifdef YYPURE
307 #ifdef YYLSP_NEEDED
308 #ifdef YYLEX_PARAM
309 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
310 #else
311 #define YYLEX yylex(&yylval, &yylloc)
312 #endif
313 #else /* not YYLSP_NEEDED */
314 #ifdef YYLEX_PARAM
315 #define YYLEX yylex(&yylval, YYLEX_PARAM)
316 #else
317 #define YYLEX yylex(&yylval)
318 #endif
319 #endif /* not YYLSP_NEEDED */
320 #endif
321
322 /* If nonreentrant, generate the variables here */
323
324 #ifndef YYPURE
325
326 int yychar; /* the lookahead symbol */
327 YYSTYPE yylval; /* the semantic value of the */
328 /* lookahead symbol */
329
330 #ifdef YYLSP_NEEDED
331 YYLTYPE yylloc; /* location data for the lookahead */
332 /* symbol */
333 #endif
334
335 int yynerrs; /* number of parse errors so far */
336 #endif /* not YYPURE */
337
338 #if YYDEBUG != 0
339 int yydebug; /* nonzero means print parse trace */
340 /* Since this is uninitialized, it does not stop multiple parsers
341 from coexisting. */
342 #endif
343
344 /* YYINITDEPTH indicates the initial size of the parser's stacks */
345
346 #ifndef YYINITDEPTH
347 #define YYINITDEPTH 200
348 #endif
349
350 /* YYMAXDEPTH is the maximum size the stacks can grow to
351 (effective only if the built-in stack extension method is used). */
352
353 #if YYMAXDEPTH == 0
354 #undef YYMAXDEPTH
355 #endif
356
357 #ifndef YYMAXDEPTH
358 #define YYMAXDEPTH 10000
359 #endif
360 \f
361 /* Define __yy_memcpy. Note that the size argument
362 should be passed with type unsigned int, because that is what the non-GCC
363 definitions require. With GCC, __builtin_memcpy takes an arg
364 of type size_t, but it can handle unsigned int. */
365
366 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
367 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
368 #else /* not GNU C or C++ */
369 #ifndef __cplusplus
370
371 /* This is the most reliable way to avoid incompatibilities
372 in available built-in functions on various systems. */
373 static void
374 __yy_memcpy (to, from, count)
375 char *to;
376 char *from;
377 unsigned int count;
378 {
379 register char *f = from;
380 register char *t = to;
381 register int i = count;
382
383 while (i-- > 0)
384 *t++ = *f++;
385 }
386
387 #else /* __cplusplus */
388
389 /* This is the most reliable way to avoid incompatibilities
390 in available built-in functions on various systems. */
391 static void
392 __yy_memcpy (char *to, char *from, unsigned int count)
393 {
394 register char *t = to;
395 register char *f = from;
396 register int i = count;
397
398 while (i-- > 0)
399 *t++ = *f++;
400 }
401
402 #endif
403 #endif
404 \f
405 #line 217 "/usr/share/misc/bison.simple"
406
407 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
408 into yyparse. The argument should have type void *.
409 It should actually point to an object.
410 Grammar actions can access the variable by casting it
411 to the proper pointer type. */
412
413 #ifdef YYPARSE_PARAM
414 #ifdef __cplusplus
415 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
416 #define YYPARSE_PARAM_DECL
417 #else /* not __cplusplus */
418 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
419 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
420 #endif /* not __cplusplus */
421 #else /* not YYPARSE_PARAM */
422 #define YYPARSE_PARAM_ARG
423 #define YYPARSE_PARAM_DECL
424 #endif /* not YYPARSE_PARAM */
425
426 /* Prevent warning if -Wstrict-prototypes. */
427 #ifdef __GNUC__
428 #ifdef YYPARSE_PARAM
429 int yyparse (void *);
430 #else
431 int yyparse (void);
432 #endif
433 #endif
434
435 int
436 yyparse(YYPARSE_PARAM_ARG)
437 YYPARSE_PARAM_DECL
438 {
439 register int yystate;
440 register int yyn;
441 register short *yyssp;
442 register YYSTYPE *yyvsp;
443 int yyerrstatus; /* number of tokens to shift before error messages enabled */
444 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
445
446 short yyssa[YYINITDEPTH]; /* the state stack */
447 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
448
449 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
450 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
451
452 #ifdef YYLSP_NEEDED
453 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
454 YYLTYPE *yyls = yylsa;
455 YYLTYPE *yylsp;
456
457 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
458 #else
459 #define YYPOPSTACK (yyvsp--, yyssp--)
460 #endif
461
462 int yystacksize = YYINITDEPTH;
463 int yyfree_stacks = 0;
464
465 #ifdef YYPURE
466 int yychar;
467 YYSTYPE yylval;
468 int yynerrs;
469 #ifdef YYLSP_NEEDED
470 YYLTYPE yylloc;
471 #endif
472 #endif
473
474 YYSTYPE yyval; /* the variable used to return */
475 /* semantic values from the action */
476 /* routines */
477
478 int yylen;
479
480 #if YYDEBUG != 0
481 if (yydebug)
482 fprintf(stderr, "Starting parse\n");
483 #endif
484
485 yystate = 0;
486 yyerrstatus = 0;
487 yynerrs = 0;
488 yychar = YYEMPTY; /* Cause a token to be read. */
489
490 /* Initialize stack pointers.
491 Waste one element of value and location stack
492 so that they stay on the same level as the state stack.
493 The wasted elements are never initialized. */
494
495 yyssp = yyss - 1;
496 yyvsp = yyvs;
497 #ifdef YYLSP_NEEDED
498 yylsp = yyls;
499 #endif
500
501 /* Push a new state, which is found in yystate . */
502 /* In all cases, when you get here, the value and location stacks
503 have just been pushed. so pushing a state here evens the stacks. */
504 yynewstate:
505
506 *++yyssp = yystate;
507
508 if (yyssp >= yyss + yystacksize - 1)
509 {
510 /* Give user a chance to reallocate the stack */
511 /* Use copies of these so that the &'s don't force the real ones into memory. */
512 YYSTYPE *yyvs1 = yyvs;
513 short *yyss1 = yyss;
514 #ifdef YYLSP_NEEDED
515 YYLTYPE *yyls1 = yyls;
516 #endif
517
518 /* Get the current used size of the three stacks, in elements. */
519 int size = yyssp - yyss + 1;
520
521 #ifdef yyoverflow
522 /* Each stack pointer address is followed by the size of
523 the data in use in that stack, in bytes. */
524 #ifdef YYLSP_NEEDED
525 /* This used to be a conditional around just the two extra args,
526 but that might be undefined if yyoverflow is a macro. */
527 yyoverflow("parser stack overflow",
528 &yyss1, size * sizeof (*yyssp),
529 &yyvs1, size * sizeof (*yyvsp),
530 &yyls1, size * sizeof (*yylsp),
531 &yystacksize);
532 #else
533 yyoverflow("parser stack overflow",
534 &yyss1, size * sizeof (*yyssp),
535 &yyvs1, size * sizeof (*yyvsp),
536 &yystacksize);
537 #endif
538
539 yyss = yyss1; yyvs = yyvs1;
540 #ifdef YYLSP_NEEDED
541 yyls = yyls1;
542 #endif
543 #else /* no yyoverflow */
544 /* Extend the stack our own way. */
545 if (yystacksize >= YYMAXDEPTH)
546 {
547 yyerror("parser stack overflow");
548 if (yyfree_stacks)
549 {
550 free (yyss);
551 free (yyvs);
552 #ifdef YYLSP_NEEDED
553 free (yyls);
554 #endif
555 }
556 return 2;
557 }
558 yystacksize *= 2;
559 if (yystacksize > YYMAXDEPTH)
560 yystacksize = YYMAXDEPTH;
561 #ifndef YYSTACK_USE_ALLOCA
562 yyfree_stacks = 1;
563 #endif
564 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
565 __yy_memcpy ((char *)yyss, (char *)yyss1,
566 size * (unsigned int) sizeof (*yyssp));
567 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
568 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
569 size * (unsigned int) sizeof (*yyvsp));
570 #ifdef YYLSP_NEEDED
571 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
572 __yy_memcpy ((char *)yyls, (char *)yyls1,
573 size * (unsigned int) sizeof (*yylsp));
574 #endif
575 #endif /* no yyoverflow */
576
577 yyssp = yyss + size - 1;
578 yyvsp = yyvs + size - 1;
579 #ifdef YYLSP_NEEDED
580 yylsp = yyls + size - 1;
581 #endif
582
583 #if YYDEBUG != 0
584 if (yydebug)
585 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
586 #endif
587
588 if (yyssp >= yyss + yystacksize - 1)
589 YYABORT;
590 }
591
592 #if YYDEBUG != 0
593 if (yydebug)
594 fprintf(stderr, "Entering state %d\n", yystate);
595 #endif
596
597 goto yybackup;
598 yybackup:
599
600 /* Do appropriate processing given the current state. */
601 /* Read a lookahead token if we need one and don't already have one. */
602 /* yyresume: */
603
604 /* First try to decide what to do without reference to lookahead token. */
605
606 yyn = yypact[yystate];
607 if (yyn == YYFLAG)
608 goto yydefault;
609
610 /* Not known => get a lookahead token if don't already have one. */
611
612 /* yychar is either YYEMPTY or YYEOF
613 or a valid token in external form. */
614
615 if (yychar == YYEMPTY)
616 {
617 #if YYDEBUG != 0
618 if (yydebug)
619 fprintf(stderr, "Reading a token: ");
620 #endif
621 yychar = YYLEX;
622 }
623
624 /* Convert token to internal form (in yychar1) for indexing tables with */
625
626 if (yychar <= 0) /* This means end of input. */
627 {
628 yychar1 = 0;
629 yychar = YYEOF; /* Don't call YYLEX any more */
630
631 #if YYDEBUG != 0
632 if (yydebug)
633 fprintf(stderr, "Now at end of input.\n");
634 #endif
635 }
636 else
637 {
638 yychar1 = YYTRANSLATE(yychar);
639
640 #if YYDEBUG != 0
641 if (yydebug)
642 {
643 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
644 /* Give the individual parser a way to print the precise meaning
645 of a token, for further debugging info. */
646 #ifdef YYPRINT
647 YYPRINT (stderr, yychar, yylval);
648 #endif
649 fprintf (stderr, ")\n");
650 }
651 #endif
652 }
653
654 yyn += yychar1;
655 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
656 goto yydefault;
657
658 yyn = yytable[yyn];
659
660 /* yyn is what to do for this token type in this state.
661 Negative => reduce, -yyn is rule number.
662 Positive => shift, yyn is new state.
663 New state is final state => don't bother to shift,
664 just return success.
665 0, or most negative number => error. */
666
667 if (yyn < 0)
668 {
669 if (yyn == YYFLAG)
670 goto yyerrlab;
671 yyn = -yyn;
672 goto yyreduce;
673 }
674 else if (yyn == 0)
675 goto yyerrlab;
676
677 if (yyn == YYFINAL)
678 YYACCEPT;
679
680 /* Shift the lookahead token. */
681
682 #if YYDEBUG != 0
683 if (yydebug)
684 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
685 #endif
686
687 /* Discard the token being shifted unless it is eof. */
688 if (yychar != YYEOF)
689 yychar = YYEMPTY;
690
691 *++yyvsp = yylval;
692 #ifdef YYLSP_NEEDED
693 *++yylsp = yylloc;
694 #endif
695
696 /* count tokens shifted since error; after three, turn off error status. */
697 if (yyerrstatus) yyerrstatus--;
698
699 yystate = yyn;
700 goto yynewstate;
701
702 /* Do the default action for the current state. */
703 yydefault:
704
705 yyn = yydefact[yystate];
706 if (yyn == 0)
707 goto yyerrlab;
708
709 /* Do a reduction. yyn is the number of a rule to reduce with. */
710 yyreduce:
711 yylen = yyr2[yyn];
712 if (yylen > 0)
713 yyval = yyvsp[1-yylen]; /* implement default value of the action */
714
715 #if YYDEBUG != 0
716 if (yydebug)
717 {
718 int i;
719
720 fprintf (stderr, "Reducing via rule %d (line %d), ",
721 yyn, yyrline[yyn]);
722
723 /* Print the symbols being reduced, and their result. */
724 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
725 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
726 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
727 }
728 #endif
729
730
731 switch (yyn) {
732
733 case 6:
734 #line 46 "epist.y"
735 {
736 ((parser*)parser_obj)->setAction(yyvsp[-2]);
737 ((parser*)parser_obj)->endAction();
738 ;
739 break;}
740 case 7:
741 #line 55 "epist.y"
742 {
743 ((parser*)parser_obj)->endChain();
744 ;
745 break;}
746 case 10:
747 #line 69 "epist.y"
748 { ((parser*)parser_obj)->startChain(); ;
749 break;}
750 case 11:
751 #line 73 "epist.y"
752 { /* ((parser*)parser_obj)->endChain(); */ ;
753 break;}
754 case 13:
755 #line 77 "epist.y"
756 { ((parser*)parser_obj)->addModifier(yyvsp[-2]); ;
757 break;}
758 case 14:
759 #line 81 "epist.y"
760 { ((parser*)parser_obj)->setKey(yyvsp[0]); ;
761 break;}
762 case 15:
763 #line 82 "epist.y"
764 { ((parser*)parser_obj)->setKey(yyvsp[0]); ;
765 break;}
766 case 16:
767 #line 83 "epist.y"
768 { ((parser*)parser_obj)->setKey(yyvsp[0]); ;
769 break;}
770 case 17:
771 #line 84 "epist.y"
772 { ((parser*)parser_obj)->setKey(yyvsp[0]); ;
773 break;}
774 case 18:
775 #line 85 "epist.y"
776 { ((parser*)parser_obj)->setKey(yyvsp[0]); ;
777 break;}
778 case 19:
779 #line 86 "epist.y"
780 { ((parser*)parser_obj)->setKey(yyvsp[0]); ;
781 break;}
782 case 21:
783 #line 90 "epist.y"
784 { ((parser*)parser_obj)->setArgumentNum(yyvsp[0]); ;
785 break;}
786 case 22:
787 #line 91 "epist.y"
788 { ((parser*)parser_obj)->setArgumentNegNum(yyvsp[0]); ;
789 break;}
790 case 23:
791 #line 92 "epist.y"
792 { ((parser*)parser_obj)->setArgumentStr(yyvsp[0]); ;
793 break;}
794 case 24:
795 #line 93 "epist.y"
796 { ((parser*)parser_obj)->setArgumentTrue(yyvsp[0]); ;
797 break;}
798 case 25:
799 #line 94 "epist.y"
800 { ((parser*)parser_obj)->setArgumentFalse(yyvsp[0]); ;
801 break;}
802 case 29:
803 #line 107 "epist.y"
804 { ((parser*)parser_obj)->setOption(yyvsp[-2]); ;
805 break;}
806 }
807 /* the action file gets copied in in place of this dollarsign */
808 #line 543 "/usr/share/misc/bison.simple"
809 \f
810 yyvsp -= yylen;
811 yyssp -= yylen;
812 #ifdef YYLSP_NEEDED
813 yylsp -= yylen;
814 #endif
815
816 #if YYDEBUG != 0
817 if (yydebug)
818 {
819 short *ssp1 = yyss - 1;
820 fprintf (stderr, "state stack now");
821 while (ssp1 != yyssp)
822 fprintf (stderr, " %d", *++ssp1);
823 fprintf (stderr, "\n");
824 }
825 #endif
826
827 *++yyvsp = yyval;
828
829 #ifdef YYLSP_NEEDED
830 yylsp++;
831 if (yylen == 0)
832 {
833 yylsp->first_line = yylloc.first_line;
834 yylsp->first_column = yylloc.first_column;
835 yylsp->last_line = (yylsp-1)->last_line;
836 yylsp->last_column = (yylsp-1)->last_column;
837 yylsp->text = 0;
838 }
839 else
840 {
841 yylsp->last_line = (yylsp+yylen-1)->last_line;
842 yylsp->last_column = (yylsp+yylen-1)->last_column;
843 }
844 #endif
845
846 /* Now "shift" the result of the reduction.
847 Determine what state that goes to,
848 based on the state we popped back to
849 and the rule number reduced by. */
850
851 yyn = yyr1[yyn];
852
853 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
854 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
855 yystate = yytable[yystate];
856 else
857 yystate = yydefgoto[yyn - YYNTBASE];
858
859 goto yynewstate;
860
861 yyerrlab: /* here on detecting error */
862
863 if (! yyerrstatus)
864 /* If not already recovering from an error, report this error. */
865 {
866 ++yynerrs;
867
868 #ifdef YYERROR_VERBOSE
869 yyn = yypact[yystate];
870
871 if (yyn > YYFLAG && yyn < YYLAST)
872 {
873 int size = 0;
874 char *msg;
875 int x, count;
876
877 count = 0;
878 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
879 for (x = (yyn < 0 ? -yyn : 0);
880 x < (sizeof(yytname) / sizeof(char *)); x++)
881 if (yycheck[x + yyn] == x)
882 size += strlen(yytname[x]) + 15, count++;
883 msg = (char *) malloc(size + 15);
884 if (msg != 0)
885 {
886 strcpy(msg, "parse error");
887
888 if (count < 5)
889 {
890 count = 0;
891 for (x = (yyn < 0 ? -yyn : 0);
892 x < (sizeof(yytname) / sizeof(char *)); x++)
893 if (yycheck[x + yyn] == x)
894 {
895 strcat(msg, count == 0 ? ", expecting `" : " or `");
896 strcat(msg, yytname[x]);
897 strcat(msg, "'");
898 count++;
899 }
900 }
901 yyerror(msg);
902 free(msg);
903 }
904 else
905 yyerror ("parse error; also virtual memory exceeded");
906 }
907 else
908 #endif /* YYERROR_VERBOSE */
909 yyerror("parse error");
910 }
911
912 goto yyerrlab1;
913 yyerrlab1: /* here on error raised explicitly by an action */
914
915 if (yyerrstatus == 3)
916 {
917 /* if just tried and failed to reuse lookahead token after an error, discard it. */
918
919 /* return failure if at end of input */
920 if (yychar == YYEOF)
921 YYABORT;
922
923 #if YYDEBUG != 0
924 if (yydebug)
925 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
926 #endif
927
928 yychar = YYEMPTY;
929 }
930
931 /* Else will try to reuse lookahead token
932 after shifting the error token. */
933
934 yyerrstatus = 3; /* Each real token shifted decrements this */
935
936 goto yyerrhandle;
937
938 yyerrdefault: /* current state does not do anything special for the error token. */
939
940 #if 0
941 /* This is wrong; only states that explicitly want error tokens
942 should shift them. */
943 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
944 if (yyn) goto yydefault;
945 #endif
946
947 yyerrpop: /* pop the current state because it cannot handle the error token */
948
949 if (yyssp == yyss) YYABORT;
950 yyvsp--;
951 yystate = *--yyssp;
952 #ifdef YYLSP_NEEDED
953 yylsp--;
954 #endif
955
956 #if YYDEBUG != 0
957 if (yydebug)
958 {
959 short *ssp1 = yyss - 1;
960 fprintf (stderr, "Error: state stack now");
961 while (ssp1 != yyssp)
962 fprintf (stderr, " %d", *++ssp1);
963 fprintf (stderr, "\n");
964 }
965 #endif
966
967 yyerrhandle:
968
969 yyn = yypact[yystate];
970 if (yyn == YYFLAG)
971 goto yyerrdefault;
972
973 yyn += YYTERROR;
974 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
975 goto yyerrdefault;
976
977 yyn = yytable[yyn];
978 if (yyn < 0)
979 {
980 if (yyn == YYFLAG)
981 goto yyerrpop;
982 yyn = -yyn;
983 goto yyreduce;
984 }
985 else if (yyn == 0)
986 goto yyerrpop;
987
988 if (yyn == YYFINAL)
989 YYACCEPT;
990
991 #if YYDEBUG != 0
992 if (yydebug)
993 fprintf(stderr, "Shifting error token, ");
994 #endif
995
996 *++yyvsp = yylval;
997 #ifdef YYLSP_NEEDED
998 *++yylsp = yylloc;
999 #endif
1000
1001 yystate = yyn;
1002 goto yynewstate;
1003
1004 yyacceptlab:
1005 /* YYACCEPT comes here. */
1006 if (yyfree_stacks)
1007 {
1008 free (yyss);
1009 free (yyvs);
1010 #ifdef YYLSP_NEEDED
1011 free (yyls);
1012 #endif
1013 }
1014 return 0;
1015
1016 yyabortlab:
1017 /* YYABORT comes here. */
1018 if (yyfree_stacks)
1019 {
1020 free (yyss);
1021 free (yyvs);
1022 #ifdef YYLSP_NEEDED
1023 free (yyls);
1024 #endif
1025 }
1026 return 1;
1027 }
1028 #line 110 "epist.y"
1029
1030
my patches for the openbox window manager
This page took 0.089987 seconds and 4 git commands to generate.