Mercurial > hg > xemacs-beta

comparison netinstall/iniparse.c @ 448:3078fd1074e8 r21-2-39

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-39
author cvs
date Mon, 13 Aug 2007 11:38:25 +0200
parents
children
comparison
equal deleted inserted replaced
447:4fc5f13f3bd3 448:3078fd1074e8
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
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
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
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 }