| blob | 552002fa096f7b3793e4b69dc2cfce5884349b9b |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 1993 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
30 #pragma ident "%Z%%M% %I% %E% SMI"
32 /*
33 ** Skeleton parser driver for yacc output
34 */
36 /*
37 ** yacc user known macros and defines
38 */
39 #define YYERROR goto yyerrlab
40 #define YYACCEPT return(0)
41 #define YYABORT return(1)
42 #define YYBACKUP( newtoken, newvalue )\
43 {\
44 if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
45 {\
46 yyerror( "syntax error - cannot backup" );\
47 goto yyerrlab;\
48 }\
49 yychar = newtoken;\
50 yystate = *yyps;\
51 yylval = newvalue;\
52 goto yynewstate;\
53 }
54 #define YYRECOVERING() (!!yyerrflag)
55 #define YYNEW(type) malloc(sizeof(type) * yynewmax)
56 #define YYCOPY(to, from, type) \
57 (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type))
58 #define YYENLARGE( from, type) \
59 (type *) realloc((char *) from, yynewmax * sizeof(type))
60 #ifndef YYDEBUG
61 # define YYDEBUG 1 /* make debugging available */
62 #endif
64 /*
65 ** user known globals
66 */
67 int yydebug; /* set to 1 to get debugging */
69 /*
70 ** driver internal defines
71 */
72 #define YYFLAG (-10000000)
74 /*
75 ** global variables used by the parser
76 */
77 YYSTYPE *yypv; /* top of value stack */
78 int *yyps; /* top of state stack */
80 int yystate; /* current state */
81 int yytmp; /* extra var (lasts between blocks) */
83 int yynerrs; /* number of errors */
84 int yyerrflag; /* error recovery flag */
85 int yychar; /* current input token number */
89 #ifdef YYNMBCHARS
90 #define YYLEX() yycvtok(yylex())
91 /*
92 ** yycvtok - return a token if i is a wchar_t value that exceeds 255.
93 ** If i<255, i itself is the token. If i>255 but the neither
94 ** of the 30th or 31st bit is on, i is already a token.
95 */
96 #if defined(__STDC__) || defined(__cplusplus)
97 int yycvtok(int i)
98 #else
99 int yycvtok(i) int i;
100 #endif
101 {
102 int first = 0;
103 int last = YYNMBCHARS - 1;
104 int mid;
105 wchar_t j;
107 if(i&0x60000000){/*Must convert to a token. */
108 if( yymbchars[last].character < i ){
109 return i;/*Giving up*/
110 }
111 while ((last>=first)&&(first>=0)) {/*Binary search loop*/
112 mid = (first+last)/2;
113 j = yymbchars[mid].character;
114 if( j==i ){/*Found*/
115 return yymbchars[mid].tvalue;
116 }else if( j<i ){
117 first = mid + 1;
118 }else{
119 last = mid -1;
120 }
121 }
122 /*No entry in the table.*/
123 return i;/* Giving up.*/
124 }else{/* i is already a token. */
125 return i;
126 }
127 }
128 #else/*!YYNMBCHARS*/
129 #define YYLEX() yylex()
130 #endif/*!YYNMBCHARS*/
132 /*
133 ** yyparse - return 0 if worked, 1 if syntax error not recovered from
134 */
135 #if defined(__STDC__) || defined(__cplusplus)
136 int yyparse(void)
137 #else
138 int yyparse()
139 #endif
140 {
141 register YYSTYPE *yypvt = 0; /* top of value stack for $vars */
143 #if defined(__cplusplus) || defined(lint)
144 /*
145 hacks to please C++ and lint - goto's inside
146 switch should never be executed
147 */
148 static int __yaccpar_lint_hack__ = 0;
149 switch (__yaccpar_lint_hack__)
150 {
151 case 1: goto yyerrlab;
152 case 2: goto yynewstate;
153 }
154 #endif
156 /*
157 ** Initialize externals - yyparse may be called more than once
158 */
159 yypv = &yyv[-1];
160 yyps = &yys[-1];
161 yystate = 0;
162 yytmp = 0;
163 yynerrs = 0;
164 yyerrflag = 0;
165 yychar = -1;
167 #if YYMAXDEPTH <= 0
168 if (yymaxdepth <= 0)
169 {
170 if ((yymaxdepth = YYEXPAND(0)) <= 0)
171 {
172 yyerror("yacc initialization error");
173 YYABORT;
174 }
175 }
176 #endif
178 {
179 register YYSTYPE *yy_pv; /* top of value stack */
180 register int *yy_ps; /* top of state stack */
181 register int yy_state; /* current state */
182 register int yy_n; /* internal state number info */
183 goto yystack; /* moved from 6 lines above to here to please C++ */
185 /*
186 ** get globals into registers.
187 ** branch to here only if YYBACKUP was called.
188 */
189 yynewstate:
190 yy_pv = yypv;
191 yy_ps = yyps;
192 yy_state = yystate;
193 goto yy_newstate;
195 /*
196 ** get globals into registers.
197 ** either we just started, or we just finished a reduction
198 */
199 yystack:
200 yy_pv = yypv;
201 yy_ps = yyps;
202 yy_state = yystate;
204 /*
205 ** top of for (;;) loop while no reductions done
206 */
207 yy_stack:
208 /*
209 ** put a state and value onto the stacks
210 */
211 #if YYDEBUG
212 /*
213 ** if debugging, look up token value in list of value vs.
214 ** name pairs. 0 and negative (-1) are special values.
215 ** Note: linear search is used since time is not a real
216 ** consideration while debugging.
217 */
218 if ( yydebug )
219 {
220 register int yy_i;
222 printf( "State %d, token ", yy_state );
223 if ( yychar == 0 )
224 printf( "end-of-file\n" );
225 else if ( yychar < 0 )
226 printf( "-none-\n" );
227 else
228 {
229 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
230 yy_i++ )
231 {
232 if ( yytoks[yy_i].t_val == yychar )
233 break;
234 }
235 printf( "%s\n", yytoks[yy_i].t_name );
236 }
237 }
238 #endif /* YYDEBUG */
239 if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */
240 {
241 /*
242 ** reallocate and recover. Note that pointers
243 ** have to be reset, or bad things will happen
244 */
245 long yyps_index = (yy_ps - yys);
246 long yypv_index = (yy_pv - yyv);
247 long yypvt_index = (yypvt - yyv);
248 int yynewmax;
249 #ifdef YYEXPAND
250 yynewmax = YYEXPAND(yymaxdepth);
251 #else
252 yynewmax = 2 * yymaxdepth; /* double table size */
253 if (yymaxdepth == YYMAXDEPTH) /* first time growth */
254 {
255 char *newyys = (char *)YYNEW(int);
256 char *newyyv = (char *)YYNEW(YYSTYPE);
257 if (newyys != 0 && newyyv != 0)
258 {
259 yys = YYCOPY(newyys, yys, int);
260 yyv = YYCOPY(newyyv, yyv, YYSTYPE);
261 }
262 else
263 yynewmax = 0; /* failed */
264 }
265 else /* not first time */
266 {
267 yys = YYENLARGE(yys, int);
268 yyv = YYENLARGE(yyv, YYSTYPE);
269 if (yys == 0 || yyv == 0)
270 yynewmax = 0; /* failed */
271 }
272 #endif
273 if (yynewmax <= yymaxdepth) /* tables not expanded */
274 {
275 yyerror( "yacc stack overflow" );
276 YYABORT;
277 }
278 yymaxdepth = yynewmax;
280 yy_ps = yys + yyps_index;
281 yy_pv = yyv + yypv_index;
282 yypvt = yyv + yypvt_index;
283 }
284 *yy_ps = yy_state;
285 *++yy_pv = yyval;
287 /*
288 ** we have a new state - find out what to do
289 */
290 yy_newstate:
291 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
292 goto yydefault; /* simple state */
293 #if YYDEBUG
294 /*
295 ** if debugging, need to mark whether new token grabbed
296 */
297 yytmp = yychar < 0;
298 #endif
299 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
300 yychar = 0; /* reached EOF */
301 #if YYDEBUG
302 if ( yydebug && yytmp )
303 {
304 register int yy_i;
306 printf( "Received token " );
307 if ( yychar == 0 )
308 printf( "end-of-file\n" );
309 else if ( yychar < 0 )
310 printf( "-none-\n" );
311 else
312 {
313 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
314 yy_i++ )
315 {
316 if ( yytoks[yy_i].t_val == yychar )
317 break;
318 }
319 printf( "%s\n", yytoks[yy_i].t_name );
320 }
321 }
322 #endif /* YYDEBUG */
323 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
324 goto yydefault;
325 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/
326 {
327 yychar = -1;
328 yyval = yylval;
329 yy_state = yy_n;
330 if ( yyerrflag > 0 )
331 yyerrflag--;
332 goto yy_stack;
333 }
335 yydefault:
336 if ( ( yy_n = yydef[ yy_state ] ) == -2 )
337 {
338 #if YYDEBUG
339 yytmp = yychar < 0;
340 #endif
341 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
342 yychar = 0; /* reached EOF */
343 #if YYDEBUG
344 if ( yydebug && yytmp )
345 {
346 register int yy_i;
348 printf( "Received token " );
349 if ( yychar == 0 )
350 printf( "end-of-file\n" );
351 else if ( yychar < 0 )
352 printf( "-none-\n" );
353 else
354 {
355 for ( yy_i = 0;
356 yytoks[yy_i].t_val >= 0;
357 yy_i++ )
358 {
359 if ( yytoks[yy_i].t_val
360 == yychar )
361 {
362 break;
363 }
364 }
365 printf( "%s\n", yytoks[yy_i].t_name );
366 }
367 }
368 #endif /* YYDEBUG */
369 /*
370 ** look through exception table
371 */
372 {
373 register YYCONST int *yyxi = yyexca;
375 while ( ( *yyxi != -1 ) ||
376 ( yyxi[1] != yy_state ) )
377 {
378 yyxi += 2;
379 }
380 while ( ( *(yyxi += 2) >= 0 ) &&
381 ( *yyxi != yychar ) )
382 ;
383 if ( ( yy_n = yyxi[1] ) < 0 )
384 YYACCEPT;
385 }
386 }
388 /*
389 ** check for syntax error
390 */
391 if ( yy_n == 0 ) /* have an error */
392 {
393 /* no worry about speed here! */
394 switch ( yyerrflag )
395 {
396 case 0: /* new error */
397 yyerror( "syntax error" );
398 goto skip_init;
399 yyerrlab:
400 /*
401 ** get globals into registers.
402 ** we have a user generated syntax type error
403 */
404 yy_pv = yypv;
405 yy_ps = yyps;
406 yy_state = yystate;
407 skip_init:
408 yynerrs++;
409 /* FALLTHRU */
410 case 1:
411 case 2: /* incompletely recovered error */
412 /* try again... */
413 yyerrflag = 3;
414 /*
415 ** find state where "error" is a legal
416 ** shift action
417 */
418 while ( yy_ps >= yys )
419 {
420 yy_n = yypact[ *yy_ps ] + YYERRCODE;
421 if ( yy_n >= 0 && yy_n < YYLAST &&
422 yychk[yyact[yy_n]] == YYERRCODE) {
423 /*
424 ** simulate shift of "error"
425 */
426 yy_state = yyact[ yy_n ];
427 goto yy_stack;
428 }
429 /*
430 ** current state has no shift on
431 ** "error", pop stack
432 */
433 #if YYDEBUG
434 # define _POP_ "Error recovery pops state %d, uncovers state %d\n"
435 if ( yydebug )
436 printf( _POP_, *yy_ps,
437 yy_ps[-1] );
438 # undef _POP_
439 #endif
440 yy_ps--;
441 yy_pv--;
442 }
443 /*
444 ** there is no state on stack with "error" as
445 ** a valid shift. give up.
446 */
447 YYABORT;
448 case 3: /* no shift yet; eat a token */
449 #if YYDEBUG
450 /*
451 ** if debugging, look up token in list of
452 ** pairs. 0 and negative shouldn't occur,
453 ** but since timing doesn't matter when
454 ** debugging, it doesn't hurt to leave the
455 ** tests here.
456 */
457 if ( yydebug )
458 {
459 register int yy_i;
461 printf( "Error recovery discards " );
462 if ( yychar == 0 )
463 printf( "token end-of-file\n" );
464 else if ( yychar < 0 )
465 printf( "token -none-\n" );
466 else
467 {
468 for ( yy_i = 0;
469 yytoks[yy_i].t_val >= 0;
470 yy_i++ )
471 {
472 if ( yytoks[yy_i].t_val
473 == yychar )
474 {
475 break;
476 }
477 }
478 printf( "token %s\n",
479 yytoks[yy_i].t_name );
480 }
481 }
482 #endif /* YYDEBUG */
483 if ( yychar == 0 ) /* reached EOF. quit */
484 YYABORT;
485 yychar = -1;
486 goto yy_newstate;
487 }
488 }/* end if ( yy_n == 0 ) */
489 /*
490 ** reduction by production yy_n
491 ** put stack tops, etc. so things right after switch
492 */
493 #if YYDEBUG
494 /*
495 ** if debugging, print the string that is the user's
496 ** specification of the reduction which is just about
497 ** to be done.
498 */
499 if ( yydebug )
500 printf( "Reduce by (%d) \"%s\"\n",
501 yy_n, yyreds[ yy_n ] );
502 #endif
503 yytmp = yy_n; /* value to switch over */
504 yypvt = yy_pv; /* $vars top of value stack */
505 /*
506 ** Look in goto table for next state
507 ** Sorry about using yy_state here as temporary
508 ** register variable, but why not, if it works...
509 ** If yyr2[ yy_n ] doesn't have the low order bit
510 ** set, then there is no action to be done for
511 ** this reduction. So, no saving & unsaving of
512 ** registers done. The only difference between the
513 ** code just after the if and the body of the if is
514 ** the goto yy_stack in the body. This way the test
515 ** can be made before the choice of what to do is needed.
516 */
517 {
518 /* length of production doubled with extra bit */
519 register int yy_len = yyr2[ yy_n ];
521 if ( !( yy_len & 01 ) )
522 {
523 yy_len >>= 1;
524 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
525 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
526 *( yy_ps -= yy_len ) + 1;
527 if ( yy_state >= YYLAST ||
528 yychk[ yy_state =
529 yyact[ yy_state ] ] != -yy_n )
530 {
531 yy_state = yyact[ yypgo[ yy_n ] ];
532 }
533 goto yy_stack;
534 }
535 yy_len >>= 1;
536 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
537 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
538 *( yy_ps -= yy_len ) + 1;
539 if ( yy_state >= YYLAST ||
540 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
541 {
542 yy_state = yyact[ yypgo[ yy_n ] ];
543 }
544 }
545 /* save until reenter driver code */
546 yystate = yy_state;
547 yyps = yy_ps;
548 yypv = yy_pv;
549 }
550 /*
551 ** code supplied by user is placed in this switch
552 */
553 switch( yytmp )
554 {
555 $A
556 }
557 goto yystack; /* reset registers in driver code */
558 }