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