The Pedigree Project  0.1
parser.c
1 /*
2  * Copyright (c) 2008-2014, Pedigree Developers
3  *
4  * Please see the CONTRIB file in the root of the source tree for a full
5  * list of contributors.
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 /* A Bison parser, made by GNU Bison 2.4.1. */
21 
22 /* Skeleton implementation for Bison's Yacc-like parsers in C
23 
24  Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
25  Free Software Foundation, Inc.
26 
27  This program is free software: you can redistribute it and/or modify
28  it under the terms of the GNU General Public License as published by
29  the Free Software Foundation, either version 3 of the License, or
30  (at your option) any later version.
31 
32  This program is distributed in the hope that it will be useful,
33  but WITHOUT ANY WARRANTY; without even the implied warranty of
34  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
35  GNU General Public License for more details.
36 
37  You should have received a copy of the GNU General Public License
38  along with this program. If not, see <http://www.gnu.org/licenses/>. */
39 
40 /* As a special exception, you may create a larger work that contains
41  part or all of the Bison parser skeleton and distribute that work
42  under terms of your choice, so long as that work isn't itself a
43  parser generator using the skeleton or a modified version thereof
44  as a parser skeleton. Alternatively, if you modify or redistribute
45  the parser skeleton itself, you may (at your option) remove this
46  special exception, which will cause the skeleton and the resulting
47  Bison output files to be licensed under the GNU General Public
48  License without this special exception.
49 
50  This special exception was added by the Free Software Foundation in
51  version 2.2 of Bison. */
52 
53 /* C LALR(1) parser skeleton written by Richard Stallman, by
54  simplifying the original so-called "semantic" parser. */
55 
56 /* All symbols defined below should begin with yy or YY, to avoid
57  infringing on user name space. This should be done even for local
58  variables, as they might otherwise be expanded by user macros.
59  There are some unavoidable exceptions within include files to
60  define necessary library symbols; they are noted "INFRINGES ON
61  USER NAME SPACE" below. */
62 
63 /* Identify Bison output. */
64 #define YYBISON 1
65 
66 /* Bison version. */
67 #define YYBISON_VERSION "2.4.1"
68 
69 /* Skeleton name. */
70 #define YYSKELETON_NAME "yacc.c"
71 
72 /* Pure parsers. */
73 #define YYPURE 0
74 
75 /* Push parsers. */
76 #define YYPUSH 0
77 
78 /* Pull parsers. */
79 #define YYPULL 1
80 
81 /* Using locations. */
82 #define YYLSP_NEEDED 0
83 
84 /* Copy the first part of user declarations. */
85 
86 /* Line 189 of yacc.c */
87 #line 1 "parser.y"
88 
89 #include "cmd.h"
90 #include <stdio.h>
91 #include <stdlib.h>
92 #include <string.h>
93 #include <unistd.h>
94 
95 extern int yylex(void);
96 extern int yyerror(const char *);
97 
98 extern cmd_t *cmds[MAX_CMDS];
99 extern int n_cmds;
100 
101 struct cmd_list
102 {
103  struct cmd *cmd;
104  struct cmd_list *next;
105 };
106 
107 char *quote_char(char c);
108 cmd_t *make_cmd(unsigned int scancode, unsigned int upoint, char *val);
109 void set_cmds(unsigned int scancode, struct cmd_list *cl);
110 struct cmd_list *add_to_cmd_list(struct cmd_list *cl, cmd_t *c);
111 
112 void add_define(char *str, int n);
113 int lookup_define(char *str);
114 
115 /* Line 189 of yacc.c */
116 #line 103 "parser.c"
117 
118 /* Enabling traces. */
119 #ifndef YYDEBUG
120 #define YYDEBUG 0
121 #endif
122 
123 /* Enabling verbose error messages. */
124 #ifdef YYERROR_VERBOSE
125 #undef YYERROR_VERBOSE
126 #define YYERROR_VERBOSE 1
127 #else
128 #define YYERROR_VERBOSE 0
129 #endif
130 
131 /* Enabling the token table. */
132 #ifndef YYTOKEN_TABLE
133 #define YYTOKEN_TABLE 0
134 #endif
135 
136 /* Tokens. */
137 #ifndef YYTOKENTYPE
138 #define YYTOKENTYPE
139 /* Put the tokens into the symbol table, so that GDB and other debuggers
140  know about them. */
141 enum yytokentype
142 {
143  NEWLINE = 258,
144  QUOTE = 259,
145  STRING = 260,
146  CTRL = 261,
147  SHIFT = 262,
148  ALT = 263,
149  ALTGR = 264,
150  CTRL_SHIFT = 265,
151  SHIFT_ALT = 266,
152  CTRL_ALT = 267,
153  CTRL_SHIFT_ALT = 268,
154  SHIFT_ALTGR = 269,
155  CTRL_ALTGR = 270,
156  CTRL_SHIFT_ALTGR = 271,
157  SET_COMBINE = 272,
158  COMBINE = 273,
159  OPEN_SQ = 274,
160  CLOSE_SQ = 275,
161  DEFINE = 276,
162  QUOTED_CHAR = 277,
163  CODE_POINT = 278,
164  NUM = 279,
165  ERROR = 280,
166  END = 281
167 };
168 #endif
169 /* Tokens. */
170 #define NEWLINE 258
171 #define QUOTE 259
172 #define STRING 260
173 #define CTRL 261
174 #define SHIFT 262
175 #define ALT 263
176 #define ALTGR 264
177 #define CTRL_SHIFT 265
178 #define SHIFT_ALT 266
179 #define CTRL_ALT 267
180 #define CTRL_SHIFT_ALT 268
181 #define SHIFT_ALTGR 269
182 #define CTRL_ALTGR 270
183 #define CTRL_SHIFT_ALTGR 271
184 #define SET_COMBINE 272
185 #define COMBINE 273
186 #define OPEN_SQ 274
187 #define CLOSE_SQ 275
188 #define DEFINE 276
189 #define QUOTED_CHAR 277
190 #define CODE_POINT 278
191 #define NUM 279
192 #define ERROR 280
193 #define END 281
194 
195 #if !defined YYSTYPE && !defined YYSTYPE_IS_DECLARED
196 typedef union YYSTYPE
197 {
198 /* Line 214 of yacc.c */
199 #line 31 "parser.y"
200 
201  int n;
202  char str[256];
203  char c;
204  struct cmd *cmd;
205  struct cmd_list *cmd_list;
206 
207 /* Line 214 of yacc.c */
208 #line 201 "parser.c"
209 } YYSTYPE;
210 #define YYSTYPE_IS_TRIVIAL 1
211 #define yystype YYSTYPE /* obsolescent; will be withdrawn */
212 #define YYSTYPE_IS_DECLARED 1
213 #endif
214 
215 /* Copy the second part of user declarations. */
216 
217 /* Line 264 of yacc.c */
218 #line 213 "parser.c"
219 
220 #ifdef short
221 #undef short
222 #endif
223 
224 #ifdef YYTYPE_UINT8
225 typedef YYTYPE_UINT8 yytype_uint8;
226 #else
227 typedef unsigned char yytype_uint8;
228 #endif
229 
230 #ifdef YYTYPE_INT8
231 typedef YYTYPE_INT8 yytype_int8;
232 #elif ( \
233  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
234  defined _MSC_VER)
235 typedef signed char yytype_int8;
236 #else
237 typedef short int yytype_int8;
238 #endif
239 
240 #ifdef YYTYPE_UINT16
241 typedef YYTYPE_UINT16 yytype_uint16;
242 #else
243 typedef unsigned short int yytype_uint16;
244 #endif
245 
246 #ifdef YYTYPE_INT16
247 typedef YYTYPE_INT16 yytype_int16;
248 #else
249 typedef short int yytype_int16;
250 #endif
251 
252 #ifndef YYSIZE_T
253 #ifdef __SIZE_TYPE__
254 #define YYSIZE_T __SIZE_TYPE__
255 #elif defined size_t
256 #define YYSIZE_T size_t
257 #elif !defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ || \
258  defined __cplusplus || defined _MSC_VER)
259 #include <stddef.h> /* INFRINGES ON USER NAME SPACE */
260 #define YYSIZE_T size_t
261 #else
262 #define YYSIZE_T unsigned int
263 #endif
264 #endif
265 
266 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
267 
268 #ifndef YY_
269 #if YYENABLE_NLS
270 #if ENABLE_NLS
271 #include <libintl.h> /* INFRINGES ON USER NAME SPACE */
272 #define YY_(msgid) dgettext("bison-runtime", msgid)
273 #endif
274 #endif
275 #ifndef YY_
276 #define YY_(msgid) msgid
277 #endif
278 #endif
279 
280 /* Suppress unused-variable warnings by "using" E. */
281 #if !defined lint || defined __GNUC__
282 #define YYUSE(e) ((void) (e))
283 #else
284 #define YYUSE(e) /* empty */
285 #endif
286 
287 /* Identity function, used to suppress warnings about constant conditions. */
288 #ifndef lint
289 #define YYID(n) (n)
290 #else
291 #if ( \
292  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
293  defined _MSC_VER)
294 static int YYID(int yyi)
295 #else
296 static int YYID(yyi) int yyi;
297 #endif
298 {
299  return yyi;
300 }
301 #endif
302 
303 #if !defined yyoverflow || YYERROR_VERBOSE
304 
305 /* The parser invokes alloca or malloc; define the necessary symbols. */
306 
307 #ifdef YYSTACK_USE_ALLOCA
308 #if YYSTACK_USE_ALLOCA
309 #ifdef __GNUC__
310 #define YYSTACK_ALLOC __builtin_alloca
311 #elif defined __BUILTIN_VA_ARG_INCR
312 #include <alloca.h> /* INFRINGES ON USER NAME SPACE */
313 #elif defined _AIX
314 #define YYSTACK_ALLOC __alloca
315 #elif defined _MSC_VER
316 #include <malloc.h> /* INFRINGES ON USER NAME SPACE */
317 #define alloca _alloca
318 #else
319 #define YYSTACK_ALLOC alloca
320 #if !defined _ALLOCA_H && !defined _STDLIB_H && \
321  (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
322  defined _MSC_VER)
323 #include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
324 #ifndef _STDLIB_H
325 #define _STDLIB_H 1
326 #endif
327 #endif
328 #endif
329 #endif
330 #endif
331 
332 #ifdef YYSTACK_ALLOC
333 /* Pacify GCC's `empty if-body' warning. */
334 #define YYSTACK_FREE(Ptr) \
335  do \
336  { /* empty */ \
337  ; \
338  } while (YYID(0))
339 #ifndef YYSTACK_ALLOC_MAXIMUM
340 /* The OS might guarantee only one guard page at the bottom of the stack,
341  and a page size can be as small as 4096 bytes. So we cannot safely
342  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
343  to allow for a few compiler-allocated temporary stack slots. */
344 #define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
345 #endif
346 #else
347 #define YYSTACK_ALLOC YYMALLOC
348 #define YYSTACK_FREE YYFREE
349 #ifndef YYSTACK_ALLOC_MAXIMUM
350 #define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
351 #endif
352 #if ( \
353  defined __cplusplus && !defined _STDLIB_H && \
354  !((defined YYMALLOC || defined malloc) && \
355  (defined YYFREE || defined free)))
356 #include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
357 #ifndef _STDLIB_H
358 #define _STDLIB_H 1
359 #endif
360 #endif
361 #ifndef YYMALLOC
362 #define YYMALLOC malloc
363 #if !defined malloc && !defined _STDLIB_H && \
364  (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
365  defined _MSC_VER)
366 void *malloc(YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
367 #endif
368 #endif
369 #ifndef YYFREE
370 #define YYFREE free
371 #if !defined free && !defined _STDLIB_H && \
372  (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
373  defined _MSC_VER)
374 void free(void *); /* INFRINGES ON USER NAME SPACE */
375 #endif
376 #endif
377 #endif
378 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
379 
380 #if ( \
381  !defined yyoverflow && \
382  (!defined __cplusplus || \
383  (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
384 
385 /* A type that is properly aligned for any stack member. */
386 union yyalloc
387 {
388  yytype_int16 yyss_alloc;
389  YYSTYPE yyvs_alloc;
390 };
391 
392 /* The size of the maximum gap between one aligned stack and the next. */
393 #define YYSTACK_GAP_MAXIMUM (sizeof(union yyalloc) - 1)
394 
395 /* The size of an array large to enough to hold all stacks, each with
396  N elements. */
397 #define YYSTACK_BYTES(N) \
398  ((N) * (sizeof(yytype_int16) + sizeof(YYSTYPE)) + YYSTACK_GAP_MAXIMUM)
399 
400 /* Copy COUNT objects from FROM to TO. The source and destination do
401  not overlap. */
402 #ifndef YYCOPY
403 #if defined __GNUC__ && 1 < __GNUC__
404 #define YYCOPY(To, From, Count) \
405  __builtin_memcpy(To, From, (Count) * sizeof(*(From)))
406 #else
407 #define YYCOPY(To, From, Count) \
408  do \
409  { \
410  YYSIZE_T yyi; \
411  for (yyi = 0; yyi < (Count); yyi++) \
412  (To)[yyi] = (From)[yyi]; \
413  } while (YYID(0))
414 #endif
415 #endif
416 
417 /* Relocate STACK from its old location to the new one. The
418  local variables YYSIZE and YYSTACKSIZE give the old and new number of
419  elements in the stack, and YYPTR gives the new location of the
420  stack. Advance YYPTR to a properly aligned location for the next
421  stack. */
422 #define YYSTACK_RELOCATE(Stack_alloc, Stack) \
423  do \
424  { \
425  YYSIZE_T yynewbytes; \
426  YYCOPY(&yyptr->Stack_alloc, Stack, yysize); \
427  Stack = &yyptr->Stack_alloc; \
428  yynewbytes = yystacksize * sizeof(*Stack) + YYSTACK_GAP_MAXIMUM; \
429  yyptr += yynewbytes / sizeof(*yyptr); \
430  } while (YYID(0))
431 
432 #endif
433 
434 /* YYFINAL -- State number of the termination state. */
435 #define YYFINAL 31
436 /* YYLAST -- Last index in YYTABLE. */
437 #define YYLAST 72
438 
439 /* YYNTOKENS -- Number of terminals. */
440 #define YYNTOKENS 27
441 /* YYNNTS -- Number of nonterminals. */
442 #define YYNNTS 10
443 /* YYNRULES -- Number of rules. */
444 #define YYNRULES 34
445 /* YYNRULES -- Number of states. */
446 #define YYNSTATES 72
447 
448 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
449 #define YYUNDEFTOK 2
450 #define YYMAXUTOK 281
451 
452 #define YYTRANSLATE(YYX) \
453  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
454 
455 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
456 static const yytype_uint8 yytranslate[] = {
457  0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
458  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
459  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
460  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
461  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
462  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
463  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
464  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
465  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
466  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
467  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
468  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
469  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
470  2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
471  11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26};
472 
473 #if YYDEBUG
474 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
475  YYRHS. */
476 static const yytype_uint8 yyprhs[] = {
477  0, 0, 3, 7, 10, 12, 16, 20, 23, 24, 27, 29, 32, 35, 38, 41, 44, 47,
478  50, 53, 56, 59, 62, 64, 66, 72, 78, 80, 82, 84, 92, 100, 104, 105, 108};
479 
480 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
481 static const yytype_int8 yyrhs[] = {
482  28, 0, -1, 29, 3, 28, -1, 3, 28, -1, 26, -1, 21, 5, 24, -1, 21, 5, 23,
483  -1, 24, 30, -1, -1, 31, 30, -1, 32, -1, 6, 32, -1, 7, 32, -1, 10, 32, -1,
484  8, 32, -1, 9, 32, -1, 12, 32, -1, 11, 32, -1, 13, 32, -1, 15, 32, -1, 14,
485  32, -1, 16, 32, -1, 33, -1, 34, -1, 18, 19, 24, 20, 33, -1, 18, 19, 5, 20,
486  33, -1, 23, -1, 35, -1, 5, -1, 17, 19, 24, 20, 19, 23, 20, -1, 17, 19, 5,
487  20, 19, 23, 20, -1, 4, 36, 4, -1, -1, 5, 36, -1, 22, 36, -1};
488 
489 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
490 static const yytype_uint8 yyrline[] = {
491  0, 51, 51, 52, 53, 56, 57, 58, 61, 62, 65, 66, 67, 68, 69, 70, 71, 72,
492  73, 74, 75, 76, 79, 80, 81, 82, 85, 86, 87, 90, 91, 94, 97, 98, 99};
493 #endif
494 
495 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
496 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
497  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
498 static const char *const yytname[] = {"$end",
499  "error",
500  "$undefined",
501  "NEWLINE",
502  "QUOTE",
503  "STRING",
504  "CTRL",
505  "SHIFT",
506  "ALT",
507  "ALTGR",
508  "CTRL_SHIFT",
509  "SHIFT_ALT",
510  "CTRL_ALT",
511  "CTRL_SHIFT_ALT",
512  "SHIFT_ALTGR",
513  "CTRL_ALTGR",
514  "CTRL_SHIFT_ALTGR",
515  "SET_COMBINE",
516  "COMBINE",
517  "OPEN_SQ",
518  "CLOSE_SQ",
519  "DEFINE",
520  "QUOTED_CHAR",
521  "CODE_POINT",
522  "NUM",
523  "ERROR",
524  "END",
525  "$accept",
526  "command",
527  "command_part",
528  "sections",
529  "section",
530  "combine",
531  "point",
532  "set_combination",
533  "string",
534  "string_internal",
535  0};
536 #endif
537 
538 #ifdef YYPRINT
539 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
540  token YYLEX-NUM. */
541 static const yytype_uint16 yytoknum[] = {
542  0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
543  269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281};
544 #endif
545 
546 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
547 static const yytype_uint8 yyr1[] = {
548  0, 27, 28, 28, 28, 29, 29, 29, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31,
549  31, 31, 31, 31, 32, 32, 32, 32, 33, 33, 33, 34, 34, 35, 36, 36, 36};
550 
551 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
552 static const yytype_uint8 yyr2[] = {0, 2, 3, 2, 1, 3, 3, 2, 0, 2, 1, 2,
553  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
554  5, 5, 1, 1, 1, 7, 7, 3, 0, 2, 2};
555 
556 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
557  STATE-NUM when YYTABLE doesn't specify something else to do. Zero
558  means the default is an error. */
559 static const yytype_uint8 yydefact[] = {
560  0, 0, 0, 8, 4, 0, 0, 3, 0, 32, 28, 0, 0, 0, 0, 0, 0, 0,
561  0, 0, 0, 0, 0, 0, 26, 7, 8, 10, 22, 23, 27, 1, 0, 6, 5, 32,
562  32, 0, 11, 12, 14, 15, 13, 17, 16, 18, 20, 19, 21, 0, 0, 9, 2, 33,
563  34, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 24, 0, 0, 30, 29};
564 
565 /* YYDEFGOTO[NTERM-NUM]. */
566 static const yytype_int8 yydefgoto[] = {-1, 5, 6, 25, 26, 27, 28, 29, 30, 37};
567 
568 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
569  STATE-NUM. */
570 #define YYPACT_NINF -34
571 static const yytype_int8 yypact[] = {
572  -2, -2, 30, 0, -34, 38, 37, -34, -21, 27, -34, 16, 16, 16, 16,
573  16, 16, 16, 16, 16, 16, 16, 24, 26, -34, -34, 0, -34, -34, -34,
574  -34, -34, -2, -34, -34, 27, 27, 44, -34, -34, -34, -34, -34, -34, -34,
575  -34, -34, -34, -34, 22, 23, -34, -34, -34, -34, -34, 41, 42, 43, 45,
576  47, 48, 21, 21, 18, 19, -34, -34, 49, 50, -34, -34};
577 
578 /* YYPGOTO[NTERM-NUM]. */
579 static const yytype_int8 yypgoto[] = {-34, -1, -34, 46, -34,
580  39, -33, -34, -34, 1};
581 
582 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
583  positive, shift that token. If negative, reduce the rule which
584  number is the opposite. If zero, do what YYDEFACT says.
585  If YYTABLE_NINF, syntax error. */
586 #define YYTABLE_NINF -1
587 static const yytype_uint8 yytable[] = {
588  7, 1, 33, 34, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
589  2, 9, 10, 3, 24, 4, 9, 10, 56, 58, 66, 67, 52, 35, 22, 23, 8, 53, 54,
590  31, 24, 32, 68, 69, 49, 24, 50, 57, 59, 55, 36, 38, 39, 40, 41, 42, 43, 44,
591  45, 46, 47, 48, 60, 61, 62, 0, 63, 64, 65, 0, 70, 71, 0, 51};
592 
593 static const yytype_int8 yycheck[] = {
594  1, 3, 23, 24, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
595  21, 4, 5, 24, 23, 26, 4, 5, 5, 5, 62, 63, 32, 5, 17, 18, 5, 35, 36,
596  0, 23, 3, 23, 23, 19, 23, 19, 24, 24, 4, 22, 11, 12, 13, 14, 15, 16, 17,
597  18, 19, 20, 21, 20, 20, 20, -1, 20, 19, 19, -1, 20, 20, -1, 26};
598 
599 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
600  symbol of state STATE-NUM. */
601 static const yytype_uint8 yystos[] = {
602  0, 3, 21, 24, 26, 28, 29, 28, 5, 4, 5, 6, 7, 8, 9, 10, 11, 12,
603  13, 14, 15, 16, 17, 18, 23, 30, 31, 32, 33, 34, 35, 0, 3, 23, 24, 5,
604  22, 36, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 19, 19, 30, 28, 36,
605  36, 4, 5, 24, 5, 24, 20, 20, 20, 20, 19, 19, 33, 33, 23, 23, 20, 20};
606 
607 #define yyerrok (yyerrstatus = 0)
608 #define yyclearin (yychar = YYEMPTY)
609 #define YYEMPTY (-2)
610 #define YYEOF 0
611 
612 #define YYACCEPT goto yyacceptlab
613 #define YYABORT goto yyabortlab
614 #define YYERROR goto yyerrorlab
615 
616 /* Like YYERROR except do call yyerror. This remains here temporarily
617  to ease the transition to the new meaning of YYERROR, for GCC.
618  Once GCC version 2 has supplanted version 1, this can go. */
619 
620 #define YYFAIL goto yyerrlab
621 
622 #define YYRECOVERING() (!!yyerrstatus)
623 
624 #define YYBACKUP(Token, Value) \
625  do \
626  if (yychar == YYEMPTY && yylen == 1) \
627  { \
628  yychar = (Token); \
629  yylval = (Value); \
630  yytoken = YYTRANSLATE(yychar); \
631  YYPOPSTACK(1); \
632  goto yybackup; \
633  } \
634  else \
635  { \
636  yyerror(YY_("syntax error: cannot back up")); \
637  YYERROR; \
638  } \
639  while (YYID(0))
640 
641 #define YYTERROR 1
642 #define YYERRCODE 256
643 
644 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
645  If N is 0, then set CURRENT to the empty location which ends
646  the previous symbol: RHS[0] (always defined). */
647 
648 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
649 #ifndef YYLLOC_DEFAULT
650 #define YYLLOC_DEFAULT(Current, Rhs, N) \
651  do \
652  if (YYID(N)) \
653  { \
654  (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \
655  (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \
656  (Current).last_line = YYRHSLOC(Rhs, N).last_line; \
657  (Current).last_column = YYRHSLOC(Rhs, N).last_column; \
658  } \
659  else \
660  { \
661  (Current).first_line = (Current).last_line = \
662  YYRHSLOC(Rhs, 0).last_line; \
663  (Current).first_column = (Current).last_column = \
664  YYRHSLOC(Rhs, 0).last_column; \
665  } \
666  while (YYID(0))
667 #endif
668 
669 /* YY_LOCATION_PRINT -- Print the location on the stream.
670  This macro was not mandated originally: define only if we know
671  we won't break user code: when these are the locations we know. */
672 
673 #ifndef YY_LOCATION_PRINT
674 #if YYLTYPE_IS_TRIVIAL
675 #define YY_LOCATION_PRINT(File, Loc) \
676  fprintf( \
677  File, "%d.%d-%d.%d", (Loc).first_line, (Loc).first_column, \
678  (Loc).last_line, (Loc).last_column)
679 #else
680 #define YY_LOCATION_PRINT(File, Loc) ((void) 0)
681 #endif
682 #endif
683 
684 /* YYLEX -- calling `yylex' with the right arguments. */
685 
686 #ifdef YYLEX_PARAM
687 #define YYLEX yylex(YYLEX_PARAM)
688 #else
689 #define YYLEX yylex()
690 #endif
691 
692 /* Enable debugging if requested. */
693 #if YYDEBUG
694 
695 #ifndef YYFPRINTF
696 #include <stdio.h> /* INFRINGES ON USER NAME SPACE */
697 #define YYFPRINTF fprintf
698 #endif
699 
700 #define YYDPRINTF(Args) \
701  do \
702  { \
703  if (yydebug) \
704  YYFPRINTF Args; \
705  } while (YYID(0))
706 
707 #define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
708  do \
709  { \
710  if (yydebug) \
711  { \
712  YYFPRINTF(stderr, "%s ", Title); \
713  yy_symbol_print(stderr, Type, Value); \
714  YYFPRINTF(stderr, "\n"); \
715  } \
716  } while (YYID(0))
717 
718 /*--------------------------------.
719 | Print this symbol on YYOUTPUT. |
720 `--------------------------------*/
721 
722 /*ARGSUSED*/
723 #if ( \
724  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
725  defined _MSC_VER)
726 static void
727 yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
728 #else
729 static void yy_symbol_value_print(yyoutput, yytype, yyvaluep) FILE *yyoutput;
730 int yytype;
731 YYSTYPE const *const yyvaluep;
732 #endif
733 {
734  if (!yyvaluep)
735  return;
736 #ifdef YYPRINT
737  if (yytype < YYNTOKENS)
738  YYPRINT(yyoutput, yytoknum[yytype], *yyvaluep);
739 #else
740  YYUSE(yyoutput);
741 #endif
742  switch (yytype)
743  {
744  default:
745  break;
746  }
747 }
748 
749 /*--------------------------------.
750 | Print this symbol on YYOUTPUT. |
751 `--------------------------------*/
752 
753 #if ( \
754  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
755  defined _MSC_VER)
756 static void
757 yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
758 #else
759 static void yy_symbol_print(yyoutput, yytype, yyvaluep) FILE *yyoutput;
760 int yytype;
761 YYSTYPE const *const yyvaluep;
762 #endif
763 {
764  if (yytype < YYNTOKENS)
765  YYFPRINTF(yyoutput, "token %s (", yytname[yytype]);
766  else
767  YYFPRINTF(yyoutput, "nterm %s (", yytname[yytype]);
768 
769  yy_symbol_value_print(yyoutput, yytype, yyvaluep);
770  YYFPRINTF(yyoutput, ")");
771 }
772 
773 /*------------------------------------------------------------------.
774 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
775 | TOP (included). |
776 `------------------------------------------------------------------*/
777 
778 #if ( \
779  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
780  defined _MSC_VER)
781 static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
782 #else
783 static void yy_stack_print(yybottom, yytop) yytype_int16 *yybottom;
784 yytype_int16 *yytop;
785 #endif
786 {
787  YYFPRINTF(stderr, "Stack now");
788  for (; yybottom <= yytop; yybottom++)
789  {
790  int yybot = *yybottom;
791  YYFPRINTF(stderr, " %d", yybot);
792  }
793  YYFPRINTF(stderr, "\n");
794 }
795 
796 #define YY_STACK_PRINT(Bottom, Top) \
797  do \
798  { \
799  if (yydebug) \
800  yy_stack_print((Bottom), (Top)); \
801  } while (YYID(0))
802 
803 /*------------------------------------------------.
804 | Report that the YYRULE is going to be reduced. |
805 `------------------------------------------------*/
806 
807 #if ( \
808  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
809  defined _MSC_VER)
810 static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule)
811 #else
812 static void yy_reduce_print(yyvsp, yyrule) YYSTYPE *yyvsp;
813 int yyrule;
814 #endif
815 {
816  int yynrhs = yyr2[yyrule];
817  int yyi;
818  unsigned long int yylno = yyrline[yyrule];
819  YYFPRINTF(
820  stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno);
821  /* The symbols being reduced. */
822  for (yyi = 0; yyi < yynrhs; yyi++)
823  {
824  YYFPRINTF(stderr, " $%d = ", yyi + 1);
825  yy_symbol_print(
826  stderr, yyrhs[yyprhs[yyrule] + yyi],
827  &(yyvsp[(yyi + 1) - (yynrhs)]));
828  YYFPRINTF(stderr, "\n");
829  }
830 }
831 
832 #define YY_REDUCE_PRINT(Rule) \
833  do \
834  { \
835  if (yydebug) \
836  yy_reduce_print(yyvsp, Rule); \
837  } while (YYID(0))
838 
839 /* Nonzero means print parse trace. It is left uninitialized so that
840  multiple parsers can coexist. */
841 int yydebug;
842 #else /* !YYDEBUG */
843 #define YYDPRINTF(Args)
844 #define YY_SYMBOL_PRINT(Title, Type, Value, Location)
845 #define YY_STACK_PRINT(Bottom, Top)
846 #define YY_REDUCE_PRINT(Rule)
847 #endif /* !YYDEBUG */
848 
849 /* YYINITDEPTH -- initial size of the parser's stacks. */
850 #ifndef YYINITDEPTH
851 #define YYINITDEPTH 200
852 #endif
853 
854 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
855  if the built-in stack extension method is used).
856 
857  Do not make this value too large; the results are undefined if
858  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
859  evaluated with infinite-precision integer arithmetic. */
860 
861 #ifndef YYMAXDEPTH
862 #define YYMAXDEPTH 10000
863 #endif
864 
865 #if YYERROR_VERBOSE
866 
867 #ifndef yystrlen
868 #if defined __GLIBC__ && defined _STRING_H
869 #define yystrlen strlen
870 #else
871 /* Return the length of YYSTR. */
872 #if ( \
873  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
874  defined _MSC_VER)
875 static YYSIZE_T yystrlen(const char *yystr)
876 #else
877 static YYSIZE_T yystrlen(yystr) const char *yystr;
878 #endif
879 {
880  YYSIZE_T yylen;
881  for (yylen = 0; yystr[yylen]; yylen++)
882  continue;
883  return yylen;
884 }
885 #endif
886 #endif
887 
888 #ifndef yystpcpy
889 #if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
890 #define yystpcpy stpcpy
891 #else
892 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
893  YYDEST. */
894 #if ( \
895  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
896  defined _MSC_VER)
897 static char *yystpcpy(char *yydest, const char *yysrc)
898 #else
899 static char *yystpcpy(yydest, yysrc) char *yydest;
900 const char *yysrc;
901 #endif
902 {
903  char *yyd = yydest;
904  const char *yys = yysrc;
905 
906  while ((*yyd++ = *yys++) != '\0')
907  continue;
908 
909  return yyd - 1;
910 }
911 #endif
912 #endif
913 
914 #ifndef yytnamerr
915 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
916  quotes and backslashes, so that it's suitable for yyerror. The
917  heuristic is that double-quoting is unnecessary unless the string
918  contains an apostrophe, a comma, or backslash (other than
919  backslash-backslash). YYSTR is taken from yytname. If YYRES is
920  null, do not copy; instead, return the length of what the result
921  would have been. */
922 static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
923 {
924  if (*yystr == '"')
925  {
926  YYSIZE_T yyn = 0;
927  char const *yyp = yystr;
928 
929  for (;;)
930  switch (*++yyp)
931  {
932  case '\'':
933  case ',':
934  goto do_not_strip_quotes;
935 
936  case '\\':
937  if (*++yyp != '\\')
938  goto do_not_strip_quotes;
939  /* Fall through. */
940  default:
941  if (yyres)
942  yyres[yyn] = *yyp;
943  yyn++;
944  break;
945 
946  case '"':
947  if (yyres)
948  yyres[yyn] = '\0';
949  return yyn;
950  }
951  do_not_strip_quotes:;
952  }
953 
954  if (!yyres)
955  return yystrlen(yystr);
956 
957  return yystpcpy(yyres, yystr) - yyres;
958 }
959 #endif
960 
961 /* Copy into YYRESULT an error message about the unexpected token
962  YYCHAR while in state YYSTATE. Return the number of bytes copied,
963  including the terminating null byte. If YYRESULT is null, do not
964  copy anything; just return the number of bytes that would be
965  copied. As a special case, return 0 if an ordinary "syntax error"
966  message will do. Return YYSIZE_MAXIMUM if overflow occurs during
967  size calculation. */
968 static YYSIZE_T yysyntax_error(char *yyresult, int yystate, int yychar)
969 {
970  int yyn = yypact[yystate];
971 
972  if (!(YYPACT_NINF < yyn && yyn <= YYLAST))
973  return 0;
974  else
975  {
976  int yytype = YYTRANSLATE(yychar);
977  YYSIZE_T yysize0 = yytnamerr(0, yytname[yytype]);
978  YYSIZE_T yysize = yysize0;
979  YYSIZE_T yysize1;
980  int yysize_overflow = 0;
981  enum
982  {
983  YYERROR_VERBOSE_ARGS_MAXIMUM = 5
984  };
985  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
986  int yyx;
987 
988 #if 0
989  /* This is so xgettext sees the translatable formats that are
990  constructed on the fly. */
991  YY_("syntax error, unexpected %s");
992  YY_("syntax error, unexpected %s, expecting %s");
993  YY_("syntax error, unexpected %s, expecting %s or %s");
994  YY_("syntax error, unexpected %s, expecting %s or %s or %s");
995  YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
996 #endif
997  char *yyfmt;
998  char const *yyf;
999  static char const yyunexpected[] = "syntax error, unexpected %s";
1000  static char const yyexpecting[] = ", expecting %s";
1001  static char const yyor[] = " or %s";
1002  char yyformat
1003  [sizeof yyunexpected + sizeof yyexpecting - 1 +
1004  ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) * (sizeof yyor - 1))];
1005  char const *yyprefix = yyexpecting;
1006 
1007  /* Start YYX at -YYN if negative to avoid negative indexes in
1008  YYCHECK. */
1009  int yyxbegin = yyn < 0 ? -yyn : 0;
1010 
1011  /* Stay within bounds of both yycheck and yytname. */
1012  int yychecklim = YYLAST - yyn + 1;
1013  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1014  int yycount = 1;
1015 
1016  yyarg[0] = yytname[yytype];
1017  yyfmt = yystpcpy(yyformat, yyunexpected);
1018 
1019  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1020  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1021  {
1022  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1023  {
1024  yycount = 1;
1025  yysize = yysize0;
1026  yyformat[sizeof yyunexpected - 1] = '\0';
1027  break;
1028  }
1029  yyarg[yycount++] = yytname[yyx];
1030  yysize1 = yysize + yytnamerr(0, yytname[yyx]);
1031  yysize_overflow |= (yysize1 < yysize);
1032  yysize = yysize1;
1033  yyfmt = yystpcpy(yyfmt, yyprefix);
1034  yyprefix = yyor;
1035  }
1036 
1037  yyf = YY_(yyformat);
1038  yysize1 = yysize + yystrlen(yyf);
1039  yysize_overflow |= (yysize1 < yysize);
1040  yysize = yysize1;
1041 
1042  if (yysize_overflow)
1043  return YYSIZE_MAXIMUM;
1044 
1045  if (yyresult)
1046  {
1047  /* Avoid sprintf, as that infringes on the user's name space.
1048  Don't have undefined behavior even if the translation
1049  produced a string with the wrong number of "%s"s. */
1050  char *yyp = yyresult;
1051  int yyi = 0;
1052  while ((*yyp = *yyf) != '\0')
1053  {
1054  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1055  {
1056  yyp += yytnamerr(yyp, yyarg[yyi++]);
1057  yyf += 2;
1058  }
1059  else
1060  {
1061  yyp++;
1062  yyf++;
1063  }
1064  }
1065  }
1066  return yysize;
1067  }
1068 }
1069 #endif /* YYERROR_VERBOSE */
1070 
1071 /*-----------------------------------------------.
1072 | Release the memory associated to this symbol. |
1073 `-----------------------------------------------*/
1074 
1075 /*ARGSUSED*/
1076 #if ( \
1077  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
1078  defined _MSC_VER)
1079 static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1080 #else
1081 static void yydestruct(yymsg, yytype, yyvaluep) const char *yymsg;
1082 int yytype;
1083 YYSTYPE *yyvaluep;
1084 #endif
1085 {
1086  YYUSE(yyvaluep);
1087 
1088  if (!yymsg)
1089  yymsg = "Deleting";
1090  YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp);
1091 
1092  switch (yytype)
1093  {
1094  default:
1095  break;
1096  }
1097 }
1098 
1099 /* Prevent warnings from -Wmissing-prototypes. */
1100 #ifdef YYPARSE_PARAM
1101 #if defined __STDC__ || defined __cplusplus
1102 int yyparse(void *YYPARSE_PARAM);
1103 #else
1104 int yyparse();
1105 #endif
1106 #else /* ! YYPARSE_PARAM */
1107 #if defined __STDC__ || defined __cplusplus
1108 int yyparse(void);
1109 #else
1110 int yyparse();
1111 #endif
1112 #endif /* ! YYPARSE_PARAM */
1113 
1114 /* The lookahead symbol. */
1115 int yychar;
1116 
1117 /* The semantic value of the lookahead symbol. */
1118 YYSTYPE yylval;
1119 
1120 /* Number of syntax errors so far. */
1121 int yynerrs;
1122 
1123 /*-------------------------.
1124 | yyparse or yypush_parse. |
1125 `-------------------------*/
1126 
1127 #ifdef YYPARSE_PARAM
1128 #if ( \
1129  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
1130  defined _MSC_VER)
1131 int yyparse(void *YYPARSE_PARAM)
1132 #else
1133 int yyparse(YYPARSE_PARAM) void *YYPARSE_PARAM;
1134 #endif
1135 #else /* ! YYPARSE_PARAM */
1136 #if ( \
1137  defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || \
1138  defined _MSC_VER)
1139 int yyparse(void)
1140 #else
1141 int yyparse()
1142 
1143 #endif
1144 #endif
1145 {
1146  int yystate;
1147  /* Number of tokens to shift before error messages enabled. */
1148  int yyerrstatus;
1149 
1150  /* The stacks and their tools:
1151  `yyss': related to states.
1152  `yyvs': related to semantic values.
1153 
1154  Refer to the stacks thru separate pointers, to allow yyoverflow
1155  to reallocate them elsewhere. */
1156 
1157  /* The state stack. */
1158  yytype_int16 yyssa[YYINITDEPTH];
1159  yytype_int16 *yyss;
1160  yytype_int16 *yyssp;
1161 
1162  /* The semantic value stack. */
1163  YYSTYPE yyvsa[YYINITDEPTH];
1164  YYSTYPE *yyvs;
1165  YYSTYPE *yyvsp;
1166 
1167  YYSIZE_T yystacksize;
1168 
1169  int yyn;
1170  int yyresult;
1171  /* Lookahead token as an internal (translated) token number. */
1172  int yytoken;
1173  /* The variables used to return semantic value and location from the
1174  action routines. */
1175  YYSTYPE yyval;
1176 
1177 #if YYERROR_VERBOSE
1178  /* Buffer for error messages, and its allocated size. */
1179  char yymsgbuf[128];
1180  char *yymsg = yymsgbuf;
1181  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1182 #endif
1183 
1184 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1185 
1186  /* The number of symbols on the RHS of the reduced rule.
1187  Keep to zero when no symbol should be popped. */
1188  int yylen = 0;
1189 
1190  yytoken = 0;
1191  yyss = yyssa;
1192  yyvs = yyvsa;
1193  yystacksize = YYINITDEPTH;
1194 
1195  YYDPRINTF((stderr, "Starting parse\n"));
1196 
1197  yystate = 0;
1198  yyerrstatus = 0;
1199  yynerrs = 0;
1200  yychar = YYEMPTY; /* Cause a token to be read. */
1201 
1202  /* Initialize stack pointers.
1203  Waste one element of value and location stack
1204  so that they stay on the same level as the state stack.
1205  The wasted elements are never initialized. */
1206  yyssp = yyss;
1207  yyvsp = yyvs;
1208 
1209  goto yysetstate;
1210 
1211 /*------------------------------------------------------------.
1212 | yynewstate -- Push a new state, which is found in yystate. |
1213 `------------------------------------------------------------*/
1214 yynewstate:
1215  /* In all cases, when you get here, the value and location stacks
1216  have just been pushed. So pushing a state here evens the stacks. */
1217  yyssp++;
1218 
1219 yysetstate:
1220  *yyssp = yystate;
1221 
1222  if (yyss + yystacksize - 1 <= yyssp)
1223  {
1224  /* Get the current used size of the three stacks, in elements. */
1225  YYSIZE_T yysize = yyssp - yyss + 1;
1226 
1227 #ifdef yyoverflow
1228  {
1229  /* Give user a chance to reallocate the stack. Use copies of
1230  these so that the &'s don't force the real ones into
1231  memory. */
1232  YYSTYPE *yyvs1 = yyvs;
1233  yytype_int16 *yyss1 = yyss;
1234 
1235  /* Each stack pointer address is followed by the size of the
1236  data in use in that stack, in bytes. This used to be a
1237  conditional around just the two extra args, but that might
1238  be undefined if yyoverflow is a macro. */
1239  yyoverflow(
1240  YY_("memory exhausted"), &yyss1, yysize * sizeof(*yyssp),
1241  &yyvs1, yysize * sizeof(*yyvsp), &yystacksize);
1242 
1243  yyss = yyss1;
1244  yyvs = yyvs1;
1245  }
1246 #else /* no yyoverflow */
1247 #ifndef YYSTACK_RELOCATE
1248  goto yyexhaustedlab;
1249 #else
1250  /* Extend the stack our own way. */
1251  if (YYMAXDEPTH <= yystacksize)
1252  goto yyexhaustedlab;
1253  yystacksize *= 2;
1254  if (YYMAXDEPTH < yystacksize)
1255  yystacksize = YYMAXDEPTH;
1256 
1257  {
1258  yytype_int16 *yyss1 = yyss;
1259  union yyalloc *yyptr =
1260  (union yyalloc *) YYSTACK_ALLOC(YYSTACK_BYTES(yystacksize));
1261  if (!yyptr)
1262  goto yyexhaustedlab;
1263  YYSTACK_RELOCATE(yyss_alloc, yyss);
1264  YYSTACK_RELOCATE(yyvs_alloc, yyvs);
1265 #undef YYSTACK_RELOCATE
1266  if (yyss1 != yyssa)
1267  YYSTACK_FREE(yyss1);
1268  }
1269 #endif
1270 #endif /* no yyoverflow */
1271 
1272  yyssp = yyss + yysize - 1;
1273  yyvsp = yyvs + yysize - 1;
1274 
1275  YYDPRINTF(
1276  (stderr, "Stack size increased to %lu\n",
1277  (unsigned long int) yystacksize));
1278 
1279  if (yyss + yystacksize - 1 <= yyssp)
1280  YYABORT;
1281  }
1282 
1283  YYDPRINTF((stderr, "Entering state %d\n", yystate));
1284 
1285  if (yystate == YYFINAL)
1286  YYACCEPT;
1287 
1288  goto yybackup;
1289 
1290 /*-----------.
1291 | yybackup. |
1292 `-----------*/
1293 yybackup:
1294 
1295  /* Do appropriate processing given the current state. Read a
1296  lookahead token if we need one and don't already have one. */
1297 
1298  /* First try to decide what to do without reference to lookahead token. */
1299  yyn = yypact[yystate];
1300  if (yyn == YYPACT_NINF)
1301  goto yydefault;
1302 
1303  /* Not known => get a lookahead token if don't already have one. */
1304 
1305  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1306  if (yychar == YYEMPTY)
1307  {
1308  YYDPRINTF((stderr, "Reading a token: "));
1309  yychar = YYLEX;
1310  }
1311 
1312  if (yychar <= YYEOF)
1313  {
1314  yychar = yytoken = YYEOF;
1315  YYDPRINTF((stderr, "Now at end of input.\n"));
1316  }
1317  else
1318  {
1319  yytoken = YYTRANSLATE(yychar);
1320  YY_SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc);
1321  }
1322 
1323  /* If the proper action on seeing token YYTOKEN is to reduce or to
1324  detect an error, take that action. */
1325  yyn += yytoken;
1326  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1327  goto yydefault;
1328  yyn = yytable[yyn];
1329  if (yyn <= 0)
1330  {
1331  if (yyn == 0 || yyn == YYTABLE_NINF)
1332  goto yyerrlab;
1333  yyn = -yyn;
1334  goto yyreduce;
1335  }
1336 
1337  /* Count tokens shifted since error; after three, turn off error
1338  status. */
1339  if (yyerrstatus)
1340  yyerrstatus--;
1341 
1342  /* Shift the lookahead token. */
1343  YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc);
1344 
1345  /* Discard the shifted token. */
1346  yychar = YYEMPTY;
1347 
1348  yystate = yyn;
1349  *++yyvsp = yylval;
1350 
1351  goto yynewstate;
1352 
1353 /*-----------------------------------------------------------.
1354 | yydefault -- do the default action for the current state. |
1355 `-----------------------------------------------------------*/
1356 yydefault:
1357  yyn = yydefact[yystate];
1358  if (yyn == 0)
1359  goto yyerrlab;
1360  goto yyreduce;
1361 
1362 /*-----------------------------.
1363 | yyreduce -- Do a reduction. |
1364 `-----------------------------*/
1365 yyreduce:
1366  /* yyn is the number of a rule to reduce with. */
1367  yylen = yyr2[yyn];
1368 
1369  /* If YYLEN is nonzero, implement the default value of the action:
1370  `$$ = $1'.
1371 
1372  Otherwise, the following line sets YYVAL to garbage.
1373  This behavior is undocumented and Bison
1374  users should not rely upon it. Assigning to YYVAL
1375  unconditionally makes the parser a bit smaller, and it avoids a
1376  GCC warning that YYVAL may be used uninitialized. */
1377  yyval = yyvsp[1 - yylen];
1378 
1379  YY_REDUCE_PRINT(yyn);
1380  switch (yyn)
1381  {
1382  case 3:
1383 
1384 /* Line 1455 of yacc.c */
1385 #line 52 "parser.y"
1386  {
1387  }
1388  break;
1389 
1390  case 4:
1391 
1392 /* Line 1455 of yacc.c */
1393 #line 53 "parser.y"
1394  {
1395  YYACCEPT;
1396  }
1397  break;
1398 
1399  case 5:
1400 
1401 /* Line 1455 of yacc.c */
1402 #line 56 "parser.y"
1403  {
1404  (yyval.cmd_list) = 0;
1405  add_define((yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].n));
1406  }
1407  break;
1408 
1409  case 6:
1410 
1411 /* Line 1455 of yacc.c */
1412 #line 57 "parser.y"
1413  {
1414  (yyval.cmd_list) = 0;
1415  add_define((yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].n));
1416  }
1417  break;
1418 
1419  case 7:
1420 
1421 /* Line 1455 of yacc.c */
1422 #line 58 "parser.y"
1423  {
1424  (yyval.cmd_list) = (yyvsp[(2) - (2)].cmd_list);
1425  set_cmds((yyvsp[(1) - (2)].n), (yyval.cmd_list));
1426  }
1427  break;
1428 
1429  case 8:
1430 
1431 /* Line 1455 of yacc.c */
1432 #line 61 "parser.y"
1433  {
1434  (yyval.cmd_list) = 0;
1435  }
1436  break;
1437 
1438  case 9:
1439 
1440 /* Line 1455 of yacc.c */
1441 #line 62 "parser.y"
1442  {
1443  (yyval.cmd_list) = add_to_cmd_list(
1444  (yyvsp[(2) - (2)].cmd_list), (yyvsp[(1) - (2)].cmd));
1445  }
1446  break;
1447 
1448  case 10:
1449 
1450 /* Line 1455 of yacc.c */
1451 #line 65 "parser.y"
1452  {
1453  (yyval.cmd) = (yyvsp[(1) - (1)].cmd);
1454  }
1455  break;
1456 
1457  case 11:
1458 
1459 /* Line 1455 of yacc.c */
1460 #line 66 "parser.y"
1461  {
1462  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1463  (yyval.cmd)->modifiers = CTRL_I;
1464  }
1465  break;
1466 
1467  case 12:
1468 
1469 /* Line 1455 of yacc.c */
1470 #line 67 "parser.y"
1471  {
1472  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1473  (yyval.cmd)->modifiers = SHIFT_I;
1474  }
1475  break;
1476 
1477  case 13:
1478 
1479 /* Line 1455 of yacc.c */
1480 #line 68 "parser.y"
1481  {
1482  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1483  (yyval.cmd)->modifiers = CTRL_I | SHIFT_I;
1484  }
1485  break;
1486 
1487  case 14:
1488 
1489 /* Line 1455 of yacc.c */
1490 #line 69 "parser.y"
1491  {
1492  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1493  (yyval.cmd)->modifiers = ALT_I;
1494  }
1495  break;
1496 
1497  case 15:
1498 
1499 /* Line 1455 of yacc.c */
1500 #line 70 "parser.y"
1501  {
1502  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1503  (yyval.cmd)->modifiers = ALTGR_I;
1504  }
1505  break;
1506 
1507  case 16:
1508 
1509 /* Line 1455 of yacc.c */
1510 #line 71 "parser.y"
1511  {
1512  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1513  (yyval.cmd)->modifiers = CTRL_I | ALT_I;
1514  }
1515  break;
1516 
1517  case 17:
1518 
1519 /* Line 1455 of yacc.c */
1520 #line 72 "parser.y"
1521  {
1522  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1523  (yyval.cmd)->modifiers = SHIFT_I | ALT_I;
1524  }
1525  break;
1526 
1527  case 18:
1528 
1529 /* Line 1455 of yacc.c */
1530 #line 73 "parser.y"
1531  {
1532  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1533  (yyval.cmd)->modifiers = CTRL_I | SHIFT_I | ALT_I;
1534  }
1535  break;
1536 
1537  case 19:
1538 
1539 /* Line 1455 of yacc.c */
1540 #line 74 "parser.y"
1541  {
1542  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1543  (yyval.cmd)->modifiers = CTRL_I | ALTGR_I;
1544  }
1545  break;
1546 
1547  case 20:
1548 
1549 /* Line 1455 of yacc.c */
1550 #line 75 "parser.y"
1551  {
1552  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1553  (yyval.cmd)->modifiers = SHIFT_I | ALTGR_I;
1554  }
1555  break;
1556 
1557  case 21:
1558 
1559 /* Line 1455 of yacc.c */
1560 #line 76 "parser.y"
1561  {
1562  (yyval.cmd) = (yyvsp[(2) - (2)].cmd);
1563  (yyval.cmd)->modifiers = CTRL_I | SHIFT_I | ALTGR_I;
1564  }
1565  break;
1566 
1567  case 22:
1568 
1569 /* Line 1455 of yacc.c */
1570 #line 79 "parser.y"
1571  {
1572  (yyval.cmd) = (yyvsp[(1) - (1)].cmd);
1573  }
1574  break;
1575 
1576  case 23:
1577 
1578 /* Line 1455 of yacc.c */
1579 #line 80 "parser.y"
1580  {
1581  (yyval.cmd) = (yyvsp[(1) - (1)].cmd);
1582  }
1583  break;
1584 
1585  case 24:
1586 
1587 /* Line 1455 of yacc.c */
1588 #line 81 "parser.y"
1589  {
1590  (yyval.cmd) = (yyvsp[(5) - (5)].cmd);
1591  (yyval.cmd)->combinators = (yyvsp[(3) - (5)].n);
1592  }
1593  break;
1594 
1595  case 25:
1596 
1597 /* Line 1455 of yacc.c */
1598 #line 82 "parser.y"
1599  {
1600  (yyval.cmd) = (yyvsp[(5) - (5)].cmd);
1601  (yyval.cmd)->combinators = lookup_define((yyvsp[(3) - (5)].str));
1602  }
1603  break;
1604 
1605  case 26:
1606 
1607 /* Line 1455 of yacc.c */
1608 #line 85 "parser.y"
1609  {
1610  (yyval.cmd) = make_cmd(0, (yyvsp[(1) - (1)].n), (char *) "");
1611  }
1612  break;
1613 
1614  case 27:
1615 
1616 /* Line 1455 of yacc.c */
1617 #line 86 "parser.y"
1618  {
1619  (yyval.cmd) = make_cmd(0, 0, (yyvsp[(1) - (1)].str));
1620  }
1621  break;
1622 
1623  case 28:
1624 
1625 /* Line 1455 of yacc.c */
1626 #line 87 "parser.y"
1627  {
1628  (yyval.cmd) =
1629  make_cmd(0, lookup_define((yyvsp[(1) - (1)].str)), (char *) "");
1630  }
1631  break;
1632 
1633  case 29:
1634 
1635 /* Line 1455 of yacc.c */
1636 #line 90 "parser.y"
1637  {
1638  (yyval.cmd) = make_cmd(0, (yyvsp[(6) - (7)].n), (char *) "");
1639  (yyval.cmd)->set_modifiers = (yyvsp[(3) - (7)].n);
1640  }
1641  break;
1642 
1643  case 30:
1644 
1645 /* Line 1455 of yacc.c */
1646 #line 91 "parser.y"
1647  {
1648  (yyval.cmd) = make_cmd(0, (yyvsp[(6) - (7)].n), (char *) "");
1649  (yyval.cmd)->set_modifiers = lookup_define((yyvsp[(3) - (7)].str));
1650  }
1651  break;
1652 
1653  case 31:
1654 
1655 /* Line 1455 of yacc.c */
1656 #line 94 "parser.y"
1657  {
1658  strcpy((yyval.str), (yyvsp[(2) - (3)].str));
1659  }
1660  break;
1661 
1662  case 32:
1663 
1664 /* Line 1455 of yacc.c */
1665 #line 97 "parser.y"
1666  {
1667  strcpy((yyval.str), "");
1668  }
1669  break;
1670 
1671  case 33:
1672 
1673 /* Line 1455 of yacc.c */
1674 #line 98 "parser.y"
1675  {
1676  strcpy((yyval.str), (yyvsp[(1) - (2)].str));
1677  strcat((yyval.str), (yyvsp[(2) - (2)].str));
1678  }
1679  break;
1680 
1681  case 34:
1682 
1683 /* Line 1455 of yacc.c */
1684 #line 99 "parser.y"
1685  {
1686  strcpy((yyval.str), quote_char((yyvsp[(1) - (2)].c)));
1687  strcat((yyval.str), (yyvsp[(2) - (2)].str));
1688  }
1689  break;
1690 
1691 /* Line 1455 of yacc.c */
1692 #line 1682 "parser.c"
1693  default:
1694  break;
1695  }
1696  YY_SYMBOL_PRINT("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1697 
1698  YYPOPSTACK(yylen);
1699  yylen = 0;
1700  YY_STACK_PRINT(yyss, yyssp);
1701 
1702  *++yyvsp = yyval;
1703 
1704  /* Now `shift' the result of the reduction. Determine what state
1705  that goes to, based on the state we popped back to and the rule
1706  number reduced by. */
1707 
1708  yyn = yyr1[yyn];
1709 
1710  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1711  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1712  yystate = yytable[yystate];
1713  else
1714  yystate = yydefgoto[yyn - YYNTOKENS];
1715 
1716  goto yynewstate;
1717 
1718 /*------------------------------------.
1719 | yyerrlab -- here on detecting error |
1720 `------------------------------------*/
1721 yyerrlab:
1722  /* If not already recovering from an error, report this error. */
1723  if (!yyerrstatus)
1724  {
1725  ++yynerrs;
1726 #if !YYERROR_VERBOSE
1727  yyerror(YY_("syntax error"));
1728 #else
1729  {
1730  YYSIZE_T yysize = yysyntax_error(0, yystate, yychar);
1731  if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1732  {
1733  YYSIZE_T yyalloc = 2 * yysize;
1734  if (!(yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1735  yyalloc = YYSTACK_ALLOC_MAXIMUM;
1736  if (yymsg != yymsgbuf)
1737  YYSTACK_FREE(yymsg);
1738  yymsg = (char *) YYSTACK_ALLOC(yyalloc);
1739  if (yymsg)
1740  yymsg_alloc = yyalloc;
1741  else
1742  {
1743  yymsg = yymsgbuf;
1744  yymsg_alloc = sizeof yymsgbuf;
1745  }
1746  }
1747 
1748  if (0 < yysize && yysize <= yymsg_alloc)
1749  {
1750  (void) yysyntax_error(yymsg, yystate, yychar);
1751  yyerror(yymsg);
1752  }
1753  else
1754  {
1755  yyerror(YY_("syntax error"));
1756  if (yysize != 0)
1757  goto yyexhaustedlab;
1758  }
1759  }
1760 #endif
1761  }
1762 
1763  if (yyerrstatus == 3)
1764  {
1765  /* If just tried and failed to reuse lookahead token after an
1766  error, discard it. */
1767 
1768  if (yychar <= YYEOF)
1769  {
1770  /* Return failure if at end of input. */
1771  if (yychar == YYEOF)
1772  YYABORT;
1773  }
1774  else
1775  {
1776  yydestruct("Error: discarding", yytoken, &yylval);
1777  yychar = YYEMPTY;
1778  }
1779  }
1780 
1781  /* Else will try to reuse lookahead token after shifting the error
1782  token. */
1783  goto yyerrlab1;
1784 
1785 /*---------------------------------------------------.
1786 | yyerrorlab -- error raised explicitly by YYERROR. |
1787 `---------------------------------------------------*/
1788 yyerrorlab:
1789 
1790  /* Pacify compilers like GCC when the user code never invokes
1791  YYERROR and the label yyerrorlab therefore never appears in user
1792  code. */
1793  if (/*CONSTCOND*/ 0)
1794  goto yyerrorlab;
1795 
1796  /* Do not reclaim the symbols of the rule which action triggered
1797  this YYERROR. */
1798  YYPOPSTACK(yylen);
1799  yylen = 0;
1800  YY_STACK_PRINT(yyss, yyssp);
1801  yystate = *yyssp;
1802  goto yyerrlab1;
1803 
1804 /*-------------------------------------------------------------.
1805 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1806 `-------------------------------------------------------------*/
1807 yyerrlab1:
1808  yyerrstatus = 3; /* Each real token shifted decrements this. */
1809 
1810  for (;;)
1811  {
1812  yyn = yypact[yystate];
1813  if (yyn != YYPACT_NINF)
1814  {
1815  yyn += YYTERROR;
1816  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1817  {
1818  yyn = yytable[yyn];
1819  if (0 < yyn)
1820  break;
1821  }
1822  }
1823 
1824  /* Pop the current state because it cannot handle the error token. */
1825  if (yyssp == yyss)
1826  YYABORT;
1827 
1828  yydestruct("Error: popping", yystos[yystate], yyvsp);
1829  YYPOPSTACK(1);
1830  yystate = *yyssp;
1831  YY_STACK_PRINT(yyss, yyssp);
1832  }
1833 
1834  *++yyvsp = yylval;
1835 
1836  /* Shift the error token. */
1837  YY_SYMBOL_PRINT("Shifting", yystos[yyn], yyvsp, yylsp);
1838 
1839  yystate = yyn;
1840  goto yynewstate;
1841 
1842 /*-------------------------------------.
1843 | yyacceptlab -- YYACCEPT comes here. |
1844 `-------------------------------------*/
1845 yyacceptlab:
1846  yyresult = 0;
1847  goto yyreturn;
1848 
1849 /*-----------------------------------.
1850 | yyabortlab -- YYABORT comes here. |
1851 `-----------------------------------*/
1852 yyabortlab:
1853  yyresult = 1;
1854  goto yyreturn;
1855 
1856 #if !defined(yyoverflow) || YYERROR_VERBOSE
1857 /*-------------------------------------------------.
1858 | yyexhaustedlab -- memory exhaustion comes here. |
1859 `-------------------------------------------------*/
1860 yyexhaustedlab:
1861  yyerror(YY_("memory exhausted"));
1862  yyresult = 2;
1863 /* Fall through. */
1864 #endif
1865 
1866 yyreturn:
1867  if (yychar != YYEMPTY)
1868  yydestruct("Cleanup: discarding lookahead", yytoken, &yylval);
1869  /* Do not reclaim the symbols of the rule which action triggered
1870  this YYABORT or YYACCEPT. */
1871  YYPOPSTACK(yylen);
1872  YY_STACK_PRINT(yyss, yyssp);
1873  while (yyssp != yyss)
1874  {
1875  yydestruct("Cleanup: popping", yystos[*yyssp], yyvsp);
1876  YYPOPSTACK(1);
1877  }
1878 #ifndef yyoverflow
1879  if (yyss != yyssa)
1880  YYSTACK_FREE(yyss);
1881 #endif
1882 #if YYERROR_VERBOSE
1883  if (yymsg != yymsgbuf)
1884  YYSTACK_FREE(yymsg);
1885 #endif
1886  /* Make sure YYID is used. */
1887  return YYID(yyresult);
1888 }
1889 
1890 /* Line 1675 of yacc.c */
1891 #line 102 "parser.y"
1892 
1893 char *quote_char(char c)
1894 {
1895  switch (c)
1896  {
1897  case 'e':
1898  return (char *) "\e";
1899  default:
1900  return (char *) "?";
1901  }
1902 }
1903 
1904 struct cmd_list *add_to_cmd_list(struct cmd_list *cl, cmd_t *c)
1905 {
1906  struct cmd_list *cl2 = (struct cmd_list *) malloc(sizeof(struct cmd_list));
1907  cl2->cmd = c;
1908  cl2->next = 0;
1909 
1910  if (cl == 0)
1911  return cl2;
1912  else
1913  {
1914  struct cmd_list *cl3 = cl;
1915  while (cl3->next)
1916  cl3 = cl3->next;
1917  cl3->next = cl2;
1918  return cl;
1919  }
1920 }
1921 
1922 cmd_t *make_cmd(unsigned int scancode, unsigned int unicode_point, char *val)
1923 {
1924  cmd_t *c = (cmd_t *) malloc(sizeof(cmd_t));
1925  c->scancode = scancode;
1926  c->unicode_point = unicode_point;
1927  if (val)
1928  c->val = strdup(val);
1929  else
1930  c->val = 0;
1931  c->modifiers = 0;
1932 
1933  cmds[n_cmds++] = c;
1934  return c;
1935 }
1936 
1937 void set_cmds(unsigned int scancode, struct cmd_list *cl)
1938 {
1939  while (cl)
1940  {
1941  cl->cmd->scancode = scancode;
1942  cl = cl->next;
1943  }
1944 }
1945 
1946 struct def
1947 {
1948  char str[32];
1949  int n;
1950 } defines[1024];
1951 int ndefines = 0;
1952 
1953 void add_define(char *str, int n)
1954 {
1955  memset(defines[ndefines].str, 0, 32);
1956  strcpy(defines[ndefines].str, str);
1957  defines[ndefines++].n = n;
1958 }
1959 
1960 int lookup_define(char *str)
1961 {
1962  int i;
1963  for (i = 0; i < ndefines; i++)
1964  {
1965  if (!strcmp(defines[i].str, str))
1966  return defines[i].n;
1967  }
1968  fprintf(stderr, "Error: define `%s' not found.\n", str);
1969  exit(1);
1970 }
cmd
Definition: cmd.h:30
def
Definition: parser.c:1946
cmd_list
Definition: parser.c:101
ERROR
#define ERROR(text)
Definition: Log.h:82
Generated on Fri Jan 24 2020 06:46:15 for The Pedigree Project by   doxygen 1.8.11