Thank the developer of the initial push parser implementation.
[bison.git] / tests / calc.at
0 / 683 (  0%)
CommitLineData
1# Simple calculator. -*- Autotest -*-
2
3# Copyright (C) 2000-2010 Free Software Foundation, Inc.
4
5# This program is free software: you can redistribute it and/or modify
6# it under the terms of the GNU General Public License as published by
7# the Free Software Foundation, either version 3 of the License, or
8# (at your option) any later version.
9#
10# This program is distributed in the hope that it will be useful,
11# but WITHOUT ANY WARRANTY; without even the implied warranty of
12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13# GNU General Public License for more details.
14#
15# You should have received a copy of the GNU General Public License
16# along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18## ---------------------------------------------------- ##
19## Compile the grammar described in the documentation. ##
20## ---------------------------------------------------- ##
21
22
23# ------------------------- #
24# Helping Autotest macros. #
25# ------------------------- #
26
27
28# _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
29# -----------------------------------------------
30# Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
31# `calc-lex.cc'.
32#
33# Don't call this macro directly, because it contains some occurrences
34# of `$1' etc. which will be interpreted by m4. So you should call it
35# with $1, $2, and $3 as arguments, which is what AT_DATA_CALC_Y does.
36m4_define([_AT_DATA_CALC_Y],
37[m4_if([$1$2$3], $[1]$[2]$[3], [],
38 [m4_fatal([$0: Invalid arguments: $@])])dnl
39m4_pushdef([AT_CALC_LEX],
40[[#include <ctype.h>
41
42int ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[);
43static int get_char (]AT_LEX_FORMALS[);
44static void unget_char (]AT_LEX_PRE_FORMALS[ int c);
45
46]AT_LOCATION_IF([
47static YYLTYPE last_yylloc;
48])[
49static int
50get_char (]AT_LEX_FORMALS[)
51{
52 int res = getc (input);
53 ]AT_USE_LEX_ARGS[;
54]AT_LOCATION_IF([
55 last_yylloc = AT_LOC;
56 if (res == '\n')
57 {
58 AT_LOC.last_line++;
59 AT_LOC.last_column = 1;
60 }
61 else
62 AT_LOC.last_column++;
63])[
64 return res;
65}
66
67static void
68unget_char (]AT_LEX_PRE_FORMALS[ int c)
69{
70 ]AT_USE_LEX_ARGS[;
71]AT_LOCATION_IF([
72 /* Wrong when C == `\n'. */
73 AT_LOC = last_yylloc;
74])[
75 ungetc (c, input);
76}
77
78static int
79read_signed_integer (]AT_LEX_FORMALS[)
80{
81 int c = get_char (]AT_LEX_ARGS[);
82 int sign = 1;
83 int n = 0;
84
85 ]AT_USE_LEX_ARGS[;
86 if (c == '-')
87 {
88 c = get_char (]AT_LEX_ARGS[);
89 sign = -1;
90 }
91
92 while (isdigit (c))
93 {
94 n = 10 * n + (c - '0');
95 c = get_char (]AT_LEX_ARGS[);
96 }
97
98 unget_char (]AT_LEX_PRE_ARGS[ c);
99
100 return sign * n;
101}
102
103
104/*---------------------------------------------------------------.
105| Lexical analyzer returns an integer on the stack and the token |
106| NUM, or the ASCII character read if not a number. Skips all |
107| blanks and tabs, returns 0 for EOF. |
108`---------------------------------------------------------------*/
109
110int
111]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[)
112{
113 static int init = 1;
114 int c;
115
116 if (init)
117 {
118 init = 0;
119]AT_LOCATION_IF([
120 AT_LOC.last_column = 1;
121 AT_LOC.last_line = 1;
122])[
123 }
124
125]AT_LOCATION_IF([
126 AT_LOC.first_column = AT_LOC.last_column;
127 AT_LOC.first_line = AT_LOC.last_line;
128])[
129
130 /* Skip white space. */
131 while ((c = get_char (]AT_LEX_ARGS[)) == ' ' || c == '\t')
132 {
133]AT_LOCATION_IF(
134[ AT_LOC.first_column = AT_LOC.last_column;
135 AT_LOC.first_line = AT_LOC.last_line;
136])[
137 }
138
139 /* process numbers */
140 if (c == '.' || isdigit (c))
141 {
142 unget_char (]AT_LEX_PRE_ARGS[ c);
143 ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
144 return ]AT_TOKEN_PREFIX[NUM;
145 }
146
147 /* Return end-of-file. */
148 if (c == EOF)
149 return ]AT_TOKEN_PREFIX[CALC_EOF;
150
151 /* Return single chars. */
152 return c;
153}
154]])
155
156AT_DATA_GRAMMAR([calc.y],
157[[/* Infix notation calculator--calc */
158]$4
159AT_SKEL_CC_IF(
160[%define global_tokens_and_yystype])[
161%code requires {
162/* Exercise pre-prologue dependency to %union. */
163typedef int semantic_value;
164}
165
166/* Exercise %union. */
167%union
168{
169 semantic_value ival;
170};
171
172%code provides {
173#include <stdio.h>
174/* The input. */
175extern FILE *input;]AT_SKEL_CC_IF([[
176#ifndef YYLTYPE
177# define YYLTYPE ]AT_NAME_PREFIX[::location
178#endif
179#define first_line begin.line
180#define first_column begin.column
181#define last_line end.line
182#define last_column end.column]])[
183}
184
185%code {
186#include <stdlib.h>
187#include <string.h>
188#if HAVE_UNISTD_H
189# include <unistd.h>
190#else
191# undef alarm
192# define alarm(seconds) /* empty */
193#endif
194#define USE(Var)
195
196FILE *input;
197static semantic_value global_result = 0;
198static int global_count = 0;
199static int power (int base, int exponent);
200]AT_SKEL_CC_IF(,
201[/* yyerror receives the location if:
202 - %location & %pure & %glr
203 - %location & %pure & %yacc & %parse-param. */
204static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
205 AT_PARAM_IF([semantic_value *result, int *count, ])
206 const char *s
207 );])[
208int yylex (]AT_LEX_FORMALS[);
209}
210
211]AT_SKEL_CC_IF([AT_LOCATION_IF([
212/* The lalr1.cc skeleton, for backward compatibility, defines
213 a constructor for position that initializes the filename. The
214 glr.cc skeleton does not (and in fact cannot: location/position
215 are stored in a union, from which objects with constructors are
216 excluded in C++). */
217%initial-action {
218 @$.initialize (0);
219}
220])])[
221
222/* Bison Declarations */
223%token CALC_EOF 0 "end of input"
224%token <ival> NUM "number"
225%type <ival> exp
226
227%nonassoc '=' /* comparison */
228%left '-' '+'
229%left '*' '/'
230%precedence NEG /* negation--unary minus */
231%right '^' /* exponentiation */
232
233/* Grammar follows */
234%%
235input:
236 line
237| input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
238;
239
240line:
241 '\n'
242| exp '\n' { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
243;
244
245exp:
246 NUM { $$ = $1; }
247| exp '=' exp
248 {
249 if ($1 != $3)
250 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
251 $$ = $1;
252 }
253| exp '+' exp { $$ = $1 + $3; }
254| exp '-' exp { $$ = $1 - $3; }
255| exp '*' exp { $$ = $1 * $3; }
256| exp '/' exp { $$ = $1 / $3; }
257| '-' exp %prec NEG { $$ = -$2; }
258| exp '^' exp { $$ = power ($1, $3); }
259| '(' exp ')' { $$ = $2; }
260| '(' error ')' { $$ = 1111; yyerrok; }
261| '!' { $$ = 0; YYERROR; }
262| '-' error { $$ = 0; YYERROR; }
263;
264%%
265
266]AT_SKEL_CC_IF(
267[/* A C++ error reporting function. */
268void
269AT_NAME_PREFIX::parser::error (AT_LOCATION_IF([const location& l, ])const std::string& m)
270{
271 std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
272}
273
274int
275yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
276{
277 AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
278#if YYDEBUG
279 parser.set_debug_level (1);
280#endif
281 return parser.parse ();
282}
283],
284[static void
285yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
286 AT_PARAM_IF([semantic_value *result, int *count, ])
287 const char *s)
288{
289AT_PARAM_IF([(void) result; (void) count;])
290AT_YYERROR_SEES_LOC_IF([
291 fprintf (stderr, "%d.%d",
292 AT_LOC.first_line, AT_LOC.first_column);
293 if (AT_LOC.first_line != AT_LOC.last_line)
294 fprintf (stderr, "-%d.%d",
295 AT_LOC.last_line, AT_LOC.last_column - 1);
296 else if (AT_LOC.first_column != AT_LOC.last_column - 1)
297 fprintf (stderr, "-%d",
298 AT_LOC.last_column - 1);
299 fprintf (stderr, ": ");])
300 fprintf (stderr, "%s\n", s);
301}])[
302
303]AT_DEFINES_IF(, [AT_CALC_LEX])[
304
305static int
306power (int base, int exponent)
307{
308 int res = 1;
309 if (exponent < 0)
310 exit (3);
311 for (/* Niente */; exponent; --exponent)
312 res *= base;
313 return res;
314}
315
316
317int
318main (int argc, const char **argv)
319{
320 semantic_value result = 0;
321 int count = 0;
322 int status;
323
324 /* This used to be alarm (10), but that isn't enough time for
325 a July 1995 vintage DEC Alphastation 200 4/100 system,
326 according to Nelson H. F. Beebe. 100 seconds is enough. */
327 alarm (100);
328
329 if (argc == 2)
330 input = fopen (argv[1], "r");
331 else
332 input = stdin;
333
334 if (!input)
335 {
336 perror (argv[1]);
337 return 3;
338 }
339
340]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
341[ yydebug = 1;])])[
342 status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
343 fclose (input);
344 if (global_result != result)
345 abort ();
346 if (global_count != count)
347 abort ();
348 return status;
349}
350]])
351AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
352[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
353
354]AT_CALC_LEX])])
355m4_popdef([AT_CALC_LEX])
356])# _AT_DATA_CALC_Y
357
358
359# AT_DATA_CALC_Y([BISON-OPTIONS])
360# -------------------------------
361# Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
362# `calc-lex.cc'.
363m4_define([AT_DATA_CALC_Y],
364[_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
365])
366
367
368
369# _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
370# --------------------------------------------------------
371# Run `calc' on INPUT and expect no STDOUT nor STDERR.
372#
373# If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
374#
375# NUM-STDERR-LINES is the number of expected lines on stderr.
376# Currently this is ignored, though, since the output format is fluctuating.
377#
378# We don't count GLR's traces yet, since its traces are somewhat
379# different from LALR's.
380m4_define([_AT_CHECK_CALC],
381[AT_DATA([[input]],
382[[$2
383]])
384AT_PARSER_CHECK([./calc input], 0, [], [stderr])
385])
386
387
388# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
389# [NUM-STDERR-LINES],
390# [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
391# ---------------------------------------------------------
392# Run `calc' on INPUT, and expect a `syntax error' message.
393#
394# If INPUT starts with a slash, it is used as absolute input file name,
395# otherwise as contents.
396#
397# NUM-STDERR-LINES is the number of expected lines on stderr.
398# Currently this is ignored, though, since the output format is fluctuating.
399#
400# If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
401# is correctly output on stderr.
402#
403# If BISON-OPTIONS contains `%define parse.error verbose', then make sure the
404# IF-YYERROR-VERBOSE message is properly output after `syntax error, '
405# on STDERR.
406#
407# If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
408# is the number of expected lines on stderr.
409m4_define([_AT_CHECK_CALC_ERROR],
410[m4_bmatch([$3], [^/],
411 [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
412 [AT_DATA([[input]],
413[[$3
414]])
415AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
416
417# Normalize the observed and expected error messages, depending upon the
418# options.
419# 1. Remove the traces from observed.
420sed '/^Starting/d
421/^Entering/d
422/^Stack/d
423/^Reading/d
424/^Reducing/d
425/^Return/d
426/^Shifting/d
427/^state/d
428/^Cleanup:/d
429/^Error:/d
430/^Next/d
431/^Now/d
432/^Discarding/d
433/ \$[[0-9$]]* = /d
434/^yydestructor:/d' stderr >at-stderr
435mv at-stderr stderr
436# 2. Create the reference error message.
437AT_DATA([[expout]],
438[$5
439])
440# 3. If locations are not used, remove them.
441AT_YYERROR_SEES_LOC_IF([],
442[[sed 's/^[-0-9.]*: //' expout >at-expout
443mv at-expout expout]])
444# 4. If error-verbose is not used, strip the`, unexpected....' part.
445m4_bmatch([$1], [%define parse.error verbose], [],
446[[sed 's/syntax error, .*$/syntax error/' expout >at-expout
447mv at-expout expout]])
448# 5. Check
449AT_CHECK([cat stderr], 0, [expout])
450])
451
452
453# AT_CHECK_CALC([BISON-OPTIONS, [EXPECTED-TO-FAIL]])
454# --------------------------------------------------
455# Start a testing chunk which compiles `calc' grammar with
456# BISON-OPTIONS, and performs several tests over the parser.
457# However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.
458m4_define([AT_CHECK_CALC],
459[# We use integers to avoid dependencies upon the precision of doubles.
460AT_SETUP([Calculator $1])
461
462m4_ifval([$2], [AT_CHECK([exit 77])])
463
464AT_BISON_OPTION_PUSHDEFS([$1])
465
466AT_DATA_CALC_Y([$1])
467AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
468
469# Test the priorities.
470_AT_CHECK_CALC([$1],
471[1 + 2 * 3 = 7
4721 + 2 * -3 = -5
473
474-1^2 = -1
475(-1)^2 = 1
476
477---1 = -1
478
4791 - 2 - 3 = -4
4801 - (2 - 3) = 2
481
4822^2^3 = 256
483(2^2)^3 = 64],
484 [842])
485
486# Some syntax errors.
487_AT_CHECK_CALC_ERROR([$1], [1], [0 0], [15],
488 [1.3: syntax error, unexpected number])
489_AT_CHECK_CALC_ERROR([$1], [1], [1//2], [20],
490 [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
491_AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
492 [1.1: syntax error, unexpected $undefined])
493_AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [30],
494 [1.7: syntax error, unexpected '='])
495_AT_CHECK_CALC_ERROR([$1], [1],
496 [
497+1],
498 [20],
499 [2.1: syntax error, unexpected '+'])
500# Exercise error messages with EOF: work on an empty file.
501_AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
502 [1.1: syntax error, unexpected end of input])
503
504# Exercise the error token: without it, we die at the first error,
505# hence be sure to
506#
507# - have several errors which exercise different shift/discardings
508# - (): nothing to pop, nothing to discard
509# - (1 + 1 + 1 +): a lot to pop, nothing to discard
510# - (* * *): nothing to pop, a lot to discard
511# - (1 + 2 * *): some to pop and discard
512#
513# - test the action associated to `error'
514#
515# - check the lookahead that triggers an error is not discarded
516# when we enter error recovery. Below, the lookahead causing the
517# first error is ")", which is needed to recover from the error and
518# produce the "0" that triggers the "0 != 1" error.
519#
520_AT_CHECK_CALC_ERROR([$1], [0],
521 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
522 [250],
523[1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5241.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5251.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5261.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
527calc: error: 4444 != 1])
528
529# The same, but this time exercising explicitly triggered syntax errors.
530# POSIX says the lookahead causing the error should not be discarded.
531_AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [102],
532[1.10: syntax error, unexpected number
533calc: error: 2222 != 1])
534_AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [113],
535[1.4: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5361.12: syntax error, unexpected number
537calc: error: 2222 != 1])
538
539# Check that yyerrok works properly: second error is not reported,
540# third and fourth are. Parse status is succesfull.
541_AT_CHECK_CALC_ERROR([$1], [0], [(* *) + (*) + (*)], [113],
542[1.2: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5431.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5441.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!'])
545
546AT_BISON_OPTION_POPDEFS
547
548AT_CLEANUP
549])# AT_CHECK_CALC
550
551
552
553
554# ------------------------ #
555# Simple LALR Calculator. #
556# ------------------------ #
557
558AT_BANNER([[Simple LALR(1) Calculator.]])
559
560# AT_CHECK_CALC_LALR([BISON-OPTIONS])
561# -----------------------------------
562# Start a testing chunk which compiles `calc' grammar with
563# BISON-OPTIONS, and performs several tests over the parser.
564m4_define([AT_CHECK_CALC_LALR],
565[AT_CHECK_CALC($@)])
566
567AT_CHECK_CALC_LALR()
568
569AT_CHECK_CALC_LALR([%defines])
570AT_CHECK_CALC_LALR([%locations])
571AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
572AT_CHECK_CALC_LALR([%verbose])
573AT_CHECK_CALC_LALR([%yacc])
574AT_CHECK_CALC_LALR([%define parse.error verbose])
575
576AT_CHECK_CALC_LALR([%define api.pure %locations])
577AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations])
578AT_CHECK_CALC_LALR([%define parse.error verbose %locations])
579
580AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
581AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
582
583AT_CHECK_CALC_LALR([%debug])
584AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
585
586AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
587AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
588
589AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
590
591
592# ----------------------- #
593# Simple GLR Calculator. #
594# ----------------------- #
595
596AT_BANNER([[Simple GLR Calculator.]])
597
598# AT_CHECK_CALC_GLR([BISON-OPTIONS])
599# ----------------------------------
600# Start a testing chunk which compiles `calc' grammar with
601# BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
602m4_define([AT_CHECK_CALC_GLR],
603[AT_CHECK_CALC([%glr-parser] $@)])
604
605
606AT_CHECK_CALC_GLR()
607
608AT_CHECK_CALC_GLR([%defines])
609AT_CHECK_CALC_GLR([%locations])
610AT_CHECK_CALC_GLR([%name-prefix "calc"])
611AT_CHECK_CALC_GLR([%verbose])
612AT_CHECK_CALC_GLR([%yacc])
613AT_CHECK_CALC_GLR([%define parse.error verbose])
614
615AT_CHECK_CALC_GLR([%define api.pure %locations])
616AT_CHECK_CALC_GLR([%define parse.error verbose %locations])
617
618AT_CHECK_CALC_GLR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
619
620AT_CHECK_CALC_GLR([%debug])
621AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
622AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
623
624AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
625
626AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
627
628
629# ----------------------------- #
630# Simple LALR1 C++ Calculator. #
631# ----------------------------- #
632
633AT_BANNER([[Simple LALR(1) C++ Calculator.]])
634
635# First let's try using %skeleton
636AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
637
638# AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
639# ---------------------------------------
640# Start a testing chunk which compiles `calc' grammar with
641# the C++ skeleton, and performs several tests over the parser.
642m4_define([AT_CHECK_CALC_LALR1_CC],
643[AT_CHECK_CALC([%language "C++" %defines] $@)])
644
645AT_CHECK_CALC_LALR1_CC([])
646AT_CHECK_CALC_LALR1_CC([%locations])
647AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %name-prefix "calc" %verbose %yacc])
648
649AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
650
651AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
652AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
653
654AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
655
656
657
658# --------------------------- #
659# Simple GLR C++ Calculator. #
660# --------------------------- #
661
662AT_BANNER([[Simple GLR C++ Calculator.]])
663
664# Again, we try also using %skeleton.
665AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
666
667# AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
668# -------------------------------------
669# Start a testing chunk which compiles `calc' grammar with
670# the GLR C++ skeleton, and performs several tests over the parser.
671m4_define([AT_CHECK_CALC_GLR_CC],
672[AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
673
674AT_CHECK_CALC_GLR_CC([])
675AT_CHECK_CALC_GLR_CC([%define parse.error verbose %name-prefix "calc" %verbose %yacc])
676
677AT_CHECK_CALC_GLR_CC([%debug])
678AT_CHECK_CALC_GLR_CC([%define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
679
680AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
681AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
682
683AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])