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
118 RCSID("$Id: slc-gram.y 20767 2007-06-01 11:24:52Z lha $");
132 extern struct assignment *assignment;
135 /* Enabling traces. */
140 /* Enabling verbose error messages. */
141 #ifdef YYERROR_VERBOSE
142 # undef YYERROR_VERBOSE
143 # define YYERROR_VERBOSE 1
145 # define YYERROR_VERBOSE 0
148 /* Enabling the token table. */
149 #ifndef YYTOKEN_TABLE
150 # define YYTOKEN_TABLE 0
153 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
154 typedef union YYSTYPE
155 #line 54 "slc-gram.y"
158 struct assignment *assignment;
160 /* Line 193 of yacc.c. */
161 #line 162 "slc-gram.c"
163 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
164 # define YYSTYPE_IS_DECLARED 1
165 # define YYSTYPE_IS_TRIVIAL 1
170 /* Copy the second part of user declarations. */
173 /* Line 216 of yacc.c. */
174 #line 175 "slc-gram.c"
181 typedef YYTYPE_UINT8 yytype_uint8;
183 typedef unsigned char yytype_uint8;
187 typedef YYTYPE_INT8 yytype_int8;
188 #elif (defined __STDC__ || defined __C99__FUNC__ \
189 || defined __cplusplus || defined _MSC_VER)
190 typedef signed char yytype_int8;
192 typedef short int yytype_int8;
196 typedef YYTYPE_UINT16 yytype_uint16;
198 typedef unsigned short int yytype_uint16;
202 typedef YYTYPE_INT16 yytype_int16;
204 typedef short int yytype_int16;
208 # ifdef __SIZE_TYPE__
209 # define YYSIZE_T __SIZE_TYPE__
210 # elif defined size_t
211 # define YYSIZE_T size_t
212 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
213 || defined __cplusplus || defined _MSC_VER)
214 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
215 # define YYSIZE_T size_t
217 # define YYSIZE_T unsigned int
221 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
224 # if defined YYENABLE_NLS && YYENABLE_NLS
226 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
227 # define YY_(msgid) dgettext ("bison-runtime", msgid)
231 # define YY_(msgid) msgid
235 /* Suppress unused-variable warnings by "using" E. */
236 #if ! defined lint || defined __GNUC__
237 # define YYUSE(e) ((void) (e))
239 # define YYUSE(e) /* empty */
242 /* Identity function, used to suppress warnings about constant conditions. */
246 #if (defined __STDC__ || defined __C99__FUNC__ \
247 || defined __cplusplus || defined _MSC_VER)
260 #if ! defined yyoverflow || YYERROR_VERBOSE
262 /* The parser invokes alloca or malloc; define the necessary symbols. */
264 # ifdef YYSTACK_USE_ALLOCA
265 # if YYSTACK_USE_ALLOCA
267 # define YYSTACK_ALLOC __builtin_alloca
268 # elif defined __BUILTIN_VA_ARG_INCR
269 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
271 # define YYSTACK_ALLOC __alloca
272 # elif defined _MSC_VER
273 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
274 # define alloca _alloca
276 # define YYSTACK_ALLOC alloca
277 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
278 || defined __cplusplus || defined _MSC_VER)
279 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
288 # ifdef YYSTACK_ALLOC
289 /* Pacify GCC's `empty if-body' warning. */
290 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
291 # ifndef YYSTACK_ALLOC_MAXIMUM
292 /* The OS might guarantee only one guard page at the bottom of the stack,
293 and a page size can be as small as 4096 bytes. So we cannot safely
294 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
295 to allow for a few compiler-allocated temporary stack slots. */
296 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
299 # define YYSTACK_ALLOC YYMALLOC
300 # define YYSTACK_FREE YYFREE
301 # ifndef YYSTACK_ALLOC_MAXIMUM
302 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
304 # if (defined __cplusplus && ! defined _STDLIB_H \
305 && ! ((defined YYMALLOC || defined malloc) \
306 && (defined YYFREE || defined free)))
307 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
313 # define YYMALLOC malloc
314 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
315 || defined __cplusplus || defined _MSC_VER)
316 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
321 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
322 || defined __cplusplus || defined _MSC_VER)
323 void free (void *); /* INFRINGES ON USER NAME SPACE */
327 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
330 #if (! defined yyoverflow \
331 && (! defined __cplusplus \
332 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
334 /* A type that is properly aligned for any stack member. */
341 /* The size of the maximum gap between one aligned stack and the next. */
342 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
344 /* The size of an array large to enough to hold all stacks, each with
346 # define YYSTACK_BYTES(N) \
347 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
348 + YYSTACK_GAP_MAXIMUM)
350 /* Copy COUNT objects from FROM to TO. The source and destination do
353 # if defined __GNUC__ && 1 < __GNUC__
354 # define YYCOPY(To, From, Count) \
355 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
357 # define YYCOPY(To, From, Count) \
361 for (yyi = 0; yyi < (Count); yyi++) \
362 (To)[yyi] = (From)[yyi]; \
368 /* Relocate STACK from its old location to the new one. The
369 local variables YYSIZE and YYSTACKSIZE give the old and new number of
370 elements in the stack, and YYPTR gives the new location of the
371 stack. Advance YYPTR to a properly aligned location for the next
373 # define YYSTACK_RELOCATE(Stack) \
376 YYSIZE_T yynewbytes; \
377 YYCOPY (&yyptr->Stack, Stack, yysize); \
378 Stack = &yyptr->Stack; \
379 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
380 yyptr += yynewbytes / sizeof (*yyptr); \
386 /* YYFINAL -- State number of the termination state. */
388 /* YYLAST -- Last index in YYTABLE. */
391 /* YYNTOKENS -- Number of terminals. */
393 /* YYNNTS -- Number of nonterminals. */
395 /* YYNRULES -- Number of rules. */
397 /* YYNRULES -- Number of states. */
400 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
402 #define YYMAXUTOK 259
404 #define YYTRANSLATE(YYX) \
405 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
407 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
408 static const yytype_uint8 yytranslate[] =
410 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
411 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
412 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
413 2, 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, 5, 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, 2, 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, 6, 2, 7, 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, 2, 2, 2, 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, 1, 2, 3, 4
439 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
441 static const yytype_uint8 yyprhs[] =
443 0, 0, 3, 5, 8, 10, 14
446 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
447 static const yytype_int8 yyrhs[] =
449 9, 0, -1, 10, -1, 11, 10, -1, 11, -1,
450 3, 5, 4, -1, 3, 5, 6, 10, 7, -1
453 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
454 static const yytype_uint8 yyrline[] =
456 0, 67, 67, 73, 78, 81, 90
460 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
461 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
462 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
463 static const char *const yytname[] =
465 "$end", "error", "$undefined", "LITERAL", "STRING", "'='", "'{'", "'}'",
466 "$accept", "start", "assignments", "assignment", 0
471 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
473 static const yytype_uint16 yytoknum[] =
475 0, 256, 257, 258, 259, 61, 123, 125
479 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
480 static const yytype_uint8 yyr1[] =
482 0, 8, 9, 10, 10, 11, 11
485 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
486 static const yytype_uint8 yyr2[] =
491 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
492 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
493 means the default is an error. */
494 static const yytype_uint8 yydefact[] =
496 0, 0, 0, 2, 4, 0, 1, 3, 5, 0,
500 /* YYDEFGOTO[NTERM-NUM]. */
501 static const yytype_int8 yydefgoto[] =
506 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
508 #define YYPACT_NINF -5
509 static const yytype_int8 yypact[] =
511 -1, 1, 4, -5, -1, -3, -5, -5, -5, -1,
515 /* YYPGOTO[NTERM-NUM]. */
516 static const yytype_int8 yypgoto[] =
521 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
522 positive, shift that token. If negative, reduce the rule which
523 number is the opposite. If zero, do what YYDEFACT says.
524 If YYTABLE_NINF, syntax error. */
525 #define YYTABLE_NINF -1
526 static const yytype_uint8 yytable[] =
528 7, 8, 1, 9, 6, 10, 5, 11
531 static const yytype_uint8 yycheck[] =
533 4, 4, 3, 6, 0, 9, 5, 7
536 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
537 symbol of state STATE-NUM. */
538 static const yytype_uint8 yystos[] =
540 0, 3, 9, 10, 11, 5, 0, 10, 4, 6,
544 #define yyerrok (yyerrstatus = 0)
545 #define yyclearin (yychar = YYEMPTY)
549 #define YYACCEPT goto yyacceptlab
550 #define YYABORT goto yyabortlab
551 #define YYERROR goto yyerrorlab
554 /* Like YYERROR except do call yyerror. This remains here temporarily
555 to ease the transition to the new meaning of YYERROR, for GCC.
556 Once GCC version 2 has supplanted version 1, this can go. */
558 #define YYFAIL goto yyerrlab
560 #define YYRECOVERING() (!!yyerrstatus)
562 #define YYBACKUP(Token, Value) \
564 if (yychar == YYEMPTY && yylen == 1) \
568 yytoken = YYTRANSLATE (yychar); \
574 yyerror (YY_("syntax error: cannot back up")); \
581 #define YYERRCODE 256
584 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
585 If N is 0, then set CURRENT to the empty location which ends
586 the previous symbol: RHS[0] (always defined). */
588 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
589 #ifndef YYLLOC_DEFAULT
590 # define YYLLOC_DEFAULT(Current, Rhs, N) \
594 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
595 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
596 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
597 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
601 (Current).first_line = (Current).last_line = \
602 YYRHSLOC (Rhs, 0).last_line; \
603 (Current).first_column = (Current).last_column = \
604 YYRHSLOC (Rhs, 0).last_column; \
610 /* YY_LOCATION_PRINT -- Print the location on the stream.
611 This macro was not mandated originally: define only if we know
612 we won't break user code: when these are the locations we know. */
614 #ifndef YY_LOCATION_PRINT
615 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
616 # define YY_LOCATION_PRINT(File, Loc) \
617 fprintf (File, "%d.%d-%d.%d", \
618 (Loc).first_line, (Loc).first_column, \
619 (Loc).last_line, (Loc).last_column)
621 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
626 /* YYLEX -- calling `yylex' with the right arguments. */
629 # define YYLEX yylex (YYLEX_PARAM)
631 # define YYLEX yylex ()
634 /* Enable debugging if requested. */
638 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
639 # define YYFPRINTF fprintf
642 # define YYDPRINTF(Args) \
648 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
652 YYFPRINTF (stderr, "%s ", Title); \
653 yy_symbol_print (stderr, \
655 YYFPRINTF (stderr, "\n"); \
660 /*--------------------------------.
661 | Print this symbol on YYOUTPUT. |
662 `--------------------------------*/
665 #if (defined __STDC__ || defined __C99__FUNC__ \
666 || defined __cplusplus || defined _MSC_VER)
668 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
671 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
674 YYSTYPE const * const yyvaluep;
680 if (yytype < YYNTOKENS)
681 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
693 /*--------------------------------.
694 | Print this symbol on YYOUTPUT. |
695 `--------------------------------*/
697 #if (defined __STDC__ || defined __C99__FUNC__ \
698 || defined __cplusplus || defined _MSC_VER)
700 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
703 yy_symbol_print (yyoutput, yytype, yyvaluep)
706 YYSTYPE const * const yyvaluep;
709 if (yytype < YYNTOKENS)
710 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
712 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
714 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
715 YYFPRINTF (yyoutput, ")");
718 /*------------------------------------------------------------------.
719 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
721 `------------------------------------------------------------------*/
723 #if (defined __STDC__ || defined __C99__FUNC__ \
724 || defined __cplusplus || defined _MSC_VER)
726 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
729 yy_stack_print (bottom, top)
730 yytype_int16 *bottom;
734 YYFPRINTF (stderr, "Stack now");
735 for (; bottom <= top; ++bottom)
736 YYFPRINTF (stderr, " %d", *bottom);
737 YYFPRINTF (stderr, "\n");
740 # define YY_STACK_PRINT(Bottom, Top) \
743 yy_stack_print ((Bottom), (Top)); \
747 /*------------------------------------------------.
748 | Report that the YYRULE is going to be reduced. |
749 `------------------------------------------------*/
751 #if (defined __STDC__ || defined __C99__FUNC__ \
752 || defined __cplusplus || defined _MSC_VER)
754 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
757 yy_reduce_print (yyvsp, yyrule)
762 int yynrhs = yyr2[yyrule];
764 unsigned long int yylno = yyrline[yyrule];
765 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
767 /* The symbols being reduced. */
768 for (yyi = 0; yyi < yynrhs; yyi++)
770 fprintf (stderr, " $%d = ", yyi + 1);
771 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
772 &(yyvsp[(yyi + 1) - (yynrhs)])
774 fprintf (stderr, "\n");
778 # define YY_REDUCE_PRINT(Rule) \
781 yy_reduce_print (yyvsp, Rule); \
784 /* Nonzero means print parse trace. It is left uninitialized so that
785 multiple parsers can coexist. */
788 # define YYDPRINTF(Args)
789 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
790 # define YY_STACK_PRINT(Bottom, Top)
791 # define YY_REDUCE_PRINT(Rule)
792 #endif /* !YYDEBUG */
795 /* YYINITDEPTH -- initial size of the parser's stacks. */
797 # define YYINITDEPTH 200
800 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
801 if the built-in stack extension method is used).
803 Do not make this value too large; the results are undefined if
804 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
805 evaluated with infinite-precision integer arithmetic. */
808 # define YYMAXDEPTH 10000
816 # if defined __GLIBC__ && defined _STRING_H
817 # define yystrlen strlen
819 /* Return the length of YYSTR. */
820 #if (defined __STDC__ || defined __C99__FUNC__ \
821 || defined __cplusplus || defined _MSC_VER)
823 yystrlen (const char *yystr)
831 for (yylen = 0; yystr[yylen]; yylen++)
839 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
840 # define yystpcpy stpcpy
842 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
844 #if (defined __STDC__ || defined __C99__FUNC__ \
845 || defined __cplusplus || defined _MSC_VER)
847 yystpcpy (char *yydest, const char *yysrc)
850 yystpcpy (yydest, yysrc)
856 const char *yys = yysrc;
858 while ((*yyd++ = *yys++) != '\0')
867 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
868 quotes and backslashes, so that it's suitable for yyerror. The
869 heuristic is that double-quoting is unnecessary unless the string
870 contains an apostrophe, a comma, or backslash (other than
871 backslash-backslash). YYSTR is taken from yytname. If YYRES is
872 null, do not copy; instead, return the length of what the result
875 yytnamerr (char *yyres, const char *yystr)
880 char const *yyp = yystr;
887 goto do_not_strip_quotes;
891 goto do_not_strip_quotes;
904 do_not_strip_quotes: ;
908 return yystrlen (yystr);
910 return yystpcpy (yyres, yystr) - yyres;
914 /* Copy into YYRESULT an error message about the unexpected token
915 YYCHAR while in state YYSTATE. Return the number of bytes copied,
916 including the terminating null byte. If YYRESULT is null, do not
917 copy anything; just return the number of bytes that would be
918 copied. As a special case, return 0 if an ordinary "syntax error"
919 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
922 yysyntax_error (char *yyresult, int yystate, int yychar)
924 int yyn = yypact[yystate];
926 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
930 int yytype = YYTRANSLATE (yychar);
931 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
932 YYSIZE_T yysize = yysize0;
934 int yysize_overflow = 0;
935 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
936 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
940 /* This is so xgettext sees the translatable formats that are
941 constructed on the fly. */
942 YY_("syntax error, unexpected %s");
943 YY_("syntax error, unexpected %s, expecting %s");
944 YY_("syntax error, unexpected %s, expecting %s or %s");
945 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
946 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
950 static char const yyunexpected[] = "syntax error, unexpected %s";
951 static char const yyexpecting[] = ", expecting %s";
952 static char const yyor[] = " or %s";
953 char yyformat[sizeof yyunexpected
954 + sizeof yyexpecting - 1
955 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
956 * (sizeof yyor - 1))];
957 char const *yyprefix = yyexpecting;
959 /* Start YYX at -YYN if negative to avoid negative indexes in
961 int yyxbegin = yyn < 0 ? -yyn : 0;
963 /* Stay within bounds of both yycheck and yytname. */
964 int yychecklim = YYLAST - yyn + 1;
965 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
968 yyarg[0] = yytname[yytype];
969 yyfmt = yystpcpy (yyformat, yyunexpected);
971 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
972 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
974 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
978 yyformat[sizeof yyunexpected - 1] = '\0';
981 yyarg[yycount++] = yytname[yyx];
982 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
983 yysize_overflow |= (yysize1 < yysize);
985 yyfmt = yystpcpy (yyfmt, yyprefix);
990 yysize1 = yysize + yystrlen (yyf);
991 yysize_overflow |= (yysize1 < yysize);
995 return YYSIZE_MAXIMUM;
999 /* Avoid sprintf, as that infringes on the user's name space.
1000 Don't have undefined behavior even if the translation
1001 produced a string with the wrong number of "%s"s. */
1002 char *yyp = yyresult;
1004 while ((*yyp = *yyf) != '\0')
1006 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1008 yyp += yytnamerr (yyp, yyarg[yyi++]);
1021 #endif /* YYERROR_VERBOSE */
1024 /*-----------------------------------------------.
1025 | Release the memory associated to this symbol. |
1026 `-----------------------------------------------*/
1029 #if (defined __STDC__ || defined __C99__FUNC__ \
1030 || defined __cplusplus || defined _MSC_VER)
1032 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1035 yydestruct (yymsg, yytype, yyvaluep)
1045 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1056 /* Prevent warnings from -Wmissing-prototypes. */
1058 #ifdef YYPARSE_PARAM
1059 #if defined __STDC__ || defined __cplusplus
1060 int yyparse (void *YYPARSE_PARAM);
1064 #else /* ! YYPARSE_PARAM */
1065 #if defined __STDC__ || defined __cplusplus
1070 #endif /* ! YYPARSE_PARAM */
1074 /* The look-ahead symbol. */
1077 /* The semantic value of the look-ahead symbol. */
1080 /* Number of syntax errors so far. */
1089 #ifdef YYPARSE_PARAM
1090 #if (defined __STDC__ || defined __C99__FUNC__ \
1091 || defined __cplusplus || defined _MSC_VER)
1093 yyparse (void *YYPARSE_PARAM)
1096 yyparse (YYPARSE_PARAM)
1097 void *YYPARSE_PARAM;
1099 #else /* ! YYPARSE_PARAM */
1100 #if (defined __STDC__ || defined __C99__FUNC__ \
1101 || defined __cplusplus || defined _MSC_VER)
1115 /* Number of tokens to shift before error messages enabled. */
1117 /* Look-ahead token as an internal (translated) token number. */
1120 /* Buffer for error messages, and its allocated size. */
1122 char *yymsg = yymsgbuf;
1123 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1126 /* Three stacks and their tools:
1127 `yyss': related to states,
1128 `yyvs': related to semantic values,
1129 `yyls': related to locations.
1131 Refer to the stacks thru separate pointers, to allow yyoverflow
1132 to reallocate them elsewhere. */
1134 /* The state stack. */
1135 yytype_int16 yyssa[YYINITDEPTH];
1136 yytype_int16 *yyss = yyssa;
1137 yytype_int16 *yyssp;
1139 /* The semantic value stack. */
1140 YYSTYPE yyvsa[YYINITDEPTH];
1141 YYSTYPE *yyvs = yyvsa;
1146 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1148 YYSIZE_T yystacksize = YYINITDEPTH;
1150 /* The variables used to return semantic value and location from the
1155 /* The number of symbols on the RHS of the reduced rule.
1156 Keep to zero when no symbol should be popped. */
1159 YYDPRINTF ((stderr, "Starting parse\n"));
1164 yychar = YYEMPTY; /* Cause a token to be read. */
1166 /* Initialize stack pointers.
1167 Waste one element of value and location stack
1168 so that they stay on the same level as the state stack.
1169 The wasted elements are never initialized. */
1176 /*------------------------------------------------------------.
1177 | yynewstate -- Push a new state, which is found in yystate. |
1178 `------------------------------------------------------------*/
1180 /* In all cases, when you get here, the value and location stacks
1181 have just been pushed. So pushing a state here evens the stacks. */
1187 if (yyss + yystacksize - 1 <= yyssp)
1189 /* Get the current used size of the three stacks, in elements. */
1190 YYSIZE_T yysize = yyssp - yyss + 1;
1194 /* Give user a chance to reallocate the stack. Use copies of
1195 these so that the &'s don't force the real ones into
1197 YYSTYPE *yyvs1 = yyvs;
1198 yytype_int16 *yyss1 = yyss;
1201 /* Each stack pointer address is followed by the size of the
1202 data in use in that stack, in bytes. This used to be a
1203 conditional around just the two extra args, but that might
1204 be undefined if yyoverflow is a macro. */
1205 yyoverflow (YY_("memory exhausted"),
1206 &yyss1, yysize * sizeof (*yyssp),
1207 &yyvs1, yysize * sizeof (*yyvsp),
1214 #else /* no yyoverflow */
1215 # ifndef YYSTACK_RELOCATE
1216 goto yyexhaustedlab;
1218 /* Extend the stack our own way. */
1219 if (YYMAXDEPTH <= yystacksize)
1220 goto yyexhaustedlab;
1222 if (YYMAXDEPTH < yystacksize)
1223 yystacksize = YYMAXDEPTH;
1226 yytype_int16 *yyss1 = yyss;
1227 union yyalloc *yyptr =
1228 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1230 goto yyexhaustedlab;
1231 YYSTACK_RELOCATE (yyss);
1232 YYSTACK_RELOCATE (yyvs);
1234 # undef YYSTACK_RELOCATE
1236 YYSTACK_FREE (yyss1);
1239 #endif /* no yyoverflow */
1241 yyssp = yyss + yysize - 1;
1242 yyvsp = yyvs + yysize - 1;
1245 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1246 (unsigned long int) yystacksize));
1248 if (yyss + yystacksize - 1 <= yyssp)
1252 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1261 /* Do appropriate processing given the current state. Read a
1262 look-ahead token if we need one and don't already have one. */
1264 /* First try to decide what to do without reference to look-ahead token. */
1265 yyn = yypact[yystate];
1266 if (yyn == YYPACT_NINF)
1269 /* Not known => get a look-ahead token if don't already have one. */
1271 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1272 if (yychar == YYEMPTY)
1274 YYDPRINTF ((stderr, "Reading a token: "));
1278 if (yychar <= YYEOF)
1280 yychar = yytoken = YYEOF;
1281 YYDPRINTF ((stderr, "Now at end of input.\n"));
1285 yytoken = YYTRANSLATE (yychar);
1286 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1289 /* If the proper action on seeing token YYTOKEN is to reduce or to
1290 detect an error, take that action. */
1292 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1297 if (yyn == 0 || yyn == YYTABLE_NINF)
1306 /* Count tokens shifted since error; after three, turn off error
1311 /* Shift the look-ahead token. */
1312 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1314 /* Discard the shifted token unless it is eof. */
1315 if (yychar != YYEOF)
1324 /*-----------------------------------------------------------.
1325 | yydefault -- do the default action for the current state. |
1326 `-----------------------------------------------------------*/
1328 yyn = yydefact[yystate];
1334 /*-----------------------------.
1335 | yyreduce -- Do a reduction. |
1336 `-----------------------------*/
1338 /* yyn is the number of a rule to reduce with. */
1341 /* If YYLEN is nonzero, implement the default value of the action:
1344 Otherwise, the following line sets YYVAL to garbage.
1345 This behavior is undocumented and Bison
1346 users should not rely upon it. Assigning to YYVAL
1347 unconditionally makes the parser a bit smaller, and it avoids a
1348 GCC warning that YYVAL may be used uninitialized. */
1349 yyval = yyvsp[1-yylen];
1352 YY_REDUCE_PRINT (yyn);
1356 #line 68 "slc-gram.y"
1358 assignment = (yyvsp[(1) - (1)].assignment);
1363 #line 74 "slc-gram.y"
1365 (yyvsp[(1) - (2)].assignment)->next = (yyvsp[(2) - (2)].assignment);
1366 (yyval.assignment) = (yyvsp[(1) - (2)].assignment);
1371 #line 82 "slc-gram.y"
1373 (yyval.assignment) = malloc(sizeof(*(yyval.assignment)));
1374 (yyval.assignment)->name = (yyvsp[(1) - (3)].string);
1375 (yyval.assignment)->type = a_value;
1376 (yyval.assignment)->lineno = lineno;
1377 (yyval.assignment)->u.value = (yyvsp[(3) - (3)].string);
1378 (yyval.assignment)->next = NULL;
1383 #line 91 "slc-gram.y"
1385 (yyval.assignment) = malloc(sizeof(*(yyval.assignment)));
1386 (yyval.assignment)->name = (yyvsp[(1) - (5)].string);
1387 (yyval.assignment)->type = a_assignment;
1388 (yyval.assignment)->lineno = lineno;
1389 (yyval.assignment)->u.assignment = (yyvsp[(4) - (5)].assignment);
1390 (yyval.assignment)->next = NULL;
1395 /* Line 1267 of yacc.c. */
1396 #line 1397 "slc-gram.c"
1399 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1403 YY_STACK_PRINT (yyss, yyssp);
1408 /* Now `shift' the result of the reduction. Determine what state
1409 that goes to, based on the state we popped back to and the rule
1410 number reduced by. */
1414 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1415 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1416 yystate = yytable[yystate];
1418 yystate = yydefgoto[yyn - YYNTOKENS];
1423 /*------------------------------------.
1424 | yyerrlab -- here on detecting error |
1425 `------------------------------------*/
1427 /* If not already recovering from an error, report this error. */
1431 #if ! YYERROR_VERBOSE
1432 yyerror (YY_("syntax error"));
1435 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1436 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1438 YYSIZE_T yyalloc = 2 * yysize;
1439 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1440 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1441 if (yymsg != yymsgbuf)
1442 YYSTACK_FREE (yymsg);
1443 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1445 yymsg_alloc = yyalloc;
1449 yymsg_alloc = sizeof yymsgbuf;
1453 if (0 < yysize && yysize <= yymsg_alloc)
1455 (void) yysyntax_error (yymsg, yystate, yychar);
1460 yyerror (YY_("syntax error"));
1462 goto yyexhaustedlab;
1470 if (yyerrstatus == 3)
1472 /* If just tried and failed to reuse look-ahead token after an
1473 error, discard it. */
1475 if (yychar <= YYEOF)
1477 /* Return failure if at end of input. */
1478 if (yychar == YYEOF)
1483 yydestruct ("Error: discarding",
1489 /* Else will try to reuse look-ahead token after shifting the error
1494 /*---------------------------------------------------.
1495 | yyerrorlab -- error raised explicitly by YYERROR. |
1496 `---------------------------------------------------*/
1499 /* Pacify compilers like GCC when the user code never invokes
1500 YYERROR and the label yyerrorlab therefore never appears in user
1502 if (/*CONSTCOND*/ 0)
1505 /* Do not reclaim the symbols of the rule which action triggered
1509 YY_STACK_PRINT (yyss, yyssp);
1514 /*-------------------------------------------------------------.
1515 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1516 `-------------------------------------------------------------*/
1518 yyerrstatus = 3; /* Each real token shifted decrements this. */
1522 yyn = yypact[yystate];
1523 if (yyn != YYPACT_NINF)
1526 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1534 /* Pop the current state because it cannot handle the error token. */
1539 yydestruct ("Error: popping",
1540 yystos[yystate], yyvsp);
1543 YY_STACK_PRINT (yyss, yyssp);
1552 /* Shift the error token. */
1553 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1559 /*-------------------------------------.
1560 | yyacceptlab -- YYACCEPT comes here. |
1561 `-------------------------------------*/
1566 /*-----------------------------------.
1567 | yyabortlab -- YYABORT comes here. |
1568 `-----------------------------------*/
1574 /*-------------------------------------------------.
1575 | yyexhaustedlab -- memory exhaustion comes here. |
1576 `-------------------------------------------------*/
1578 yyerror (YY_("memory exhausted"));
1584 if (yychar != YYEOF && yychar != YYEMPTY)
1585 yydestruct ("Cleanup: discarding lookahead",
1587 /* Do not reclaim the symbols of the rule which action triggered
1588 this YYABORT or YYACCEPT. */
1590 YY_STACK_PRINT (yyss, yyssp);
1591 while (yyssp != yyss)
1593 yydestruct ("Cleanup: popping",
1594 yystos[*yyssp], yyvsp);
1599 YYSTACK_FREE (yyss);
1602 if (yymsg != yymsgbuf)
1603 YYSTACK_FREE (yymsg);
1605 /* Make sure YYID is used. */
1606 return YYID (yyresult);
1610 #line 101 "slc-gram.y"
1613 FILE *cfile, *hfile;
1615 struct assignment *assignment;
1619 ex(struct assignment *a, const char *fmt, ...)
1622 fprintf(stderr, "%s:%d: ", a->name, a->lineno);
1624 vfprintf(stderr, fmt, ap);
1626 fprintf(stderr, "\n");
1632 check_option(struct assignment *as)
1634 struct assignment *a;
1638 int seen_argument = 0;
1640 int seen_default = 0;
1643 for(a = as; a != NULL; a = a->next) {
1644 if(strcmp(a->name, "long") == 0)
1646 else if(strcmp(a->name, "short") == 0)
1648 else if(strcmp(a->name, "type") == 0)
1650 else if(strcmp(a->name, "argument") == 0)
1652 else if(strcmp(a->name, "help") == 0)
1654 else if(strcmp(a->name, "default") == 0)
1657 ex(a, "unknown name");
1661 if(seen_long == 0 && seen_short == 0) {
1662 ex(as, "neither long nor short option");
1666 ex(as, "multiple long options");
1669 if(seen_short > 1) {
1670 ex(as, "multiple short options");
1674 ex(as, "multiple types");
1677 if(seen_argument > 1) {
1678 ex(as, "multiple arguments");
1682 ex(as, "multiple help strings");
1685 if(seen_default > 1) {
1686 ex(as, "multiple default values");
1693 check_command(struct assignment *as)
1695 struct assignment *a;
1697 int seen_function = 0;
1699 int seen_argument = 0;
1700 int seen_minargs = 0;
1701 int seen_maxargs = 0;
1703 for(a = as; a != NULL; a = a->next) {
1704 if(strcmp(a->name, "name") == 0)
1706 else if(strcmp(a->name, "function") == 0) {
1708 } else if(strcmp(a->name, "option") == 0)
1709 ret += check_option(a->u.assignment);
1710 else if(strcmp(a->name, "help") == 0) {
1712 } else if(strcmp(a->name, "argument") == 0) {
1714 } else if(strcmp(a->name, "min_args") == 0) {
1716 } else if(strcmp(a->name, "max_args") == 0) {
1719 ex(a, "unknown name");
1723 if(seen_name == 0) {
1724 ex(as, "no command name");
1727 if(seen_function > 1) {
1728 ex(as, "multiple function names");
1732 ex(as, "multiple help strings");
1735 if(seen_argument > 1) {
1736 ex(as, "multiple argument strings");
1739 if(seen_minargs > 1) {
1740 ex(as, "multiple min_args strings");
1743 if(seen_maxargs > 1) {
1744 ex(as, "multiple max_args strings");
1752 check(struct assignment *as)
1754 struct assignment *a;
1756 for(a = as; a != NULL; a = a->next) {
1757 if(strcmp(a->name, "command")) {
1758 fprintf(stderr, "unknown type %s line %d\n", a->name, a->lineno);
1762 if(a->type != a_assignment) {
1763 fprintf(stderr, "bad command definition %s line %d\n", a->name, a->lineno);
1767 ret += check_command(a->u.assignment);
1772 static struct assignment *
1773 find_next(struct assignment *as, const char *name)
1775 for(as = as->next; as != NULL; as = as->next) {
1776 if(strcmp(as->name, name) == 0)
1782 static struct assignment *
1783 find(struct assignment *as, const char *name)
1785 for(; as != NULL; as = as->next) {
1786 if(strcmp(as->name, name) == 0)
1793 space(FILE *f, int level)
1795 fprintf(f, "%*.*s", level * 4, level * 4, " ");
1799 cprint(int level, const char *fmt, ...)
1803 space(cfile, level);
1804 vfprintf(cfile, fmt, ap);
1809 hprint(int level, const char *fmt, ...)
1813 space(hfile, level);
1814 vfprintf(hfile, fmt, ap);
1818 static void gen_name(char *str);
1821 gen_command(struct assignment *as)
1823 struct assignment *a, *b;
1825 a = find(as, "name");
1826 f = strdup(a->u.value);
1829 fprintf(cfile, "\"%s\", ", a->u.value);
1830 fprintf(cfile, "%s_wrap, ", f);
1831 b = find(as, "argument");
1833 fprintf(cfile, "\"%s %s\", ", a->u.value, b->u.value);
1835 fprintf(cfile, "\"%s\", ", a->u.value);
1836 b = find(as, "help");
1838 fprintf(cfile, "\"%s\"", b->u.value);
1840 fprintf(cfile, "NULL");
1841 fprintf(cfile, " },\n");
1842 for(a = a->next; a != NULL; a = a->next)
1843 if(strcmp(a->name, "name") == 0)
1844 cprint(1, " { \"%s\" },\n", a->u.value);
1852 for(p = str; *p != '\0'; p++)
1853 if(!isalnum((unsigned char)*p))
1858 make_name(struct assignment *as)
1860 struct assignment *lopt;
1861 struct assignment *type;
1864 lopt = find(as, "long");
1866 lopt = find(as, "name");
1870 type = find(as, "type");
1871 if(strcmp(type->u.value, "-flag") == 0)
1872 asprintf(&s, "%s_flag", lopt->u.value);
1874 asprintf(&s, "%s_%s", lopt->u.value, type->u.value);
1880 static void defval_int(const char *name, struct assignment *defval)
1883 cprint(1, "opt.%s = %s;\n", name, defval->u.value);
1885 cprint(1, "opt.%s = 0;\n", name);
1887 static void defval_string(const char *name, struct assignment *defval)
1890 cprint(1, "opt.%s = \"%s\";\n", name, defval->u.value);
1892 cprint(1, "opt.%s = NULL;\n", name);
1894 static void defval_strings(const char *name, struct assignment *defval)
1896 cprint(1, "opt.%s.num_strings = 0;\n", name);
1897 cprint(1, "opt.%s.strings = NULL;\n", name);
1900 static void free_strings(const char *name)
1902 cprint(1, "free_getarg_strings (&opt.%s);\n", name);
1905 struct type_handler {
1906 const char *typename;
1908 const char *getarg_type;
1909 void (*defval)(const char*, struct assignment*);
1910 void (*free)(const char*);
1911 } type_handlers[] = {
1925 "struct getarg_strings",
1938 "arg_negative_flag",
1945 static struct type_handler *find_handler(struct assignment *type)
1947 struct type_handler *th;
1948 for(th = type_handlers; th->typename != NULL; th++)
1949 if(strcmp(type->u.value, th->typename) == 0)
1951 ex(type, "unknown type \"%s\"", type->u.value);
1956 gen_options(struct assignment *opt1, const char *name)
1958 struct assignment *tmp;
1960 hprint(0, "struct %s_options {\n", name);
1964 tmp = find_next(tmp, "option")) {
1965 struct assignment *type;
1966 struct type_handler *th;
1969 s = make_name(tmp->u.assignment);
1970 type = find(tmp->u.assignment, "type");
1971 th = find_handler(type);
1972 hprint(1, "%s %s;\n", th->c_type, s);
1979 gen_wrapper(struct assignment *as)
1981 struct assignment *name;
1982 struct assignment *arg;
1983 struct assignment *opt1;
1984 struct assignment *function;
1985 struct assignment *tmp;
1989 name = find(as, "name");
1990 n = strdup(name->u.value);
1992 arg = find(as, "argument");
1993 opt1 = find(as, "option");
1994 function = find(as, "function");
1996 f = function->u.value;
2002 gen_options(opt1, n);
2003 hprint(0, "int %s(struct %s_options*, int, char **);\n", f, n);
2005 hprint(0, "int %s(void*, int, char **);\n", f);
2008 fprintf(cfile, "static int\n");
2009 fprintf(cfile, "%s_wrap(int argc, char **argv)\n", n);
2010 fprintf(cfile, "{\n");
2012 cprint(1, "struct %s_options opt;\n", n);
2013 cprint(1, "int ret;\n");
2014 cprint(1, "int optidx = 0;\n");
2015 cprint(1, "struct getargs args[] = {\n");
2016 for(tmp = find(as, "option");
2018 tmp = find_next(tmp, "option")) {
2019 struct assignment *type = find(tmp->u.assignment, "type");
2020 struct assignment *lopt = find(tmp->u.assignment, "long");
2021 struct assignment *sopt = find(tmp->u.assignment, "short");
2022 struct assignment *aarg = find(tmp->u.assignment, "argument");
2023 struct assignment *help = find(tmp->u.assignment, "help");
2025 struct type_handler *th;
2029 fprintf(cfile, "\"%s\", ", lopt->u.value);
2031 fprintf(cfile, "NULL, ");
2033 fprintf(cfile, "'%c', ", *sopt->u.value);
2035 fprintf(cfile, "0, ");
2036 th = find_handler(type);
2037 fprintf(cfile, "%s, ", th->getarg_type);
2038 fprintf(cfile, "NULL, ");
2040 fprintf(cfile, "\"%s\", ", help->u.value);
2042 fprintf(cfile, "NULL, ");
2044 fprintf(cfile, "\"%s\"", aarg->u.value);
2046 fprintf(cfile, "NULL");
2047 fprintf(cfile, " },\n");
2049 cprint(2, "{ \"help\", 'h', arg_flag, NULL, NULL, NULL }\n");
2051 cprint(1, "int help_flag = 0;\n");
2053 for(tmp = find(as, "option");
2055 tmp = find_next(tmp, "option")) {
2057 struct assignment *type = find(tmp->u.assignment, "type");
2059 struct assignment *defval = find(tmp->u.assignment, "default");
2061 struct type_handler *th;
2063 s = make_name(tmp->u.assignment);
2064 th = find_handler(type);
2065 (*th->defval)(s, defval);
2069 for(tmp = find(as, "option");
2071 tmp = find_next(tmp, "option")) {
2073 s = make_name(tmp->u.assignment);
2074 cprint(1, "args[%d].value = &opt.%s;\n", nargs++, s);
2077 cprint(1, "args[%d].value = &help_flag;\n", nargs++);
2078 cprint(1, "if(getarg(args, %d, argc, argv, &optidx))\n", nargs);
2079 cprint(2, "goto usage;\n");
2088 if((tmp = find(as, "min_args")) != NULL) {
2089 min_args = strtol(tmp->u.value, &end, 0);
2091 ex(tmp, "min_args is not numeric");
2095 ex(tmp, "min_args must be non-negative");
2099 if((tmp = find(as, "max_args")) != NULL) {
2100 max_args = strtol(tmp->u.value, &end, 0);
2102 ex(tmp, "max_args is not numeric");
2106 ex(tmp, "max_args must be non-negative");
2111 if(min_args != -1 || max_args != -1) {
2112 if(min_args == max_args) {
2113 cprint(1, "if(argc - optidx != %d) {\n",
2115 cprint(2, "fprintf(stderr, \"Need exactly %u parameters (%%u given).\\n\\n\", argc - optidx);\n", min_args);
2116 cprint(2, "goto usage;\n");
2119 if(max_args != -1) {
2120 cprint(1, "if(argc - optidx > %d) {\n", max_args);
2121 cprint(2, "fprintf(stderr, \"Arguments given (%%u) are more than expected (%u).\\n\\n\", argc - optidx);\n", max_args);
2122 cprint(2, "goto usage;\n");
2125 if(min_args != -1) {
2126 cprint(1, "if(argc - optidx < %d) {\n", min_args);
2127 cprint(2, "fprintf(stderr, \"Arguments given (%%u) are less than expected (%u).\\n\\n\", argc - optidx);\n", min_args);
2128 cprint(2, "goto usage;\n");
2135 cprint(1, "if(help_flag)\n");
2136 cprint(2, "goto usage;\n");
2138 cprint(1, "ret = %s(%s, argc - optidx, argv + optidx);\n",
2139 f, opt1 ? "&opt": "NULL");
2141 /* free allocated data */
2142 for(tmp = find(as, "option");
2144 tmp = find_next(tmp, "option")) {
2146 struct assignment *type = find(tmp->u.assignment, "type");
2147 struct type_handler *th;
2148 th = find_handler(type);
2149 if(th->free == NULL)
2151 s = make_name(tmp->u.assignment);
2155 cprint(1, "return ret;\n");
2157 cprint(0, "usage:\n");
2158 cprint(1, "arg_printusage (args, %d, \"%s\", \"%s\");\n", nargs,
2159 name->u.value, arg ? arg->u.value : "");
2160 /* free allocated data */
2161 for(tmp = find(as, "option");
2163 tmp = find_next(tmp, "option")) {
2165 struct assignment *type = find(tmp->u.assignment, "type");
2166 struct type_handler *th;
2167 th = find_handler(type);
2168 if(th->free == NULL)
2170 s = make_name(tmp->u.assignment);
2174 cprint(1, "return 0;\n");
2179 char cname[PATH_MAX];
2180 char hname[PATH_MAX];
2183 gen(struct assignment *as)
2185 struct assignment *a;
2186 cprint(0, "#include <stdio.h>\n");
2187 cprint(0, "#include <getarg.h>\n");
2188 cprint(0, "#include <sl.h>\n");
2189 cprint(0, "#include \"%s\"\n\n", hname);
2191 hprint(0, "#include <stdio.h>\n");
2192 hprint(0, "#include <sl.h>\n");
2196 for(a = as; a != NULL; a = a->next)
2197 gen_wrapper(a->u.assignment);
2199 cprint(0, "SL_cmd commands[] = {\n");
2200 for(a = as; a != NULL; a = a->next)
2201 gen_command(a->u.assignment);
2202 cprint(1, "{ NULL }\n");
2205 hprint(0, "extern SL_cmd commands[];\n");
2210 struct getargs args[] = {
2211 { "version", 0, arg_flag, &version_flag },
2212 { "help", 0, arg_flag, &help_flag }
2214 int num_args = sizeof(args) / sizeof(args[0]);
2219 arg_printusage(args, num_args, NULL, "command-table");
2224 main(int argc, char **argv)
2230 setprogname(argv[0]);
2231 if(getarg(args, num_args, argc, argv, &optidx))
2236 print_version(NULL);
2243 filename = argv[optidx];
2244 yyin = fopen(filename, "r");
2246 err(1, "%s", filename);
2247 p = strrchr(filename, '/');
2249 strlcpy(cname, p + 1, sizeof(cname));
2251 strlcpy(cname, filename, sizeof(cname));
2252 p = strrchr(cname, '.');
2255 strlcpy(hname, cname, sizeof(hname));
2256 strlcat(cname, ".c", sizeof(cname));
2257 strlcat(hname, ".h", sizeof(hname));
2261 if(check(assignment) == 0) {
2262 cfile = fopen(cname, "w");
2264 err(1, "%s", cname);
2265 hfile = fopen(hname, "w");
2267 err(1, "%s", hname);