|
448
|
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 }
|
