]> git.saurik.com Git - bison.git/blob - tests/torture.at
projects / bison.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* tests/actions.at, tests/calc.at, tests/headers.at,
[bison.git] / tests / torture.at
1 # Torturing Bison. -*- Autotest -*-
2 # Copyright 2001 Free Software Foundation, Inc.
3
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 2, or (at your option)
7 # any later version.
8
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
13
14 # You should have received a copy of the GNU General Public License
15 # along with this program; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
17 # 02111-1307, USA.
18
19 AT_BANNER([[Torture Tests.]])
20
21
22 # AT_DATA_STACK_TORTURE(C-PROLOGUE)
23 # ---------------------------------
24 # A parser specialized in torturing the stack size.
25 m4_define([AT_DATA_STACK_TORTURE],
26 [# A grammar of parens growing the stack thanks to right recursion.
27 # exp:
28 AT_DATA([input.y],
29 [[%{
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <assert.h>
33 ]$1[
34 static int yylex (void);
35 static void yyerror (const char *msg);
36 #define YYPRINT(File, Type, Value) \
37 fprintf (File, " (%d, stack size = %d, max = %d)", \
38 Value, yyssp - yyss + 1, yystacksize);
39 %}
40 %error-verbose
41 %debug
42 %token WAIT_FOR_EOF
43 %%
44 exp: WAIT_FOR_EOF exp | ;
45 %%
46 static void
47 yyerror (const char *msg)
48 {
49 fprintf (stderr, "%s\n", msg);
50 exit (1);
51 }
52
53 /* There are YYLVAL_MAX of WAIT_FOR_EOFs. */
54 unsigned int yylval_max;
55
56 static int
57 yylex (void)
58 {
59 if (yylval--)
60 return WAIT_FOR_EOF;
61 else
62 return EOF;
63 }
64
65 int
66 main (int argc, const char **argv)
67 {
68 assert (argc == 2);
69 yylval = atoi (argv[1]);
70 yydebug = 1;
71 return yyparse ();
72 }
73 ]])
74 AT_CHECK([bison input.y -o input.c])
75 AT_CHECK([$CC $CFLAGS $CPPFLAGS input.c -o input], 0, [], [ignore])
76 ])
77
78
79 ## -------------------------------------- ##
80 ## Exploding the Stack Size with Alloca. ##
81 ## -------------------------------------- ##
82
83 AT_SETUP([Exploding the Stack Size with Alloca])
84
85 AT_DATA_STACK_TORTURE
86
87 # Below the limit of 200.
88 AT_CHECK([./input 20], 0, [], [ignore])
89 # Two enlargements: 2 * 2 * 200.
90 AT_CHECK([./input 900], 0, [], [ignore])
91 # Fails: beyond the limit of 10,000 (which we don't reach anyway since we
92 # multiply by two starting at 200 => 5120 is the last possible).
93 AT_CHECK([./input 10000], 1, [], [ignore])
94
95 AT_CLEANUP
96
97
98
99
100 ## -------------------------------------- ##
101 ## Exploding the Stack Size with Malloc. ##
102 ## -------------------------------------- ##
103
104 AT_SETUP([Exploding the Stack Size with Malloc])
105
106 AT_DATA_STACK_TORTURE([[#define YYSTACK_USE_ALLOCA 0]])
107
108 # Below the limit of 200.
109 AT_CHECK([./input 20], 0, [], [ignore])
110 # Two enlargements: 2 * 2 * 200.
111 AT_CHECK([./input 900], 0, [], [ignore])
112 # Fails: beyond the limit of 10,000 (which we don't reach anyway since we
113 # multiply by two starting at 200 => 5120 is the possible).
114 AT_CHECK([./input 10000], 1, [], [ignore])
115
116 AT_CLEANUP
117
118
119 ## ----------------- ##
120 ## GNU AWK Grammar. ##
121 ## ----------------- ##
122
123 AT_SETUP([GNU AWK Grammar])
124
125 # We have been careful to strip all the actions excepts the
126 # mid-rule actions. We rely on %expect to check that there are
127 # indeed 65 SR conflicts.
128 #
129 # Bison was once wrong, due to an incorrect computation of nullable.
130 # It reported 485 SR conflicts!
131
132 AT_DATA([[input.y]],
133 [[%expect 65
134
135 %token FUNC_CALL NAME REGEXP
136 %token ERROR
137 %token YNUMBER YSTRING
138 %token RELOP APPEND_OP
139 %token ASSIGNOP MATCHOP NEWLINE CONCAT_OP
140 %token LEX_BEGIN LEX_END LEX_IF LEX_ELSE LEX_RETURN LEX_DELETE
141 %token LEX_WHILE LEX_DO LEX_FOR LEX_BREAK LEX_CONTINUE
142 %token LEX_PRINT LEX_PRINTF LEX_NEXT LEX_EXIT LEX_FUNCTION
143 %token LEX_GETLINE LEX_NEXTFILE
144 %token LEX_IN
145 %token LEX_AND LEX_OR INCREMENT DECREMENT
146 %token LEX_BUILTIN LEX_LENGTH
147
148 /* Lowest to highest */
149 %right ASSIGNOP
150 %right '?' ':'
151 %left LEX_OR
152 %left LEX_AND
153 %left LEX_GETLINE
154 %nonassoc LEX_IN
155 %left FUNC_CALL LEX_BUILTIN LEX_LENGTH
156 %nonassoc ','
157 %nonassoc MATCHOP
158 %nonassoc RELOP '<' '>' '|' APPEND_OP TWOWAYIO
159 %left CONCAT_OP
160 %left YSTRING YNUMBER
161 %left '+' '-'
162 %left '*' '/' '%'
163 %right '!' UNARY
164 %right '^'
165 %left INCREMENT DECREMENT
166 %left '$'
167 %left '(' ')'
168 %%
169
170 start
171 : opt_nls program opt_nls
172 ;
173
174 program
175 : rule
176 | program rule
177 | error
178 | program error
179 | /* empty */
180 ;
181
182 rule
183 : LEX_BEGIN {} action
184 | LEX_END {} action
185 | LEX_BEGIN statement_term
186 | LEX_END statement_term
187 | pattern action
188 | action
189 | pattern statement_term
190 | function_prologue function_body
191 ;
192
193 func_name
194 : NAME
195 | FUNC_CALL
196 | lex_builtin
197 ;
198
199 lex_builtin
200 : LEX_BUILTIN
201 | LEX_LENGTH
202 ;
203
204 function_prologue
205 : LEX_FUNCTION {} func_name '(' opt_param_list r_paren opt_nls
206 ;
207
208 function_body
209 : l_brace statements r_brace opt_semi opt_nls
210 | l_brace r_brace opt_semi opt_nls
211 ;
212
213
214 pattern
215 : exp
216 | exp ',' exp
217 ;
218
219 regexp
220 /*
221 * In this rule, want_regexp tells yylex that the next thing
222 * is a regexp so it should read up to the closing slash.
223 */
224 : '/' {} REGEXP '/'
225 ;
226
227 action
228 : l_brace statements r_brace opt_semi opt_nls
229 | l_brace r_brace opt_semi opt_nls
230 ;
231
232 statements
233 : statement
234 | statements statement
235 | error
236 | statements error
237 ;
238
239 statement_term
240 : nls
241 | semi opt_nls
242 ;
243
244 statement
245 : semi opt_nls
246 | l_brace r_brace
247 | l_brace statements r_brace
248 | if_statement
249 | LEX_WHILE '(' exp r_paren opt_nls statement
250 | LEX_DO opt_nls statement LEX_WHILE '(' exp r_paren opt_nls
251 | LEX_FOR '(' NAME LEX_IN NAME r_paren opt_nls statement
252 | LEX_FOR '(' opt_exp semi opt_nls exp semi opt_nls opt_exp r_paren opt_nls statement
253 | LEX_FOR '(' opt_exp semi opt_nls semi opt_nls opt_exp r_paren opt_nls statement
254 | LEX_BREAK statement_term
255 | LEX_CONTINUE statement_term
256 | print '(' expression_list r_paren output_redir statement_term
257 | print opt_rexpression_list output_redir statement_term
258 | LEX_NEXT statement_term
259 | LEX_NEXTFILE statement_term
260 | LEX_EXIT opt_exp statement_term
261 | LEX_RETURN {} opt_exp statement_term
262 | LEX_DELETE NAME '[' expression_list ']' statement_term
263 | LEX_DELETE NAME statement_term
264 | exp statement_term
265 ;
266
267 print
268 : LEX_PRINT
269 | LEX_PRINTF
270 ;
271
272 if_statement
273 : LEX_IF '(' exp r_paren opt_nls statement
274 | LEX_IF '(' exp r_paren opt_nls statement
275 LEX_ELSE opt_nls statement
276 ;
277
278 nls
279 : NEWLINE
280 | nls NEWLINE
281 ;
282
283 opt_nls
284 : /* empty */
285 | nls
286 ;
287
288 input_redir
289 : /* empty */
290 | '<' simp_exp
291 ;
292
293 output_redir
294 : /* empty */
295 | '>' exp
296 | APPEND_OP exp
297 | '|' exp
298 | TWOWAYIO exp
299 ;
300
301 opt_param_list
302 : /* empty */
303 | param_list
304 ;
305
306 param_list
307 : NAME
308 | param_list comma NAME
309 | error
310 | param_list error
311 | param_list comma error
312 ;
313
314 /* optional expression, as in for loop */
315 opt_exp
316 : /* empty */
317 | exp
318 ;
319
320 opt_rexpression_list
321 : /* empty */
322 | rexpression_list
323 ;
324
325 rexpression_list
326 : rexp
327 | rexpression_list comma rexp
328 | error
329 | rexpression_list error
330 | rexpression_list error rexp
331 | rexpression_list comma error
332 ;
333
334 opt_expression_list
335 : /* empty */
336 | expression_list
337 ;
338
339 expression_list
340 : exp
341 | expression_list comma exp
342 | error
343 | expression_list error
344 | expression_list error exp
345 | expression_list comma error
346 ;
347
348 /* Expressions, not including the comma operator. */
349 exp : variable ASSIGNOP {} exp
350 | '(' expression_list r_paren LEX_IN NAME
351 | exp '|' LEX_GETLINE opt_variable
352 | exp TWOWAYIO LEX_GETLINE opt_variable
353 | LEX_GETLINE opt_variable input_redir
354 | exp LEX_AND exp
355 | exp LEX_OR exp
356 | exp MATCHOP exp
357 | regexp
358 | '!' regexp %prec UNARY
359 | exp LEX_IN NAME
360 | exp RELOP exp
361 | exp '<' exp
362 | exp '>' exp
363 | exp '?' exp ':' exp
364 | simp_exp
365 | exp simp_exp %prec CONCAT_OP
366 ;
367
368 rexp
369 : variable ASSIGNOP {} rexp
370 | rexp LEX_AND rexp
371 | rexp LEX_OR rexp
372 | LEX_GETLINE opt_variable input_redir
373 | regexp
374 | '!' regexp %prec UNARY
375 | rexp MATCHOP rexp
376 | rexp LEX_IN NAME
377 | rexp RELOP rexp
378 | rexp '?' rexp ':' rexp
379 | simp_exp
380 | rexp simp_exp %prec CONCAT_OP
381 ;
382
383 simp_exp
384 : non_post_simp_exp
385 /* Binary operators in order of decreasing precedence. */
386 | simp_exp '^' simp_exp
387 | simp_exp '*' simp_exp
388 | simp_exp '/' simp_exp
389 | simp_exp '%' simp_exp
390 | simp_exp '+' simp_exp
391 | simp_exp '-' simp_exp
392 | variable INCREMENT
393 | variable DECREMENT
394 ;
395
396 non_post_simp_exp
397 : '!' simp_exp %prec UNARY
398 | '(' exp r_paren
399 | LEX_BUILTIN
400 '(' opt_expression_list r_paren
401 | LEX_LENGTH '(' opt_expression_list r_paren
402 | LEX_LENGTH
403 | FUNC_CALL '(' opt_expression_list r_paren
404 | variable
405 | INCREMENT variable
406 | DECREMENT variable
407 | YNUMBER
408 | YSTRING
409 | '-' simp_exp %prec UNARY
410 | '+' simp_exp %prec UNARY
411 ;
412
413 opt_variable
414 : /* empty */
415 | variable
416 ;
417
418 variable
419 : NAME
420 | NAME '[' expression_list ']'
421 | '$' non_post_simp_exp
422 ;
423
424 l_brace
425 : '{' opt_nls
426 ;
427
428 r_brace
429 : '}' opt_nls
430 ;
431
432 r_paren
433 : ')'
434 ;
435
436 opt_semi
437 : /* empty */
438 | semi
439 ;
440
441 semi
442 : ';'
443 ;
444
445 comma : ',' opt_nls
446 ;
447
448 %%
449 ]])
450
451 # Pass plenty of options, to exercise plenty of code, even if we
452 # don't actually check the output. But SEGV is watching us, and
453 # so might do dmalloc.
454 AT_CHECK([[bison --verbose --defines input.y]])
455
456 AT_CLEANUP
457
458
459 ## ----------------- ##
460 ## GNU Cim Grammar. ##
461 ## ----------------- ##
462
463 AT_SETUP([GNU Cim Grammar])
464
465 # GNU Cim, the GNU Simula 87 Compiler.
466
467 # Bison was once wrong, due to an incorrect computation of the RR conflicts.
468 # It reported 80 SR && 99 RR conflicts instead of 78/10!!!
469
470 AT_DATA([[input.y]],
471 [[%union {
472 long token;
473 long ival;
474 long arrdim;
475 double rval;
476 char *ident;
477 char *tval;
478 char stat_decl;
479 }
480
481 %token
482 HACTIVATE HAFTER /*HAND*/ HARRAY HAT
483 HBEFORE HBEGIN HBOOLEAN
484 HCHARACTER HCLASS /*HCOMMENT*/ HCONC
485 HDELAY HDO
486 HELSE HEND HEQ /*HEQV*/ HEXTERNAL
487 HFOR
488 HGE HGO HGOTO HGT
489 HHIDDEN
490 HIF /*HIMP*/ HIN HINNER HINSPECT HINTEGER HIS
491 HLABEL HLE HLONG HLT
492 HNAME HNE HNEW HNONE /*HNOT*/ HNOTEXT
493 /*HOR*/ HOTHERWISE
494 HPRIOR HPROCEDURE HPROTECTED
495 HQUA
496 HREACTIVATE HREAL HREF
497 HSHORT HSTEP HSWITCH
498 HTEXT HTHEN HTHIS HTO
499 HUNTIL
500 HVALUE HVAR HVIRTUAL
501 HWHEN HWHILE
502
503 HASSIGNVALUE HASSIGNREF
504 /*HDOT*/ HPAREXPSEPARATOR HLABELSEPARATOR HSTATEMENTSEPARATOR
505 HBEGPAR HENDPAR
506 HEQR HNER
507 HADD HSUB HMUL HDIV HINTDIV HEXP
508 HDOTDOTDOT
509
510 %token <ident> HIDENTIFIER
511 %token <ival> HBOOLEANKONST HINTEGERKONST HCHARACTERKONST
512 %token <rval> HREALKONST
513 %token <tval> HTEXTKONST
514
515 %type <tval> EXT_IDENT
516 %type <stat_decl> DECLSTATEMENT MODULSTATEMENT MBEE_DECLSTMS MBEE_DECLSTMSU
517 %type <stat_decl> MODULS
518 %type <ident> EXPRESSION_SIMP MBEE_ARG_R_PT
519 %type <arrdim> BAUND_PAIR_LIST
520
521 %right <token> HASSIGN
522 %left HORELSE
523 %left HANDTHEN
524 %left HEQV
525 %left HIMP
526 %left HOR
527 %left HAND
528
529 %left HNOT
530
531 %left <token> HVALRELOPERATOR HREFRELOPERATOR HOBJRELOPERATOR
532
533 %left HCONC
534
535 %left <token> HTERMOPERATOR
536 %left <token> UNEAR
537 %left <token> HFACTOROPERATOR
538 %left HPRIMARYOPERATOR
539
540 %left HQUA
541
542 %left HDOT
543
544 %start MAIN_MODULE
545 %%
546 /* GRAMATIKK FOR PROGRAM MODULES */
547 MAIN_MODULE : { categ=CLOCAL; mout(MBLOCK);
548 beginBlock(KBLOKK);separat_comp=FALSE;}
549 MODULS { endBlock(NULL,CCNO); mout(MENDBLOCK);}
550 | error HSTATEMENTSEPARATOR MBEE_DECLSTMS
551 ;
552 EXT_DECLARATION : HEXTERNAL
553 MBEE_TYPE
554 HPROCEDURE
555 { MBEENEWBLOCK();
556 kind=KPROC;}
557 EXT_LIST
558 |
559 HEXTERNAL
560 HIDENTIFIER
561 HPROCEDURE
562 { MBEENEWBLOCK();
563 type=TNOTY;
564 kind=KPROC;
565 if($2==Ckind)categ=CCPROC;else
566 yerror (1);
567 ysensitive=sensitive;
568 sensitive=ON;}
569 HIDENTIFIER { $<ident>$=$5;
570 sensitive=ysensitive;}
571 EXTERNAL_KIND_ITEM
572 { categ=CLOCAL;}
573 | HEXTERNAL
574 HCLASS
575 { MBEENEWBLOCK();
576 kind=KCLASS;}
577 EXT_LIST
578
579 ;
580 EXTERNAL_KIND_ITEM: EXT_IDENT
581 HOBJRELOPERATOR
582 { if($2!=HIS)yerror (2);}
583 MBEE_TYPE HPROCEDURE
584 HIDENTIFIER
585 { regDecl($6, type, KPROC, CCPROC);
586 beginBlock(kind);}
587 HEADING EMPTY_BLOCK
588 { categ=CLOCAL;
589 endBlock($1==NULL?$<ident>0:tag($1),CCCPROC);}
590 /* |
591 EXT_IDENT
592 { if($1!=NULL)yerror (3);
593 regDecl($0, type, kind, categ);}
594 MBEE_REST_EXT_LIST
595 { endBlock(NULL,CCNO);}
596 ;
597 MBEE_REST_EXT_LIST: /* EMPTY
598 | HPAREXPSEPARATOR EXT_KIND_LIST
599 ;
600 EXT_KIND_LIST : EXT_KIND_ITEM
601 | EXT_KIND_LIST HPAREXPSEPARATOR EXT_KIND_ITEM
602 ;
603 EXT_KIND_ITEM : HIDENTIFIER
604 EXT_IDENT
605 { if($2!=NULL)yerror (3);
606 regDecl($1, type, kind, categ);}*/
607 ;
608 EMPTY_BLOCK : /*EMPT*/
609 | HBEGIN HEND
610 ;
611 EXT_LIST : EXT_ITEM
612 | EXT_LIST HPAREXPSEPARATOR EXT_ITEM
613 ;
614 EXT_ITEM : HIDENTIFIER
615 EXT_IDENT
616 { lesinn_external_spec($1,$2, kind);}
617 ;
618 EXT_IDENT : /* EMPTY */ { $$=NULL;}
619 | HVALRELOPERATOR { if($1!=HEQ)yerror (9);
620 external=TRUE;}
621 HTEXTKONST { $$=$3;external=FALSE;}
622 ;
623 /* GRAMATIKK FOR TYPER */
624 NO_TYPE : /*EMPT*/ { type=TNOTY;}
625 ;
626 MBEE_TYPE : NO_TYPE
627 | TYPE
628 ;
629 TYPE : HREF HBEGPAR
630 HIDENTIFIER
631 { prefquantident=$3;
632 type=TREF;}
633 HENDPAR
634 | HTEXT { type=TTEXT;}
635 | HBOOLEAN { type=TBOOL;}
636 | HCHARACTER { type=TCHAR;}
637 | HSHORT HINTEGER { type=TSHORT;}
638 | HINTEGER { type=TINTG;}
639 | HREAL { type=TREAL;}
640 | HLONG HREAL { type=TLONG;}
641 ;
642
643 /* GRAMATIKK FOR DEL AV SETNINGER */
644 MBEE_ELSE_PART : /*EMPT*/
645 /* | HELSE
646 HIF
647 EXPRESSION
648 HTHEN { mout(MELSE);
649 mout(MIF);
650 OBSBLOCK();}
651 BLOCK { MBEEENDBLOCK();}
652 MBEE_ELSE_PART { mout(MENDIF);}*/
653 | HELSE { OBSBLOCK(); mout(MELSE);}
654 BLOCK { MBEEENDBLOCK();}
655 ;
656 FOR_LIST : FOR_LIST_ELEMENT { mout(MENDSEP);
657 mout(MLISTSEP);}
658 | FOR_LIST_ELEMENT
659 HPAREXPSEPARATOR
660 FOR_LIST { mout(MLISTSEP);}
661 ;
662 FOR_LIST_ELEMENT: EXPRESSION
663 MBEE_F_L_EL_R_PT
664 ;
665 MBEE_F_L_EL_R_PT: /*EMPT*/
666 | HWHILE
667 EXPRESSION { mout(MFORWHILE);}
668 | HSTEP
669 EXPRESSION
670 HUNTIL
671 EXPRESSION { mout(MUNTIL);
672 mout(MSTEP);}
673 ;
674 GOTO : HGO
675 HTO
676 | HGOTO
677 ;
678 CONN_STATE_R_PT : WHEN_CLAUSE_LIST
679 | HDO { beginBlock(KCON); mout(MDO);
680 OBSBLOCK(); }
681 BLOCK { endBlock(NULL,CCNO);
682 MBEEENDBLOCK(); mout(MENDDO);}
683 ;
684 WHEN_CLAUSE_LIST: HWHEN
685 HIDENTIFIER
686 HDO { beginBlock(KCON); mout(MIDENTIFIER);
687 OBSBLOCK(); moutId($2);
688 mout(MWHEN);}
689 BLOCK { endBlock(NULL,CCNO);
690 MBEEENDBLOCK(); mout(MENDWHEN);}
691 | WHEN_CLAUSE_LIST
692 HWHEN
693 HIDENTIFIER
694 HDO { beginBlock(KCON); mout(MIDENTIFIER);
695 OBSBLOCK(); moutId($3);
696 mout(MWHEN);}
697 BLOCK { endBlock(NULL,CCNO);
698 MBEEENDBLOCK(); mout(MENDWHEN);}
699 ;
700 MBEE_OTWI_CLAUS : /*EMPT*/
701 | HOTHERWISE {OBSBLOCK(); mout(MOTHERWISE);}
702
703 BLOCK {MBEEENDBLOCK();mout(MENDOTHERWISE);}
704 ;
705 ACTIVATOR : HACTIVATE { mout(MBOOLEANKONST);
706 moutIval(FALSE);}
707 | HREACTIVATE { mout(MBOOLEANKONST);
708 moutIval(TRUE);}
709 ;
710 SCHEDULE : /*EMPT*/ { mout(MCHARACTERKONST);
711 moutIval(DIRECT);
712 mout(MINTEGERKONST);
713 moutIval(0);
714 mout(MNONE);
715 mout(MBOOLEANKONST);
716 moutIval(FALSE);}
717 | ATDELAY EXPRESSION { mout(MNONE);}
718 PRIOR
719 | BEFOREAFTER { mout(MINTEGERKONST);
720 moutIval(0);}
721 EXPRESSION { mout(MBOOLEANKONST);
722 moutIval(FALSE);}
723 ;
724 ATDELAY : HAT { mout(MCHARACTERKONST);
725 moutIval(AT);}
726 | HDELAY { mout(MCHARACTERKONST);
727 moutIval(DELAYS);}
728 ;
729 BEFOREAFTER : HBEFORE { mout(MCHARACTERKONST);
730 moutIval(BEFORE);}
731 | HAFTER { mout(MCHARACTERKONST);
732 moutIval(AFTER);}
733 ;
734 PRIOR : /*EMPT*/ { mout(MBOOLEANKONST);
735 moutIval(FALSE);}
736 | HPRIOR { mout(MBOOLEANKONST);
737 moutIval(TRUE);}
738 ;
739 /* GRAMATIKK FOR SETNINGER OG DEKLARASJONER */
740 MODULSTATEMENT : HWHILE
741 EXPRESSION
742 HDO { STOPOBSBLOCK(); mout(MWHILE);
743 OBSBLOCK();}
744 BLOCK { MBEEENDBLOCK(); mout(MENDWHILE);
745 $$=STATEMENT;}
746 | HIF
747 EXPRESSION
748 HTHEN { STOPOBSBLOCK(); mout(MIF);
749 OBSBLOCK();}
750 BLOCK { MBEEENDBLOCK();}
751 MBEE_ELSE_PART { mout(MENDIF);
752 $$=STATEMENT;}
753 | HFOR
754 HIDENTIFIER
755 HASSIGN { STOPOBSBLOCK(); mout(MIDENTIFIER);
756 moutId($2);}
757 FOR_LIST
758 HDO { beginBlock(KFOR);
759 if($3==HASSIGNVALUE) mout(MFOR);
760 else mout(MFORR);
761 OBSBLOCK(); mout(MFORDO);}
762 BLOCK { MBEEENDBLOCK();
763 endBlock(NULL,CCNO); mout(MENDFOR);
764 $$=STATEMENT;}
765 | GOTO
766 EXPRESSION { mout(MGOTO);
767 STOPOBSBLOCK(); $$=STATEMENT;}
768 | HINSPECT
769 EXPRESSION { mout(MINSPECT);
770 STOPOBSBLOCK();
771 beginBlock(KINSP);}
772 CONN_STATE_R_PT
773 { endBlock(NULL,CCNO);}
774 MBEE_OTWI_CLAUS { mout(MENDINSPECT);
775 $$=STATEMENT;}
776 | HINNER { STOPOBSBLOCK(); mout(MINNER);
777 regInner(); $$=STATEMENT;}
778 | HIDENTIFIER
779 HLABELSEPARATOR
780 { STOPOBSBLOCK();
781 regDecl($1, TLABEL, KSIMPLE, categ); mout(MLABEL);
782 moutId($1);
783 mout(MENDLABEL);}
784 DECLSTATEMENT { if($4<=DECLARATION)
785 { yerror (27);
786 $$=DECLARATION;}
787 else $$=$4;}
788 | EXPRESSION_SIMP
789 HBEGIN
790 { $<ident>$=$1; }
791 IMPORT_SPEC_MODULE
792 { mout(MPRBLOCK);
793 prefquantident=$1;
794 beginBlock(KPRBLK);}
795 MBEE_DECLSTMS
796 HEND { endBlock(NULL,CCNO); mout(MENDPRBLOCK);
797 $$=STATEMENT;}
798 | EXPRESSION_SIMP HBEGIN error HSTATEMENTSEPARATOR
799 MBEE_DECLSTMS HEND { $$=STATEMENT;
800 endBlock(NULL,CCNO); mout(MENDPRBLOCK);}
801 | EXPRESSION_SIMP HBEGIN error HEND
802 { $$=STATEMENT;
803 endBlock(NULL,CCNO); mout(MENDPRBLOCK);}
804
805 | EXPRESSION_SIMP
806 { STOPOBSBLOCK(); $$=STATEMENT;
807 mout(MENDASSIGN);}
808 | ACTIVATOR EXPRESSION SCHEDULE
809 { $$=STATEMENT;
810 mout(MENDSEP);
811 mout(MARGUMENTSEP);
812 mout(MARGUMENTSEP);
813 mout(MARGUMENTSEP);
814 mout(MARGUMENTSEP);
815 mout(MARGUMENTSEP);
816 mout(MARGUMENTSEP);
817 mout(MARGUMENT);
818 moutId(activateid);
819 mout(MENDASSIGN);}
820 | HBEGIN
821 { STOPOBSBLOCK();
822 OBSBLOCK();}
823 MBEE_DECLSTMS
824 HEND { MBEEENDBLOCK(); $$=STATEMENT;}
825 | MBEE_TYPE HPROCEDURE
826 HIDENTIFIER
827 { MBEENEWBLOCK(); mout(MPROCEDURE);
828 regDecl($3, type, KPROC, categ);
829 beginBlock(KPROC);}
830 HEADING BLOCK { endBlock(NULL,CCNO); $$=DECLARATION;
831 mout(MENDPROCEDURE);}
832 | HIDENTIFIER
833 HCLASS
834 NO_TYPE
835 { $<ident>$=$1; }
836 IMPORT_SPEC_MODULE
837 HIDENTIFIER
838 { prefquantident=$1;
839 mout(MCLASS);
840 regDecl($6, TNOTY, KCLASS, categ);
841 beginBlock(KCLASS);}
842 HEADING
843 BLOCK { endBlock(NULL,CCNO); $$=DECLARATION;
844 mout(MENDCLASS);}
845 | HCLASS
846 NO_TYPE
847 HIDENTIFIER
848 { prefquantident=0;
849 MBEENEWBLOCK(); mout(MCLASS);
850 regDecl($3, TNOTY, KCLASS, categ);
851 beginBlock(KCLASS);}
852 HEADING
853 BLOCK { endBlock(NULL,CCNO); $$=DECLARATION;
854 mout(MENDCLASS);}
855 | EXT_DECLARATION { $$=EXTDECLARATION;}
856 | /*EMPT*/{ STOPOBSBLOCK(); $$=EMPTYSTATEMENT;}
857 ;
858 IMPORT_SPEC_MODULE: { MBEENEWBLOCK();
859 kind=KCLASS;
860 if($<ident>0==simsetident &&
861 findDecl(simsetident,cblock,FALSE)==NULL)
862 lesinn_external_spec(simsetident,
863 SIMSETATRFILE, kind);
864 if($<ident>0==simulationident && findDecl(
865 simulationident,cblock,FALSE)==NULL)
866 lesinn_external_spec(simulationident,
867 SIMULATIONATRFILE, kind);
868 if(($<ident>0==fileident && findDecl(
869 fileident,cblock,FALSE)==NULL) ||
870 ($<ident>0==outfileident && findDecl(
871 outfileident,cblock,FALSE)==NULL) ||
872 ($<ident>0==infileident && findDecl(
873 infileident,cblock,FALSE)==NULL) ||
874 ($<ident>0==directfileident && findDecl(
875 directfileident,cblock,FALSE)==NULL) ||
876 ($<ident>0==printfileident && findDecl(
877 printfileident,cblock,FALSE)==NULL) ||
878 ($<ident>0==bytefileident && findDecl(
879 bytefileident,cblock,FALSE)==NULL) ||
880 ($<ident>0==inbytefileident && findDecl(
881 inbytefileident,cblock,FALSE)==NULL) ||
882 ($<ident>0==outbytefileident && findDecl(
883 outbytefileident,cblock,FALSE)==NULL) ||
884 ($<ident>0==directbytefileident && findDecl(
885 directbytefileident,cblock,FALSE)==NULL))
886 lesinn_external_spec(fileident,
887 FILEATRFILE, kind);}
888 ;
889 DECLSTATEMENT : MODULSTATEMENT
890 | TYPE
891 HIDENTIFIER
892 MBEE_CONSTANT
893 HPAREXPSEPARATOR
894 { MBEENEWBLOCK();
895 kind=KSIMPLE;
896 regDecl($2, type, KSIMPLE, categ);
897 categ=CLOCAL;}
898 IDENTIFIER_LISTC { $$=DECLARATION;}
899 | TYPE
900 HIDENTIFIER
901 MBEE_CONSTANT
902 { MBEENEWBLOCK();
903 regDecl($2, type, KSIMPLE, categ);
904 categ=CLOCAL; $$=DECLARATION;}
905 | MBEE_TYPE
906 HARRAY { MBEENEWBLOCK();
907 kind=KARRAY;}
908 ARR_SEGMENT_LIST { $$=DECLARATION;}
909 | HSWITCH
910 HIDENTIFIER
911 HASSIGN { MBEENEWBLOCK(); mout(MIDENTIFIER);
912 moutId($2);
913 regDecl($2, TLABEL, KARRAY, categ);}
914 SWITCH_LIST { $$=DECLARATION;
915 mout(MSWITCH);
916 mout(MENDSWITCH);}
917 ;
918 BLOCK : DECLSTATEMENT { if($1<=DECLARATION)yerror (29);}
919 | HBEGIN MBEE_DECLSTMS HEND
920 | HBEGIN error HSTATEMENTSEPARATOR MBEE_DECLSTMS HEND
921 | HBEGIN error HEND
922 ;
923 MBEE_DECLSTMS : MBEE_DECLSTMSU { if($1<=DECLARATION)yerror (28);
924 $$=$1;}
925 ;
926 MBEE_DECLSTMSU : DECLSTATEMENT { $$=$1;}
927 | MBEE_DECLSTMSU
928 HSTATEMENTSEPARATOR
929 DECLSTATEMENT { if($1>=STATEMENT && $3<=DECLARATION)
930 yerror (26);
931 $$=$3;}
932 ;
933 MODULS : MODULSTATEMENT { if($1==DECLARATION)
934 {separat_comp=TRUE;gettimestamp();}
935 $$=$1;}
936 | MODULS HSTATEMENTSEPARATOR MODULSTATEMENT
937 { if($1>=STATEMENT && $3<=DECLARATION)
938 yerror (26);else
939 if($1>=STATEMENT
940 && $3!=EMPTYSTATEMENT)yerror (25);
941 if(separat_comp && $3==STATEMENT)
942 yerror (25);
943 if($3==DECLARATION && !separat_comp)
944 {separat_comp=TRUE;gettimestamp();}
945 $$=$3;}
946 ;
947 /* GRAMATIKK FOR DEL AV DEKLARASJONER */
948 ARR_SEGMENT_LIST: ARR_SEGMENT
949 | ARR_SEGMENT_LIST
950 HPAREXPSEPARATOR
951 ARR_SEGMENT
952 ;
953 ARR_SEGMENT : ARRAY_SEGMENT
954 HBEGPAR
955 BAUND_PAIR_LIST HENDPAR { mout(MARRAY);
956 mout(MENDARRAY);
957 setArrayDim($3);}
958 ;
959 ARRAY_SEGMENT : ARRAY_SEGMENT_EL { mout(MENDSEP);
960 mout(MARRAYSEP);}
961
962 | ARRAY_SEGMENT_EL
963 HPAREXPSEPARATOR
964 ARRAY_SEGMENT { mout(MARRAYSEP);}
965 ;
966 ARRAY_SEGMENT_EL: HIDENTIFIER { mout(MIDENTIFIER);
967 moutId($1);
968 regDecl($1, type, kind, categ);
969 if(lastArray==NULL)
970 lastArray=cblock->lastparloc;}
971 ;
972 BAUND_PAIR_LIST : BAUND_PAIR { mout(MENDSEP);
973 mout(MBOUNDSEP);
974 $$=1;}
975 | BAUND_PAIR
976 HPAREXPSEPARATOR
977 BAUND_PAIR_LIST { mout(MBOUNDSEP);
978 $$=$3+1;}
979 ;
980 BAUND_PAIR : EXPRESSION
981 HLABELSEPARATOR
982 EXPRESSION { mout(MBOUNDPARSEP);}
983 ;
984 SWITCH_LIST : EXPRESSION { mout(MENDSEP);
985 mout(MSWITCHSEP);}
986 | EXPRESSION
987 HPAREXPSEPARATOR
988 SWITCH_LIST { mout(MSWITCHSEP);}
989 ;
990 HEADING : MBEE_FMAL_PAR_P HSTATEMENTSEPARATOR { kind=KNOKD;}
991 MBEE_MODE_PART { categ=CSPEC;}
992 MBEE_SPEC_PART { kind=KNOKD;}
993 MBEE_PROT_PART { categ=CVIRT;}
994 MBEE_VIRT_PART
995 { categ=CLOCAL;}
996 ;
997 MBEE_FMAL_PAR_P : /*EMPT*/
998 | FMAL_PAR_PART
999 ;
1000 FMAL_PAR_PART : HBEGPAR NO_TYPE
1001 MBEE_LISTV HENDPAR
1002 ;
1003 MBEE_LISTV : /*EMPT*/
1004 | LISTV
1005 ;
1006 LISTV : HIDENTIFIER { regDecl($1, type, KNOKD, CDEFLT);}
1007 | FPP_CATEG HDOTDOTDOT { regDecl(varargsid, TVARARGS, KNOKD, categ);}
1008 | HIDENTIFIER { regDecl($1, type, KNOKD, CDEFLT);}
1009 HPAREXPSEPARATOR LISTV
1010 | FPP_SPEC
1011 | FPP_SPEC
1012 HPAREXPSEPARATOR LISTV
1013 ;
1014 FPP_HEADING : HBEGPAR NO_TYPE
1015 FPP_MBEE_LISTV HENDPAR
1016 ;
1017 FPP_MBEE_LISTV : /*EMPT*/
1018 | FPP_LISTV
1019 ;
1020 FPP_LISTV : FPP_CATEG HDOTDOTDOT { regDecl(varargsid, TVARARGS, KNOKD, categ);}
1021 | FPP_SPEC
1022 | FPP_SPEC
1023 HPAREXPSEPARATOR LISTV
1024 ;
1025 FPP_SPEC : FPP_CATEG SPECIFIER HIDENTIFIER
1026 { regDecl($3, type, kind, categ);}
1027 | FPP_CATEG FPP_PROC_DECL_IN_SPEC
1028 ;
1029 FPP_CATEG : HNAME HLABELSEPARATOR
1030 { categ=CNAME;}
1031 | HVALUE HLABELSEPARATOR
1032 { categ=CVALUE;}
1033 | HVAR HLABELSEPARATOR
1034 { categ=CVAR;}
1035 | /*EMPT*/ { categ=CDEFLT;}
1036 ;
1037 FPP_PROC_DECL_IN_SPEC: MBEE_TYPE HPROCEDURE
1038 HIDENTIFIER
1039 { $<ival>$=categ;
1040 regDecl($3, type, KPROC, categ);
1041 beginBlock(KPROC);}
1042 FPP_HEADING
1043 { categ=$<ival>4; /* M} settes tilbake*/}
1044 { endBlock(NULL,CCNO);}
1045 ;
1046 IDENTIFIER_LISTV: HIDENTIFIER { regDecl($1, type, kind, categ);}
1047 | HDOTDOTDOT { regDecl(varargsid, TVARARGS, kind, categ);}
1048 | HIDENTIFIER { regDecl($1, type, kind, categ);}
1049 HPAREXPSEPARATOR IDENTIFIER_LISTV
1050 ;
1051 MBEE_MODE_PART : /*EMPT*/
1052 | MODE_PART
1053 ;
1054 MODE_PART : NAME_PART
1055 | VALUE_PART
1056 | VAR_PART
1057 | NAME_PART VALUE_PART
1058 | VALUE_PART NAME_PART
1059 | NAME_PART VAR_PART
1060 | VAR_PART NAME_PART
1061 | VALUE_PART VAR_PART
1062 | VAR_PART VALUE_PART
1063 | VAR_PART NAME_PART VALUE_PART
1064 | NAME_PART VAR_PART VALUE_PART
1065 | NAME_PART VALUE_PART VAR_PART
1066 | VAR_PART VALUE_PART NAME_PART
1067 | VALUE_PART VAR_PART NAME_PART
1068 | VALUE_PART NAME_PART VAR_PART
1069 ;
1070 NAME_PART : HNAME { categ=CNAME;}
1071 IDENTIFIER_LISTV
1072 HSTATEMENTSEPARATOR
1073 ;
1074 VAR_PART : HVAR { categ=CVAR;}
1075 IDENTIFIER_LISTV
1076 HSTATEMENTSEPARATOR
1077 ;
1078 VALUE_PART : HVALUE { categ=CVALUE;}
1079 IDENTIFIER_LISTV HSTATEMENTSEPARATOR
1080 ;
1081 MBEE_SPEC_PART : /*EMPT*/
1082 | SPEC_PART
1083 ;
1084 SPEC_PART : ONE_SPEC
1085 | SPEC_PART ONE_SPEC
1086 ;
1087 ONE_SPEC : SPECIFIER IDENTIFIER_LIST HSTATEMENTSEPARATOR
1088 | NO_TYPE HPROCEDURE HIDENTIFIER HOBJRELOPERATOR
1089 { if($4!=HIS) yerror (8);}
1090 PROC_DECL_IN_SPEC HSTATEMENTSEPARATOR
1091 | FPP_PROC_DECL_IN_SPEC HSTATEMENTSEPARATOR
1092 | MBEE_TYPE HPROCEDURE HIDENTIFIER HSTATEMENTSEPARATOR
1093 { yerror (45);}
1094 | MBEE_TYPE HPROCEDURE HIDENTIFIER HPAREXPSEPARATOR
1095 IDENTIFIER_LIST HSTATEMENTSEPARATOR
1096 { yerror (45);}
1097 ;
1098 SPECIFIER : TYPE { kind=KSIMPLE;}
1099 | MBEE_TYPE
1100 HARRAY { kind=KARRAY;}
1101 | HLABEL { type=TLABEL;
1102 kind=KSIMPLE;}
1103 | HSWITCH { type=TLABEL;
1104 kind=KARRAY;}
1105 ;
1106 PROC_DECL_IN_SPEC: MBEE_TYPE HPROCEDURE
1107 HIDENTIFIER
1108 { $<ival>$=categ;
1109 regDecl($3, type, KPROC, categ);
1110 beginBlock(KPROC);}
1111 HEADING
1112 { categ=$<ival>4; /* M} settes tilbake*/}
1113 MBEE_BEGIN_END
1114 { endBlock(NULL,CCNO);}
1115 ;
1116 MBEE_BEGIN_END : /* EMPTY */
1117 | HBEGIN HEND
1118 ;
1119 MBEE_PROT_PART : /*EMPT*/
1120 | PROTECTION_PART
1121 ;
1122 PROTECTION_PART : PROT_SPECIFIER IDENTIFIER_LIST
1123 HSTATEMENTSEPARATOR
1124 | PROTECTION_PART PROT_SPECIFIER
1125 IDENTIFIER_LIST HSTATEMENTSEPARATOR
1126 ;
1127 PROT_SPECIFIER : HHIDDEN { categ=CHIDEN;}
1128 | HPROTECTED { categ=CPROT;}
1129 | HHIDDEN
1130 HPROTECTED { categ=CHIPRO;}
1131 | HPROTECTED
1132 HHIDDEN { categ=CHIPRO;}
1133 ;
1134 MBEE_VIRT_PART : /*EMPT*/
1135 | VIRTUAL_PART
1136 ;
1137 VIRTUAL_PART : HVIRTUAL
1138 HLABELSEPARATOR
1139 MBEE_SPEC_PART
1140 ;
1141 IDENTIFIER_LIST : HIDENTIFIER { regDecl($1, type, kind, categ);}
1142 | IDENTIFIER_LIST HPAREXPSEPARATOR
1143 HIDENTIFIER { regDecl($3, type, kind, categ);}
1144 ;
1145 IDENTIFIER_LISTC: HIDENTIFIER
1146 MBEE_CONSTANT { regDecl($1, type, kind, categ);
1147 categ=CLOCAL;}
1148 | IDENTIFIER_LISTC HPAREXPSEPARATOR
1149 HIDENTIFIER
1150 MBEE_CONSTANT { regDecl($3, type, kind, categ);
1151 categ=CLOCAL;}
1152 ;
1153 MBEE_CONSTANT : /* EMPTY */
1154 | HVALRELOPERATOR
1155 { MBEENEWBLOCK();
1156 if($1!=HEQ) yerror (8);
1157 if(type==TREF)yerror (7);
1158 categ=CCONSTU;
1159 mout(MIDENTIFIER);
1160 moutId($<token>0);}
1161 EXPRESSION { mout(MASSIGN);
1162 mout(MCONST);}
1163 ;
1164
1165 /* GRAMATIKK FOR UTTRYKK */
1166 EXPRESSION : EXPRESSION_SIMP {}
1167 | HIF
1168 EXPRESSION
1169 HTHEN
1170 EXPRESSION
1171 HELSE
1172 EXPRESSION { mout(MELSEE);
1173 mout(MIFE);}
1174 ;
1175 EXPRESSION_SIMP : EXPRESSION_SIMP
1176 HASSIGN
1177 EXPRESSION { if($2==HASSIGNREF)mout(MASSIGNR);
1178 else mout(MASSIGN);$$=NULL;}
1179 |
1180
1181 EXPRESSION_SIMP
1182 HCONC
1183 EXPRESSION_SIMP { mout(MCONC);$$=NULL;}
1184 | EXPRESSION_SIMP HOR
1185 HELSE
1186 EXPRESSION_SIMP
1187 %prec HORELSE { mout(MORELSEE);$$=NULL;}
1188 | EXPRESSION_SIMP HAND
1189 HTHEN
1190 EXPRESSION_SIMP
1191 %prec HANDTHEN { mout(MANDTHENE);$$=NULL;}
1192 | EXPRESSION_SIMP
1193 HEQV EXPRESSION_SIMP { mout(MEQV);$$=NULL;}
1194 | EXPRESSION_SIMP
1195 HIMP EXPRESSION_SIMP { mout(MIMP);$$=NULL;}
1196 | EXPRESSION_SIMP
1197 HOR EXPRESSION_SIMP { mout(MOR);$$=NULL;}
1198 | EXPRESSION_SIMP
1199 HAND EXPRESSION_SIMP { mout(MAND);$$=NULL;}
1200 | HNOT EXPRESSION_SIMP { mout(MNOT);$$=NULL;}
1201 | EXPRESSION_SIMP
1202 HVALRELOPERATOR
1203 EXPRESSION_SIMP
1204 { switch($2)
1205 { case HEQ: mout(MEQ);break;
1206 case HNE: mout(MNE);break;
1207 case HLT: mout(MLT);break;
1208 case HLE: mout(MLE);break;
1209 case HGT: mout(MGT);break;
1210 case HGE: mout(MGE);break;
1211 }$$=NULL;}
1212 | EXPRESSION_SIMP
1213 HREFRELOPERATOR
1214 EXPRESSION_SIMP
1215 { if($2==HNER) mout(MNER);
1216 else mout(MEQR);$$=NULL;}
1217 | EXPRESSION_SIMP
1218 HOBJRELOPERATOR
1219 EXPRESSION_SIMP
1220 { if($2==HIS) mout(MIS);
1221 else mout(MINS);$$=NULL;}
1222 | HTERMOPERATOR
1223 EXPRESSION_SIMP %prec UNEAR
1224 { if($1==HADD) mout(MUADD);
1225 else mout(MUSUB);$$=NULL;}
1226 | EXPRESSION_SIMP
1227 HTERMOPERATOR
1228 EXPRESSION_SIMP
1229 { if($2==HADD) mout(MADD);
1230 else mout(MSUB);$$=NULL;}
1231 | EXPRESSION_SIMP
1232 HFACTOROPERATOR
1233 EXPRESSION_SIMP
1234 { if($2==HMUL) mout(MMUL); else
1235 if($2==HDIV) mout(MDIV);
1236 else mout(MINTDIV);$$=NULL;}
1237 | EXPRESSION_SIMP
1238 HPRIMARYOPERATOR
1239 EXPRESSION_SIMP { mout(MPRIMARY);$$=NULL;}
1240 | HBEGPAR
1241 EXPRESSION HENDPAR { mout(MNOOP);$$=NULL;}
1242 | HTEXTKONST { mout(MTEXTKONST);
1243 moutTval($1);$$=NULL;}
1244 | HCHARACTERKONST { mout(MCHARACTERKONST);
1245 moutIval($1);$$=NULL;}
1246 | HREALKONST { mout(MREALKONST);
1247 moutRval($1);$$=NULL;}
1248 | HINTEGERKONST { mout(MINTEGERKONST);
1249 moutIval($1);$$=NULL;}
1250 | HBOOLEANKONST { mout(MBOOLEANKONST);
1251 moutIval($1);$$=NULL;}
1252 | HNONE { mout(MNONE);$$=NULL;}
1253 | HIDENTIFIER
1254 { $<ident>$=$1;}
1255 MBEE_ARG_R_PT
1256 | HTHIS HIDENTIFIER { mout(MTHIS);
1257 moutId($2);$$=NULL;}
1258 | HNEW
1259 HIDENTIFIER
1260 ARG_R_PT { mout(MNEWARG);
1261 moutId($2);$$=NULL;}
1262 | EXPRESSION_SIMP
1263 HDOT
1264 EXPRESSION_SIMP { mout(MDOT);$$=NULL;}
1265 | EXPRESSION_SIMP
1266 HQUA HIDENTIFIER { mout(MQUA);
1267 moutId($3);$$=NULL;}
1268 ;
1269 ARG_R_PT : /*EMPTY*/ { mout(MENDSEP);}
1270 | HBEGPAR
1271 ARGUMENT_LIST HENDPAR
1272 ;
1273 MBEE_ARG_R_PT : /*EMPTY*/ { mout(MIDENTIFIER);
1274 moutId($<ident>0);
1275 $$=$<ident>0;}
1276 | HBEGPAR
1277 ARGUMENT_LIST HENDPAR { mout(MARGUMENT);
1278 moutId($<ident>0);}
1279 ;
1280 ARGUMENT_LIST : EXPRESSION { mout(MENDSEP);
1281 mout(MARGUMENTSEP);}
1282 | EXPRESSION
1283 HPAREXPSEPARATOR
1284 ARGUMENT_LIST { mout(MARGUMENTSEP);}
1285 ;
1286 %%
1287 ]])
1288
1289 # Pass plenty of options, to exercise plenty of code, even if we
1290 # don't actually check the output. But SEGV is watching us, and
1291 # so might do dmalloc.
1292 AT_CHECK([[bison --verbose --defines input.y]], 0, [],
1293 [[input.y contains 78 shift/reduce conflicts and 10 reduce/reduce conflicts.
1294 ]])
1295
1296 AT_CHECK([[grep '^State.*contains' input.output]], 0,
1297 [[State 64 contains 14 shift/reduce conflicts.
1298 State 164 contains 1 shift/reduce conflict.
1299 State 201 contains 33 shift/reduce conflicts and 4 reduce/reduce conflicts.
1300 State 206 contains 1 shift/reduce conflict.
1301 State 240 contains 1 shift/reduce conflict.
1302 State 335 contains 9 shift/reduce conflicts and 2 reduce/reduce conflicts.
1303 State 356 contains 1 shift/reduce conflict.
1304 State 360 contains 9 shift/reduce conflicts and 2 reduce/reduce conflicts.
1305 State 427 contains 9 shift/reduce conflicts and 2 reduce/reduce conflicts.
1306 ]])
1307
1308 AT_CLEANUP
bison