1 /* A Bison parser, made by GNU Bison 2.3. */
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 /* As a special exception, you may create a larger work that contains
24 part or all of the Bison parser skeleton and distribute that work
25 under terms of your choice, so long as that work isn't itself a
26 parser generator using the skeleton or a modified version thereof
27 as a parser skeleton. Alternatively, if you modify or redistribute
28 the parser skeleton itself, you may (at your option) remove this
29 special exception, which will cause the skeleton and the resulting
30 Bison output files to be licensed under the GNU General Public
31 License without this special exception.
33 This special exception was added by the Free Software Foundation in
34 version 2.2 of Bison. */
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37 simplifying the original so-called "semantic" parser. */
39 /* All symbols defined below should begin with yy or YY, to avoid
40 infringing on user name space. This should be done even for local
41 variables, as they might otherwise be expanded by user macros.
42 There are some unavoidable exceptions within include files to
43 define necessary library symbols; they are noted "INFRINGES ON
44 USER NAME SPACE" below. */
46 /* Identify Bison output. */
50 #define YYBISON_VERSION "2.3"
53 #define YYSKELETON_NAME "yacc.c"
58 /* Using locations. */
59 #define YYLSP_NEEDED 0
66 /* Put the tokens into the symbol table, so that GDB and other debuggers
80 /* Copy the first part of user declarations. */
84 * Copyright (c) 2004-2006 Kungliga Tekniska Högskolan
85 * (Royal Institute of Technology, Stockholm, Sweden).
86 * All rights reserved.
88 * Redistribution and use in source and binary forms, with or without
89 * modification, are permitted provided that the following conditions
92 * 1. Redistributions of source code must retain the above copyright
93 * notice, this list of conditions and the following disclaimer.
95 * 2. Redistributions in binary form must reproduce the above copyright
96 * notice, this list of conditions and the following disclaimer in the
97 * documentation and/or other materials provided with the distribution.
99 * 3. Neither the name of the Institute nor the names of its contributors
100 * may be used to endorse or promote products derived from this software
101 * without specific prior written permission.
103 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
104 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
105 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
106 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
107 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
108 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
109 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
110 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
111 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
112 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
129 extern struct assignment *assignment;
131 /* Declarations for Bison:
133 #define YYMALLOC malloc
138 /* Enabling traces. */
143 /* Enabling verbose error messages. */
144 #ifdef YYERROR_VERBOSE
145 # undef YYERROR_VERBOSE
146 # define YYERROR_VERBOSE 1
148 # define YYERROR_VERBOSE 0
151 /* Enabling the token table. */
152 #ifndef YYTOKEN_TABLE
153 # define YYTOKEN_TABLE 0
156 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
157 typedef union YYSTYPE
158 #line 57 "slc-gram.y"
161 struct assignment *assignment;
163 /* Line 193 of yacc.c. */
164 #line 165 "slc-gram.c"
166 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
167 # define YYSTYPE_IS_DECLARED 1
168 # define YYSTYPE_IS_TRIVIAL 1
173 /* Copy the second part of user declarations. */
176 /* Line 216 of yacc.c. */
177 #line 178 "slc-gram.c"
184 typedef YYTYPE_UINT8 yytype_uint8;
186 typedef unsigned char yytype_uint8;
190 typedef YYTYPE_INT8 yytype_int8;
191 #elif (defined __STDC__ || defined __C99__FUNC__ \
192 || defined __cplusplus || defined _MSC_VER)
193 typedef signed char yytype_int8;
195 typedef short int yytype_int8;
199 typedef YYTYPE_UINT16 yytype_uint16;
201 typedef unsigned short int yytype_uint16;
205 typedef YYTYPE_INT16 yytype_int16;
207 typedef short int yytype_int16;
211 # ifdef __SIZE_TYPE__
212 # define YYSIZE_T __SIZE_TYPE__
213 # elif defined size_t
214 # define YYSIZE_T size_t
215 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
216 || defined __cplusplus || defined _MSC_VER)
217 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
218 # define YYSIZE_T size_t
220 # define YYSIZE_T unsigned int
224 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
227 # if defined YYENABLE_NLS && YYENABLE_NLS
229 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
230 # define YY_(msgid) dgettext ("bison-runtime", msgid)
234 # define YY_(msgid) msgid
238 /* Suppress unused-variable warnings by "using" E. */
239 #if ! defined lint || defined __GNUC__
240 # define YYUSE(e) ((void) (e))
242 # define YYUSE(e) /* empty */
245 /* Identity function, used to suppress warnings about constant conditions. */
249 #if (defined __STDC__ || defined __C99__FUNC__ \
250 || defined __cplusplus || defined _MSC_VER)
263 #if ! defined yyoverflow || YYERROR_VERBOSE
265 /* The parser invokes alloca or malloc; define the necessary symbols. */
267 # ifdef YYSTACK_USE_ALLOCA
268 # if YYSTACK_USE_ALLOCA
270 # define YYSTACK_ALLOC __builtin_alloca
271 # elif defined __BUILTIN_VA_ARG_INCR
272 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
274 # define YYSTACK_ALLOC __alloca
275 # elif defined _MSC_VER
276 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
277 # define alloca _alloca
279 # define YYSTACK_ALLOC alloca
280 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
281 || defined __cplusplus || defined _MSC_VER)
282 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
291 # ifdef YYSTACK_ALLOC
292 /* Pacify GCC's `empty if-body' warning. */
293 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
294 # ifndef YYSTACK_ALLOC_MAXIMUM
295 /* The OS might guarantee only one guard page at the bottom of the stack,
296 and a page size can be as small as 4096 bytes. So we cannot safely
297 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
298 to allow for a few compiler-allocated temporary stack slots. */
299 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
302 # define YYSTACK_ALLOC YYMALLOC
303 # define YYSTACK_FREE YYFREE
304 # ifndef YYSTACK_ALLOC_MAXIMUM
305 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
307 # if (defined __cplusplus && ! defined _STDLIB_H \
308 && ! ((defined YYMALLOC || defined malloc) \
309 && (defined YYFREE || defined free)))
310 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
316 # define YYMALLOC malloc
317 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
318 || defined __cplusplus || defined _MSC_VER)
319 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
324 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
325 || defined __cplusplus || defined _MSC_VER)
326 void free (void *); /* INFRINGES ON USER NAME SPACE */
330 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
333 #if (! defined yyoverflow \
334 && (! defined __cplusplus \
335 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
337 /* A type that is properly aligned for any stack member. */
344 /* The size of the maximum gap between one aligned stack and the next. */
345 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
347 /* The size of an array large to enough to hold all stacks, each with
349 # define YYSTACK_BYTES(N) \
350 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
351 + YYSTACK_GAP_MAXIMUM)
353 /* Copy COUNT objects from FROM to TO. The source and destination do
356 # if defined __GNUC__ && 1 < __GNUC__
357 # define YYCOPY(To, From, Count) \
358 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
360 # define YYCOPY(To, From, Count) \
364 for (yyi = 0; yyi < (Count); yyi++) \
365 (To)[yyi] = (From)[yyi]; \
371 /* Relocate STACK from its old location to the new one. The
372 local variables YYSIZE and YYSTACKSIZE give the old and new number of
373 elements in the stack, and YYPTR gives the new location of the
374 stack. Advance YYPTR to a properly aligned location for the next
376 # define YYSTACK_RELOCATE(Stack) \
379 YYSIZE_T yynewbytes; \
380 YYCOPY (&yyptr->Stack, Stack, yysize); \
381 Stack = &yyptr->Stack; \
382 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
383 yyptr += yynewbytes / sizeof (*yyptr); \
389 /* YYFINAL -- State number of the termination state. */
391 /* YYLAST -- Last index in YYTABLE. */
394 /* YYNTOKENS -- Number of terminals. */
396 /* YYNNTS -- Number of nonterminals. */
398 /* YYNRULES -- Number of rules. */
400 /* YYNRULES -- Number of states. */
403 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
405 #define YYMAXUTOK 259
407 #define YYTRANSLATE(YYX) \
408 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
410 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
411 static const yytype_uint8 yytranslate[] =
413 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
414 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
419 2, 5, 2, 2, 2, 2, 2, 2, 2, 2,
420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
424 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
425 2, 2, 2, 6, 2, 7, 2, 2, 2, 2,
426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
433 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
434 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
435 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
436 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
437 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
438 2, 2, 2, 2, 2, 2, 1, 2, 3, 4
442 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
444 static const yytype_uint8 yyprhs[] =
446 0, 0, 3, 5, 8, 10, 14
449 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
450 static const yytype_int8 yyrhs[] =
452 9, 0, -1, 10, -1, 11, 10, -1, 11, -1,
453 3, 5, 4, -1, 3, 5, 6, 10, 7, -1
456 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
457 static const yytype_uint8 yyrline[] =
459 0, 70, 70, 76, 81, 84, 93
463 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
464 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
465 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
466 static const char *const yytname[] =
468 "$end", "error", "$undefined", "LITERAL", "STRING", "'='", "'{'", "'}'",
469 "$accept", "start", "assignments", "assignment", 0
474 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
476 static const yytype_uint16 yytoknum[] =
478 0, 256, 257, 258, 259, 61, 123, 125
482 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
483 static const yytype_uint8 yyr1[] =
485 0, 8, 9, 10, 10, 11, 11
488 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
489 static const yytype_uint8 yyr2[] =
494 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
495 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
496 means the default is an error. */
497 static const yytype_uint8 yydefact[] =
499 0, 0, 0, 2, 4, 0, 1, 3, 5, 0,
503 /* YYDEFGOTO[NTERM-NUM]. */
504 static const yytype_int8 yydefgoto[] =
509 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
511 #define YYPACT_NINF -5
512 static const yytype_int8 yypact[] =
514 -1, 1, 4, -5, -1, -3, -5, -5, -5, -1,
518 /* YYPGOTO[NTERM-NUM]. */
519 static const yytype_int8 yypgoto[] =
524 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
525 positive, shift that token. If negative, reduce the rule which
526 number is the opposite. If zero, do what YYDEFACT says.
527 If YYTABLE_NINF, syntax error. */
528 #define YYTABLE_NINF -1
529 static const yytype_uint8 yytable[] =
531 7, 8, 1, 9, 6, 10, 5, 11
534 static const yytype_uint8 yycheck[] =
536 4, 4, 3, 6, 0, 9, 5, 7
539 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
540 symbol of state STATE-NUM. */
541 static const yytype_uint8 yystos[] =
543 0, 3, 9, 10, 11, 5, 0, 10, 4, 6,
547 #define yyerrok (yyerrstatus = 0)
548 #define yyclearin (yychar = YYEMPTY)
552 #define YYACCEPT goto yyacceptlab
553 #define YYABORT goto yyabortlab
554 #define YYERROR goto yyerrorlab
557 /* Like YYERROR except do call yyerror. This remains here temporarily
558 to ease the transition to the new meaning of YYERROR, for GCC.
559 Once GCC version 2 has supplanted version 1, this can go. */
561 #define YYFAIL goto yyerrlab
563 #define YYRECOVERING() (!!yyerrstatus)
565 #define YYBACKUP(Token, Value) \
567 if (yychar == YYEMPTY && yylen == 1) \
571 yytoken = YYTRANSLATE (yychar); \
577 yyerror (YY_("syntax error: cannot back up")); \
584 #define YYERRCODE 256
587 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
588 If N is 0, then set CURRENT to the empty location which ends
589 the previous symbol: RHS[0] (always defined). */
591 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
592 #ifndef YYLLOC_DEFAULT
593 # define YYLLOC_DEFAULT(Current, Rhs, N) \
597 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
598 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
599 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
600 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
604 (Current).first_line = (Current).last_line = \
605 YYRHSLOC (Rhs, 0).last_line; \
606 (Current).first_column = (Current).last_column = \
607 YYRHSLOC (Rhs, 0).last_column; \
613 /* YY_LOCATION_PRINT -- Print the location on the stream.
614 This macro was not mandated originally: define only if we know
615 we won't break user code: when these are the locations we know. */
617 #ifndef YY_LOCATION_PRINT
618 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
619 # define YY_LOCATION_PRINT(File, Loc) \
620 fprintf (File, "%d.%d-%d.%d", \
621 (Loc).first_line, (Loc).first_column, \
622 (Loc).last_line, (Loc).last_column)
624 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
629 /* YYLEX -- calling `yylex' with the right arguments. */
632 # define YYLEX yylex (YYLEX_PARAM)
634 # define YYLEX yylex ()
637 /* Enable debugging if requested. */
641 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
642 # define YYFPRINTF fprintf
645 # define YYDPRINTF(Args) \
651 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
655 YYFPRINTF (stderr, "%s ", Title); \
656 yy_symbol_print (stderr, \
658 YYFPRINTF (stderr, "\n"); \
663 /*--------------------------------.
664 | Print this symbol on YYOUTPUT. |
665 `--------------------------------*/
668 #if (defined __STDC__ || defined __C99__FUNC__ \
669 || defined __cplusplus || defined _MSC_VER)
671 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
674 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
677 YYSTYPE const * const yyvaluep;
683 if (yytype < YYNTOKENS)
684 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
696 /*--------------------------------.
697 | Print this symbol on YYOUTPUT. |
698 `--------------------------------*/
700 #if (defined __STDC__ || defined __C99__FUNC__ \
701 || defined __cplusplus || defined _MSC_VER)
703 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
706 yy_symbol_print (yyoutput, yytype, yyvaluep)
709 YYSTYPE const * const yyvaluep;
712 if (yytype < YYNTOKENS)
713 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
715 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
717 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
718 YYFPRINTF (yyoutput, ")");
721 /*------------------------------------------------------------------.
722 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
724 `------------------------------------------------------------------*/
726 #if (defined __STDC__ || defined __C99__FUNC__ \
727 || defined __cplusplus || defined _MSC_VER)
729 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
732 yy_stack_print (bottom, top)
733 yytype_int16 *bottom;
737 YYFPRINTF (stderr, "Stack now");
738 for (; bottom <= top; ++bottom)
739 YYFPRINTF (stderr, " %d", *bottom);
740 YYFPRINTF (stderr, "\n");
743 # define YY_STACK_PRINT(Bottom, Top) \
746 yy_stack_print ((Bottom), (Top)); \
750 /*------------------------------------------------.
751 | Report that the YYRULE is going to be reduced. |
752 `------------------------------------------------*/
754 #if (defined __STDC__ || defined __C99__FUNC__ \
755 || defined __cplusplus || defined _MSC_VER)
757 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
760 yy_reduce_print (yyvsp, yyrule)
765 int yynrhs = yyr2[yyrule];
767 unsigned long int yylno = yyrline[yyrule];
768 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
770 /* The symbols being reduced. */
771 for (yyi = 0; yyi < yynrhs; yyi++)
773 fprintf (stderr, " $%d = ", yyi + 1);
774 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
775 &(yyvsp[(yyi + 1) - (yynrhs)])
777 fprintf (stderr, "\n");
781 # define YY_REDUCE_PRINT(Rule) \
784 yy_reduce_print (yyvsp, Rule); \
787 /* Nonzero means print parse trace. It is left uninitialized so that
788 multiple parsers can coexist. */
791 # define YYDPRINTF(Args)
792 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
793 # define YY_STACK_PRINT(Bottom, Top)
794 # define YY_REDUCE_PRINT(Rule)
795 #endif /* !YYDEBUG */
798 /* YYINITDEPTH -- initial size of the parser's stacks. */
800 # define YYINITDEPTH 200
803 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
804 if the built-in stack extension method is used).
806 Do not make this value too large; the results are undefined if
807 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
808 evaluated with infinite-precision integer arithmetic. */
811 # define YYMAXDEPTH 10000
819 # if defined __GLIBC__ && defined _STRING_H
820 # define yystrlen strlen
822 /* Return the length of YYSTR. */
823 #if (defined __STDC__ || defined __C99__FUNC__ \
824 || defined __cplusplus || defined _MSC_VER)
826 yystrlen (const char *yystr)
834 for (yylen = 0; yystr[yylen]; yylen++)
842 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
843 # define yystpcpy stpcpy
845 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
847 #if (defined __STDC__ || defined __C99__FUNC__ \
848 || defined __cplusplus || defined _MSC_VER)
850 yystpcpy (char *yydest, const char *yysrc)
853 yystpcpy (yydest, yysrc)
859 const char *yys = yysrc;
861 while ((*yyd++ = *yys++) != '\0')
870 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
871 quotes and backslashes, so that it's suitable for yyerror. The
872 heuristic is that double-quoting is unnecessary unless the string
873 contains an apostrophe, a comma, or backslash (other than
874 backslash-backslash). YYSTR is taken from yytname. If YYRES is
875 null, do not copy; instead, return the length of what the result
878 yytnamerr (char *yyres, const char *yystr)
883 char const *yyp = yystr;
890 goto do_not_strip_quotes;
894 goto do_not_strip_quotes;
907 do_not_strip_quotes: ;
911 return yystrlen (yystr);
913 return yystpcpy (yyres, yystr) - yyres;
917 /* Copy into YYRESULT an error message about the unexpected token
918 YYCHAR while in state YYSTATE. Return the number of bytes copied,
919 including the terminating null byte. If YYRESULT is null, do not
920 copy anything; just return the number of bytes that would be
921 copied. As a special case, return 0 if an ordinary "syntax error"
922 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
925 yysyntax_error (char *yyresult, int yystate, int yychar)
927 int yyn = yypact[yystate];
929 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
933 int yytype = YYTRANSLATE (yychar);
934 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
935 YYSIZE_T yysize = yysize0;
937 int yysize_overflow = 0;
938 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
939 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
943 /* This is so xgettext sees the translatable formats that are
944 constructed on the fly. */
945 YY_("syntax error, unexpected %s");
946 YY_("syntax error, unexpected %s, expecting %s");
947 YY_("syntax error, unexpected %s, expecting %s or %s");
948 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
949 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
953 static char const yyunexpected[] = "syntax error, unexpected %s";
954 static char const yyexpecting[] = ", expecting %s";
955 static char const yyor[] = " or %s";
956 char yyformat[sizeof yyunexpected
957 + sizeof yyexpecting - 1
958 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
959 * (sizeof yyor - 1))];
960 char const *yyprefix = yyexpecting;
962 /* Start YYX at -YYN if negative to avoid negative indexes in
964 int yyxbegin = yyn < 0 ? -yyn : 0;
966 /* Stay within bounds of both yycheck and yytname. */
967 int yychecklim = YYLAST - yyn + 1;
968 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
971 yyarg[0] = yytname[yytype];
972 yyfmt = yystpcpy (yyformat, yyunexpected);
974 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
975 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
977 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
981 yyformat[sizeof yyunexpected - 1] = '\0';
984 yyarg[yycount++] = yytname[yyx];
985 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
986 yysize_overflow |= (yysize1 < yysize);
988 yyfmt = yystpcpy (yyfmt, yyprefix);
993 yysize1 = yysize + yystrlen (yyf);
994 yysize_overflow |= (yysize1 < yysize);
998 return YYSIZE_MAXIMUM;
1002 /* Avoid sprintf, as that infringes on the user's name space.
1003 Don't have undefined behavior even if the translation
1004 produced a string with the wrong number of "%s"s. */
1005 char *yyp = yyresult;
1007 while ((*yyp = *yyf) != '\0')
1009 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1011 yyp += yytnamerr (yyp, yyarg[yyi++]);
1024 #endif /* YYERROR_VERBOSE */
1027 /*-----------------------------------------------.
1028 | Release the memory associated to this symbol. |
1029 `-----------------------------------------------*/
1032 #if (defined __STDC__ || defined __C99__FUNC__ \
1033 || defined __cplusplus || defined _MSC_VER)
1035 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1038 yydestruct (yymsg, yytype, yyvaluep)
1048 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1059 /* Prevent warnings from -Wmissing-prototypes. */
1061 #ifdef YYPARSE_PARAM
1062 #if defined __STDC__ || defined __cplusplus
1063 int yyparse (void *YYPARSE_PARAM);
1067 #else /* ! YYPARSE_PARAM */
1068 #if defined __STDC__ || defined __cplusplus
1073 #endif /* ! YYPARSE_PARAM */
1077 /* The look-ahead symbol. */
1080 /* The semantic value of the look-ahead symbol. */
1083 /* Number of syntax errors so far. */
1092 #ifdef YYPARSE_PARAM
1093 #if (defined __STDC__ || defined __C99__FUNC__ \
1094 || defined __cplusplus || defined _MSC_VER)
1096 yyparse (void *YYPARSE_PARAM)
1099 yyparse (YYPARSE_PARAM)
1100 void *YYPARSE_PARAM;
1102 #else /* ! YYPARSE_PARAM */
1103 #if (defined __STDC__ || defined __C99__FUNC__ \
1104 || defined __cplusplus || defined _MSC_VER)
1118 /* Number of tokens to shift before error messages enabled. */
1120 /* Look-ahead token as an internal (translated) token number. */
1123 /* Buffer for error messages, and its allocated size. */
1125 char *yymsg = yymsgbuf;
1126 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1129 /* Three stacks and their tools:
1130 `yyss': related to states,
1131 `yyvs': related to semantic values,
1132 `yyls': related to locations.
1134 Refer to the stacks thru separate pointers, to allow yyoverflow
1135 to reallocate them elsewhere. */
1137 /* The state stack. */
1138 yytype_int16 yyssa[YYINITDEPTH];
1139 yytype_int16 *yyss = yyssa;
1140 yytype_int16 *yyssp;
1142 /* The semantic value stack. */
1143 YYSTYPE yyvsa[YYINITDEPTH];
1144 YYSTYPE *yyvs = yyvsa;
1149 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1151 YYSIZE_T yystacksize = YYINITDEPTH;
1153 /* The variables used to return semantic value and location from the
1158 /* The number of symbols on the RHS of the reduced rule.
1159 Keep to zero when no symbol should be popped. */
1162 YYDPRINTF ((stderr, "Starting parse\n"));
1167 yychar = YYEMPTY; /* Cause a token to be read. */
1169 /* Initialize stack pointers.
1170 Waste one element of value and location stack
1171 so that they stay on the same level as the state stack.
1172 The wasted elements are never initialized. */
1179 /*------------------------------------------------------------.
1180 | yynewstate -- Push a new state, which is found in yystate. |
1181 `------------------------------------------------------------*/
1183 /* In all cases, when you get here, the value and location stacks
1184 have just been pushed. So pushing a state here evens the stacks. */
1190 if (yyss + yystacksize - 1 <= yyssp)
1192 /* Get the current used size of the three stacks, in elements. */
1193 YYSIZE_T yysize = yyssp - yyss + 1;
1197 /* Give user a chance to reallocate the stack. Use copies of
1198 these so that the &'s don't force the real ones into
1200 YYSTYPE *yyvs1 = yyvs;
1201 yytype_int16 *yyss1 = yyss;
1204 /* Each stack pointer address is followed by the size of the
1205 data in use in that stack, in bytes. This used to be a
1206 conditional around just the two extra args, but that might
1207 be undefined if yyoverflow is a macro. */
1208 yyoverflow (YY_("memory exhausted"),
1209 &yyss1, yysize * sizeof (*yyssp),
1210 &yyvs1, yysize * sizeof (*yyvsp),
1217 #else /* no yyoverflow */
1218 # ifndef YYSTACK_RELOCATE
1219 goto yyexhaustedlab;
1221 /* Extend the stack our own way. */
1222 if (YYMAXDEPTH <= yystacksize)
1223 goto yyexhaustedlab;
1225 if (YYMAXDEPTH < yystacksize)
1226 yystacksize = YYMAXDEPTH;
1229 yytype_int16 *yyss1 = yyss;
1230 union yyalloc *yyptr =
1231 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1233 goto yyexhaustedlab;
1234 YYSTACK_RELOCATE (yyss);
1235 YYSTACK_RELOCATE (yyvs);
1237 # undef YYSTACK_RELOCATE
1239 YYSTACK_FREE (yyss1);
1242 #endif /* no yyoverflow */
1244 yyssp = yyss + yysize - 1;
1245 yyvsp = yyvs + yysize - 1;
1248 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1249 (unsigned long int) yystacksize));
1251 if (yyss + yystacksize - 1 <= yyssp)
1255 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1264 /* Do appropriate processing given the current state. Read a
1265 look-ahead token if we need one and don't already have one. */
1267 /* First try to decide what to do without reference to look-ahead token. */
1268 yyn = yypact[yystate];
1269 if (yyn == YYPACT_NINF)
1272 /* Not known => get a look-ahead token if don't already have one. */
1274 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1275 if (yychar == YYEMPTY)
1277 YYDPRINTF ((stderr, "Reading a token: "));
1281 if (yychar <= YYEOF)
1283 yychar = yytoken = YYEOF;
1284 YYDPRINTF ((stderr, "Now at end of input.\n"));
1288 yytoken = YYTRANSLATE (yychar);
1289 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1292 /* If the proper action on seeing token YYTOKEN is to reduce or to
1293 detect an error, take that action. */
1295 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1300 if (yyn == 0 || yyn == YYTABLE_NINF)
1309 /* Count tokens shifted since error; after three, turn off error
1314 /* Shift the look-ahead token. */
1315 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1317 /* Discard the shifted token unless it is eof. */
1318 if (yychar != YYEOF)
1327 /*-----------------------------------------------------------.
1328 | yydefault -- do the default action for the current state. |
1329 `-----------------------------------------------------------*/
1331 yyn = yydefact[yystate];
1337 /*-----------------------------.
1338 | yyreduce -- Do a reduction. |
1339 `-----------------------------*/
1341 /* yyn is the number of a rule to reduce with. */
1344 /* If YYLEN is nonzero, implement the default value of the action:
1347 Otherwise, the following line sets YYVAL to garbage.
1348 This behavior is undocumented and Bison
1349 users should not rely upon it. Assigning to YYVAL
1350 unconditionally makes the parser a bit smaller, and it avoids a
1351 GCC warning that YYVAL may be used uninitialized. */
1352 yyval = yyvsp[1-yylen];
1355 YY_REDUCE_PRINT (yyn);
1359 #line 71 "slc-gram.y"
1361 assignment = (yyvsp[(1) - (1)].assignment);
1366 #line 77 "slc-gram.y"
1368 (yyvsp[(1) - (2)].assignment)->next = (yyvsp[(2) - (2)].assignment);
1369 (yyval.assignment) = (yyvsp[(1) - (2)].assignment);
1374 #line 85 "slc-gram.y"
1376 (yyval.assignment) = malloc(sizeof(*(yyval.assignment)));
1377 (yyval.assignment)->name = (yyvsp[(1) - (3)].string);
1378 (yyval.assignment)->type = a_value;
1379 (yyval.assignment)->lineno = lineno;
1380 (yyval.assignment)->u.value = (yyvsp[(3) - (3)].string);
1381 (yyval.assignment)->next = NULL;
1386 #line 94 "slc-gram.y"
1388 (yyval.assignment) = malloc(sizeof(*(yyval.assignment)));
1389 (yyval.assignment)->name = (yyvsp[(1) - (5)].string);
1390 (yyval.assignment)->type = a_assignment;
1391 (yyval.assignment)->lineno = lineno;
1392 (yyval.assignment)->u.assignment = (yyvsp[(4) - (5)].assignment);
1393 (yyval.assignment)->next = NULL;
1398 /* Line 1267 of yacc.c. */
1399 #line 1400 "slc-gram.c"
1402 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1406 YY_STACK_PRINT (yyss, yyssp);
1411 /* Now `shift' the result of the reduction. Determine what state
1412 that goes to, based on the state we popped back to and the rule
1413 number reduced by. */
1417 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1418 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1419 yystate = yytable[yystate];
1421 yystate = yydefgoto[yyn - YYNTOKENS];
1426 /*------------------------------------.
1427 | yyerrlab -- here on detecting error |
1428 `------------------------------------*/
1430 /* If not already recovering from an error, report this error. */
1434 #if ! YYERROR_VERBOSE
1435 yyerror (YY_("syntax error"));
1438 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1439 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1441 YYSIZE_T yyalloc = 2 * yysize;
1442 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1443 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1444 if (yymsg != yymsgbuf)
1445 YYSTACK_FREE (yymsg);
1446 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1448 yymsg_alloc = yyalloc;
1452 yymsg_alloc = sizeof yymsgbuf;
1456 if (0 < yysize && yysize <= yymsg_alloc)
1458 (void) yysyntax_error (yymsg, yystate, yychar);
1463 yyerror (YY_("syntax error"));
1465 goto yyexhaustedlab;
1473 if (yyerrstatus == 3)
1475 /* If just tried and failed to reuse look-ahead token after an
1476 error, discard it. */
1478 if (yychar <= YYEOF)
1480 /* Return failure if at end of input. */
1481 if (yychar == YYEOF)
1486 yydestruct ("Error: discarding",
1492 /* Else will try to reuse look-ahead token after shifting the error
1497 /*---------------------------------------------------.
1498 | yyerrorlab -- error raised explicitly by YYERROR. |
1499 `---------------------------------------------------*/
1502 /* Pacify compilers like GCC when the user code never invokes
1503 YYERROR and the label yyerrorlab therefore never appears in user
1505 if (/*CONSTCOND*/ 0)
1508 /* Do not reclaim the symbols of the rule which action triggered
1512 YY_STACK_PRINT (yyss, yyssp);
1517 /*-------------------------------------------------------------.
1518 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1519 `-------------------------------------------------------------*/
1521 yyerrstatus = 3; /* Each real token shifted decrements this. */
1525 yyn = yypact[yystate];
1526 if (yyn != YYPACT_NINF)
1529 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1537 /* Pop the current state because it cannot handle the error token. */
1542 yydestruct ("Error: popping",
1543 yystos[yystate], yyvsp);
1546 YY_STACK_PRINT (yyss, yyssp);
1555 /* Shift the error token. */
1556 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1562 /*-------------------------------------.
1563 | yyacceptlab -- YYACCEPT comes here. |
1564 `-------------------------------------*/
1569 /*-----------------------------------.
1570 | yyabortlab -- YYABORT comes here. |
1571 `-----------------------------------*/
1577 /*-------------------------------------------------.
1578 | yyexhaustedlab -- memory exhaustion comes here. |
1579 `-------------------------------------------------*/
1581 yyerror (YY_("memory exhausted"));
1587 if (yychar != YYEOF && yychar != YYEMPTY)
1588 yydestruct ("Cleanup: discarding lookahead",
1590 /* Do not reclaim the symbols of the rule which action triggered
1591 this YYABORT or YYACCEPT. */
1593 YY_STACK_PRINT (yyss, yyssp);
1594 while (yyssp != yyss)
1596 yydestruct ("Cleanup: popping",
1597 yystos[*yyssp], yyvsp);
1602 YYSTACK_FREE (yyss);
1605 if (yymsg != yymsgbuf)
1606 YYSTACK_FREE (yymsg);
1608 /* Make sure YYID is used. */
1609 return YYID (yyresult);
1613 #line 104 "slc-gram.y"
1616 FILE *cfile, *hfile;
1618 struct assignment *assignment;
1622 ex(struct assignment *a, const char *fmt, ...)
1625 fprintf(stderr, "%s:%d: ", a->name, a->lineno);
1627 vfprintf(stderr, fmt, ap);
1629 fprintf(stderr, "\n");
1635 check_option(struct assignment *as)
1637 struct assignment *a;
1642 int seen_argument = 0;
1644 int seen_default = 0;
1647 for(a = as; a != NULL; a = a->next) {
1648 if(strcmp(a->name, "long") == 0)
1650 else if(strcmp(a->name, "short") == 0)
1652 else if(strcmp(a->name, "name") == 0)
1654 else if(strcmp(a->name, "type") == 0)
1656 else if(strcmp(a->name, "argument") == 0)
1658 else if(strcmp(a->name, "help") == 0)
1660 else if(strcmp(a->name, "default") == 0)
1663 ex(a, "unknown name %s", a->name);
1667 if(seen_long == 0 && seen_short == 0) {
1668 ex(as, "neither long nor short option");
1671 if (seen_long == 0 && seen_name == 0) {
1672 ex(as, "either of long or name option must be used");
1676 ex(as, "multiple long options");
1679 if(seen_short > 1) {
1680 ex(as, "multiple short options");
1684 ex(as, "multiple types");
1687 if(seen_argument > 1) {
1688 ex(as, "multiple arguments");
1692 ex(as, "multiple help strings");
1695 if(seen_default > 1) {
1696 ex(as, "multiple default values");
1703 check_command(struct assignment *as)
1705 struct assignment *a;
1707 int seen_function = 0;
1709 int seen_argument = 0;
1710 int seen_minargs = 0;
1711 int seen_maxargs = 0;
1713 for(a = as; a != NULL; a = a->next) {
1714 if(strcmp(a->name, "name") == 0)
1716 else if(strcmp(a->name, "function") == 0) {
1718 } else if(strcmp(a->name, "option") == 0)
1719 ret += check_option(a->u.assignment);
1720 else if(strcmp(a->name, "help") == 0) {
1722 } else if(strcmp(a->name, "argument") == 0) {
1724 } else if(strcmp(a->name, "min_args") == 0) {
1726 } else if(strcmp(a->name, "max_args") == 0) {
1729 ex(a, "unknown name: %s", a->name);
1733 if(seen_name == 0) {
1734 ex(as, "no command name");
1737 if(seen_function > 1) {
1738 ex(as, "multiple function names");
1742 ex(as, "multiple help strings");
1745 if(seen_argument > 1) {
1746 ex(as, "multiple argument strings");
1749 if(seen_minargs > 1) {
1750 ex(as, "multiple min_args strings");
1753 if(seen_maxargs > 1) {
1754 ex(as, "multiple max_args strings");
1762 check(struct assignment *as)
1764 struct assignment *a;
1766 for(a = as; a != NULL; a = a->next) {
1767 if(strcmp(a->name, "command")) {
1768 fprintf(stderr, "unknown type %s line %d\n", a->name, a->lineno);
1772 if(a->type != a_assignment) {
1773 fprintf(stderr, "bad command definition %s line %d\n", a->name, a->lineno);
1777 ret += check_command(a->u.assignment);
1782 static struct assignment *
1783 find_next(struct assignment *as, const char *name)
1785 for(as = as->next; as != NULL; as = as->next) {
1786 if(strcmp(as->name, name) == 0)
1792 static struct assignment *
1793 find(struct assignment *as, const char *name)
1795 for(; as != NULL; as = as->next) {
1796 if(strcmp(as->name, name) == 0)
1803 space(FILE *f, int level)
1805 fprintf(f, "%*.*s", level * 4, level * 4, " ");
1809 cprint(int level, const char *fmt, ...)
1813 space(cfile, level);
1814 vfprintf(cfile, fmt, ap);
1819 hprint(int level, const char *fmt, ...)
1823 space(hfile, level);
1824 vfprintf(hfile, fmt, ap);
1828 static void gen_name(char *str);
1831 gen_command(struct assignment *as)
1833 struct assignment *a, *b;
1835 a = find(as, "name");
1836 f = strdup(a->u.value);
1839 fprintf(cfile, "\"%s\", ", a->u.value);
1840 fprintf(cfile, "%s_wrap, ", f);
1841 b = find(as, "argument");
1843 fprintf(cfile, "\"%s %s\", ", a->u.value, b->u.value);
1845 fprintf(cfile, "\"%s\", ", a->u.value);
1846 b = find(as, "help");
1848 fprintf(cfile, "\"%s\"", b->u.value);
1850 fprintf(cfile, "NULL");
1851 fprintf(cfile, " },\n");
1852 for(a = a->next; a != NULL; a = a->next)
1853 if(strcmp(a->name, "name") == 0)
1854 cprint(1, " { \"%s\" },\n", a->u.value);
1862 for(p = str; *p != '\0'; p++)
1863 if(!isalnum((unsigned char)*p))
1868 make_name(struct assignment *as)
1870 struct assignment *lopt;
1871 struct assignment *type;
1874 lopt = find(as, "long");
1876 lopt = find(as, "name");
1880 type = find(as, "type");
1881 if(strcmp(type->u.value, "-flag") == 0)
1882 asprintf(&s, "%s_flag", lopt->u.value);
1884 asprintf(&s, "%s_%s", lopt->u.value, type->u.value);
1890 static void defval_int(const char *name, struct assignment *defval)
1893 cprint(1, "opt.%s = %s;\n", name, defval->u.value);
1895 cprint(1, "opt.%s = 0;\n", name);
1897 static void defval_neg_flag(const char *name, struct assignment *defval)
1900 cprint(1, "opt.%s = %s;\n", name, defval->u.value);
1902 cprint(1, "opt.%s = 1;\n", name);
1904 static void defval_string(const char *name, struct assignment *defval)
1907 cprint(1, "opt.%s = (char *)(unsigned long)\"%s\";\n", name, defval->u.value);
1909 cprint(1, "opt.%s = NULL;\n", name);
1911 static void defval_strings(const char *name, struct assignment *defval)
1913 cprint(1, "opt.%s.num_strings = 0;\n", name);
1914 cprint(1, "opt.%s.strings = NULL;\n", name);
1917 static void free_strings(const char *name)
1919 cprint(1, "free_getarg_strings (&opt.%s);\n", name);
1922 struct type_handler {
1923 const char *typename;
1925 const char *getarg_type;
1926 void (*defval)(const char*, struct assignment*);
1927 void (*free)(const char*);
1928 } type_handlers[] = {
1942 "struct getarg_strings",
1955 "arg_negative_flag",
1962 static struct type_handler *find_handler(struct assignment *type)
1964 struct type_handler *th;
1965 for(th = type_handlers; th->typename != NULL; th++)
1966 if(strcmp(type->u.value, th->typename) == 0)
1968 ex(type, "unknown type \"%s\"", type->u.value);
1973 gen_options(struct assignment *opt1, const char *name)
1975 struct assignment *tmp;
1977 hprint(0, "struct %s_options {\n", name);
1981 tmp = find_next(tmp, "option")) {
1982 struct assignment *type;
1983 struct type_handler *th;
1986 s = make_name(tmp->u.assignment);
1987 type = find(tmp->u.assignment, "type");
1988 th = find_handler(type);
1989 hprint(1, "%s %s;\n", th->c_type, s);
1996 gen_wrapper(struct assignment *as)
1998 struct assignment *name;
1999 struct assignment *arg;
2000 struct assignment *opt1;
2001 struct assignment *function;
2002 struct assignment *tmp;
2007 name = find(as, "name");
2008 n = strdup(name->u.value);
2010 arg = find(as, "argument");
2013 opt1 = find(as, "option");
2014 function = find(as, "function");
2016 f = function->u.value;
2022 gen_options(opt1, n);
2023 hprint(0, "int %s(struct %s_options*, int, char **);\n", f, n);
2025 hprint(0, "int %s(void*, int, char **);\n", f);
2028 fprintf(cfile, "static int\n");
2029 fprintf(cfile, "%s_wrap(int argc, char **argv)\n", n);
2030 fprintf(cfile, "{\n");
2032 cprint(1, "struct %s_options opt;\n", n);
2033 cprint(1, "int ret;\n");
2034 cprint(1, "int optidx = 0;\n");
2035 cprint(1, "struct getargs args[] = {\n");
2036 for(tmp = find(as, "option");
2038 tmp = find_next(tmp, "option")) {
2039 struct assignment *type = find(tmp->u.assignment, "type");
2040 struct assignment *lopt = find(tmp->u.assignment, "long");
2041 struct assignment *sopt = find(tmp->u.assignment, "short");
2042 struct assignment *aarg = find(tmp->u.assignment, "argument");
2043 struct assignment *help = find(tmp->u.assignment, "help");
2045 struct type_handler *th;
2049 fprintf(cfile, "\"%s\", ", lopt->u.value);
2051 fprintf(cfile, "NULL, ");
2053 fprintf(cfile, "'%c', ", *sopt->u.value);
2055 fprintf(cfile, "0, ");
2056 th = find_handler(type);
2057 fprintf(cfile, "%s, ", th->getarg_type);
2058 fprintf(cfile, "NULL, ");
2060 fprintf(cfile, "\"%s\", ", help->u.value);
2062 fprintf(cfile, "NULL, ");
2064 fprintf(cfile, "\"%s\"", aarg->u.value);
2067 fprintf(cfile, "NULL");
2068 fprintf(cfile, " },\n");
2070 cprint(2, "{ \"help\", 'h', arg_flag, NULL, NULL, NULL }\n");
2072 cprint(1, "int help_flag = 0;\n");
2074 for(tmp = find(as, "option");
2076 tmp = find_next(tmp, "option")) {
2078 struct assignment *type = find(tmp->u.assignment, "type");
2080 struct assignment *defval = find(tmp->u.assignment, "default");
2082 struct type_handler *th;
2084 s = make_name(tmp->u.assignment);
2085 th = find_handler(type);
2086 (*th->defval)(s, defval);
2090 for(tmp = find(as, "option");
2092 tmp = find_next(tmp, "option")) {
2094 s = make_name(tmp->u.assignment);
2095 cprint(1, "args[%d].value = &opt.%s;\n", nargs++, s);
2098 cprint(1, "args[%d].value = &help_flag;\n", nargs++);
2099 cprint(1, "if(getarg(args, %d, argc, argv, &optidx))\n", nargs);
2100 cprint(2, "goto usage;\n");
2106 if(narguments == 0) {
2109 if((tmp = find(as, "min_args")) != NULL) {
2110 min_args = strtol(tmp->u.value, &end, 0);
2112 ex(tmp, "min_args is not numeric");
2116 ex(tmp, "min_args must be non-negative");
2120 if((tmp = find(as, "max_args")) != NULL) {
2121 max_args = strtol(tmp->u.value, &end, 0);
2123 ex(tmp, "max_args is not numeric");
2127 ex(tmp, "max_args must be non-negative");
2132 if(min_args != -1 || max_args != -1) {
2133 if(min_args == max_args) {
2134 cprint(1, "if(argc - optidx != %d) {\n",
2136 cprint(2, "fprintf(stderr, \"Need exactly %u parameters (%%u given).\\n\\n\", argc - optidx);\n", min_args);
2137 cprint(2, "goto usage;\n");
2140 if(max_args != -1) {
2141 cprint(1, "if(argc - optidx > %d) {\n", max_args);
2142 cprint(2, "fprintf(stderr, \"Arguments given (%%u) are more than expected (%u).\\n\\n\", argc - optidx);\n", max_args);
2143 cprint(2, "goto usage;\n");
2146 if(min_args != -1) {
2147 cprint(1, "if(argc - optidx < %d) {\n", min_args);
2148 cprint(2, "fprintf(stderr, \"Arguments given (%%u) are less than expected (%u).\\n\\n\", argc - optidx);\n", min_args);
2149 cprint(2, "goto usage;\n");
2156 cprint(1, "if(help_flag)\n");
2157 cprint(2, "goto usage;\n");
2159 cprint(1, "ret = %s(%s, argc - optidx, argv + optidx);\n",
2160 f, opt1 ? "&opt": "NULL");
2162 /* free allocated data */
2163 for(tmp = find(as, "option");
2165 tmp = find_next(tmp, "option")) {
2167 struct assignment *type = find(tmp->u.assignment, "type");
2168 struct type_handler *th;
2169 th = find_handler(type);
2170 if(th->free == NULL)
2172 s = make_name(tmp->u.assignment);
2176 cprint(1, "return ret;\n");
2178 cprint(0, "usage:\n");
2179 cprint(1, "arg_printusage (args, %d, \"%s\", \"%s\");\n", nargs,
2180 name->u.value, arg ? arg->u.value : "");
2181 /* free allocated data */
2182 for(tmp = find(as, "option");
2184 tmp = find_next(tmp, "option")) {
2186 struct assignment *type = find(tmp->u.assignment, "type");
2187 struct type_handler *th;
2188 th = find_handler(type);
2189 if(th->free == NULL)
2191 s = make_name(tmp->u.assignment);
2195 cprint(1, "return 0;\n");
2200 char cname[PATH_MAX];
2201 char hname[PATH_MAX];
2204 gen(struct assignment *as)
2206 struct assignment *a;
2207 cprint(0, "#include <stdio.h>\n");
2208 cprint(0, "#include <getarg.h>\n");
2209 cprint(0, "#include <sl.h>\n");
2210 cprint(0, "#include \"%s\"\n\n", hname);
2212 hprint(0, "#include <stdio.h>\n");
2213 hprint(0, "#include <sl.h>\n");
2217 for(a = as; a != NULL; a = a->next)
2218 gen_wrapper(a->u.assignment);
2220 cprint(0, "SL_cmd commands[] = {\n");
2221 for(a = as; a != NULL; a = a->next)
2222 gen_command(a->u.assignment);
2223 cprint(1, "{ NULL }\n");
2226 hprint(0, "extern SL_cmd commands[];\n");
2231 struct getargs args[] = {
2232 { "version", 0, arg_flag, &version_flag },
2233 { "help", 0, arg_flag, &help_flag }
2235 int num_args = sizeof(args) / sizeof(args[0]);
2240 arg_printusage(args, num_args, NULL, "command-table");
2245 main(int argc, char **argv)
2251 setprogname(argv[0]);
2252 if(getarg(args, num_args, argc, argv, &optidx))
2257 print_version(NULL);
2264 filename = argv[optidx];
2265 yyin = fopen(filename, "r");
2267 err(1, "%s", filename);
2268 p = strrchr(filename, '/');
2270 strlcpy(cname, p + 1, sizeof(cname));
2272 strlcpy(cname, filename, sizeof(cname));
2273 p = strrchr(cname, '.');
2276 strlcpy(hname, cname, sizeof(hname));
2277 strlcat(cname, ".c", sizeof(cname));
2278 strlcat(hname, ".h", sizeof(hname));
2282 if(check(assignment) == 0) {
2283 cfile = fopen(cname, "w");
2285 err(1, "%s", cname);
2286 hfile = fopen(hname, "w");
2288 err(1, "%s", hname);