build: update gnulib and autoconf submodules to latest
[bison.git] / tests / calc.at
0 / 723 (  0%)
CommitLineData
1# Simple calculator. -*- Autotest -*-
2
3# Copyright (C) 2000-2012 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 /* Skip current token, then white spaces. */
126 do
127 {
128]AT_LOCATION_IF(
129[ AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
130 AT_LOC_FIRST_LINE = AT_LOC_LAST_LINE;
131])[
132 }
133 while ((c = get_char (]AT_LEX_ARGS[)) == ' ' || c == '\t');
134
135 /* process numbers */
136 if (c == '.' || isdigit (c))
137 {
138 unget_char (]AT_LEX_PRE_ARGS[ c);
139 ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
140 return NUM;
141 }
142
143 /* Return end-of-file. */
144 if (c == EOF)
145 return CALC_EOF;
146
147 /* Return single chars. */
148 return c;
149}
150]])
151
152AT_DATA_GRAMMAR([calc.y],
153[[/* Infix notation calculator--calc */
154]$4
155AT_SKEL_CC_IF(
156[%define global_tokens_and_yystype])[
157%code requires
158{
159]AT_LOCATION_TYPE_IF([[
160# include <iostream>
161 struct Point
162 {
163 int l;
164 int c;
165 };
166
167 struct Span
168 {
169 Point first;
170 Point last;
171 };
172
173# define YYLLOC_DEFAULT(Current, Rhs, N) \
174 do \
175 if (N) \
176 { \
177 (Current).first = YYRHSLOC (Rhs, 1).first; \
178 (Current).last = YYRHSLOC (Rhs, N).last; \
179 } \
180 else \
181 { \
182 (Current).first = (Current).last = YYRHSLOC (Rhs, 0).last; \
183 } \
184 while (false)
185
186]])[
187 /* Exercise pre-prologue dependency to %union. */
188 typedef int semantic_value;
189}
190
191/* Exercise %union. */
192%union
193{
194 semantic_value ival;
195};
196
197%code provides
198{
199#include <stdio.h>
200/* The input. */
201extern FILE *input;]AT_SKEL_CC_IF([[
202#ifndef YYLTYPE
203# define YYLTYPE ]AT_NAME_PREFIX[::parser::location_type
204#endif
205]])[
206}
207
208%code
209{
210#include <stdlib.h>
211#include <string.h>
212#if HAVE_UNISTD_H
213# include <unistd.h>
214#else
215# undef alarm
216# define alarm(seconds) /* empty */
217#endif
218#define USE(Var)
219
220FILE *input;
221static semantic_value global_result = 0;
222static int global_count = 0;
223static int power (int base, int exponent);
224
225]AT_SKEL_CC_IF(,
226[/* yyerror receives the location if:
227 - %location & %pure & %glr
228 - %location & %pure & %yacc & %parse-param. */
229static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
230 AT_PARAM_IF([semantic_value *result, int *count, ])
231 const char *s
232 );])[
233int yylex (]AT_LEX_FORMALS[);
234}
235
236]AT_SKEL_CC_IF([AT_LOCATION_TYPE_IF([], [
237/* The lalr1.cc skeleton, for backward compatibility, defines
238 a constructor for position that initializes the filename. The
239 glr.cc skeleton does not (and in fact cannot: location/position
240 are stored in a union, from which objects with constructors are
241 excluded in C++. */
242%initial-action {
243 @$.initialize (0);
244}
245])])[
246
247/* Bison Declarations */
248%token CALC_EOF 0 "end of input"
249%token <ival> NUM "number"
250%type <ival> exp
251
252%nonassoc '=' /* comparison */
253%left '-' '+'
254%left '*' '/'
255%left NEG /* negation--unary minus */
256%right '^' /* exponentiation */
257
258/* Grammar follows */
259%%
260input:
261 line
262| input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
263;
264
265line:
266 '\n'
267| exp '\n' { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
268;
269
270exp:
271 NUM { $$ = $1; }
272| exp '=' exp
273 {
274 if ($1 != $3)
275 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
276 $$ = $1;
277 }
278| exp '+' exp { $$ = $1 + $3; }
279| exp '-' exp { $$ = $1 - $3; }
280| exp '*' exp { $$ = $1 * $3; }
281| exp '/' exp { $$ = $1 / $3; }
282| '-' exp %prec NEG { $$ = -$2; }
283| exp '^' exp { $$ = power ($1, $3); }
284| '(' exp ')' { $$ = $2; }
285| '(' error ')' { $$ = 1111; yyerrok; }
286| '!' { $$ = 0; YYERROR; }
287| '-' error { $$ = 0; YYERROR; }
288;
289%%
290
291]AT_SKEL_CC_IF(
292[AT_LOCATION_TYPE_IF([[
293 std::ostream&
294 operator<< (std::ostream& o, const Span& s)
295 {
296 o << s.first.l << '.' << s.first.c;
297 if (s.first.l != s.last.l)
298 o << '-' << s.last.l << '.' << s.last.c - 1;
299 else if (s.first.c != s.last.c - 1)
300 o << '-' << s.last.c - 1;
301 return o;
302 }
303]])
304
305/* A C++ error reporting function. */
306void
307AT_NAME_PREFIX::parser::error (const location_type& l, const std::string& m)
308{
309 (void) l;
310 std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
311}
312
313/* A C++ yyparse that simulates the C signature. */
314int
315yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
316{
317 AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
318#if YYDEBUG
319 parser.set_debug_level (1);
320#endif
321 return parser.parse ();
322}
323],
324[/* A C error reporting function. */
325static void
326yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
327 AT_PARAM_IF([semantic_value *result, int *count, ])
328 const char *s)
329{
330AT_PARAM_IF([(void) result; (void) count;])
331AT_YYERROR_SEES_LOC_IF([
332 fprintf (stderr, "%d.%d",
333 AT_LOC_FIRST_LINE, AT_LOC_FIRST_COLUMN);
334 if (AT_LOC_FIRST_LINE != AT_LOC_LAST_LINE)
335 fprintf (stderr, "-%d.%d",
336 AT_LOC_LAST_LINE, AT_LOC_LAST_COLUMN - 1);
337 else if (AT_LOC_FIRST_COLUMN != AT_LOC_LAST_COLUMN - 1)
338 fprintf (stderr, "-%d",
339 AT_LOC_LAST_COLUMN - 1);
340 fprintf (stderr, ": ");])
341 fprintf (stderr, "%s\n", s);
342}])[
343
344]AT_DEFINES_IF(, [AT_CALC_LEX])[
345
346static int
347power (int base, int exponent)
348{
349 int res = 1;
350 if (exponent < 0)
351 exit (3);
352 for (/* Niente */; exponent; --exponent)
353 res *= base;
354 return res;
355}
356
357
358/* A C main function. */
359int
360main (int argc, const char **argv)
361{
362 semantic_value result = 0;
363 int count = 0;
364 int status;
365
366 /* This used to be alarm (10), but that isn't enough time for
367 a July 1995 vintage DEC Alphastation 200 4/100 system,
368 according to Nelson H. F. Beebe. 100 seconds is enough. */
369 alarm (100);
370
371 if (argc == 2)
372 input = fopen (argv[1], "r");
373 else
374 input = stdin;
375
376 if (!input)
377 {
378 perror (argv[1]);
379 return 3;
380 }
381
382]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
383[ yydebug = 1;])])[
384 status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
385 if (fclose (input))
386 perror ("fclose");
387 if (global_result != result)
388 abort ();
389 if (global_count != count)
390 abort ();
391 return status;
392}
393]])
394AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
395[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
396
397]AT_CALC_LEX])])
398m4_popdef([AT_CALC_LEX])
399])# _AT_DATA_CALC_Y
400
401
402# AT_DATA_CALC_Y([BISON-OPTIONS])
403# -------------------------------
404# Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
405# `calc-lex.cc'.
406m4_define([AT_DATA_CALC_Y],
407[_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
408])
409
410
411
412# _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
413# --------------------------------------------------------
414# Run `calc' on INPUT and expect no STDOUT nor STDERR.
415#
416# If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
417#
418# NUM-STDERR-LINES is the number of expected lines on stderr.
419# Currently this is ignored, though, since the output format is fluctuating.
420#
421# We don't count GLR's traces yet, since its traces are somewhat
422# different from LALR's.
423m4_define([_AT_CHECK_CALC],
424[AT_DATA([[input]],
425[[$2
426]])
427AT_PARSER_CHECK([./calc input], 0, [], [stderr])
428])
429
430
431# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
432# [NUM-STDERR-LINES],
433# [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
434# ---------------------------------------------------------
435# Run `calc' on INPUT, and expect a `syntax error' message.
436#
437# If INPUT starts with a slash, it is used as absolute input file name,
438# otherwise as contents.
439#
440# NUM-STDERR-LINES is the number of expected lines on stderr.
441# Currently this is ignored, though, since the output format is fluctuating.
442#
443# If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
444# is correctly output on stderr.
445#
446# If BISON-OPTIONS contains `%error-verbose', then make sure the
447# IF-YYERROR-VERBOSE message is properly output after `syntax error, '
448# on STDERR.
449#
450# If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
451# is the number of expected lines on stderr.
452m4_define([_AT_CHECK_CALC_ERROR],
453[m4_bmatch([$3], [^/],
454 [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
455 [AT_DATA([[input]],
456[[$3
457]])
458AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
459
460# Normalize the observed and expected error messages, depending upon the
461# options.
462# 1. Remove the traces from observed.
463sed '/^Starting/d
464/^Entering/d
465/^Stack/d
466/^Reading/d
467/^Reducing/d
468/^Return/d
469/^Shifting/d
470/^state/d
471/^Cleanup:/d
472/^Error:/d
473/^Next/d
474/^Now/d
475/^Discarding/d
476/ \$[[0-9$]]* = /d
477/^yydestructor:/d' stderr >at-stderr
478mv at-stderr stderr
479# 2. Create the reference error message.
480AT_DATA([[expout]],
481[$5
482])
483# 3. If locations are not used, remove them.
484AT_YYERROR_SEES_LOC_IF([],
485[[sed 's/^[-0-9.]*: //' expout >at-expout
486mv at-expout expout]])
487# 4. If error-verbose is not used, strip the`, unexpected....' part.
488m4_bmatch([$1], [%error-verbose], [],
489[[sed 's/syntax error, .*$/syntax error/' expout >at-expout
490mv at-expout expout]])
491# 5. Check
492AT_CHECK([cat stderr], 0, [expout])
493])
494
495
496# AT_CHECK_CALC([BISON-OPTIONS, [EXPECTED-TO-FAIL]])
497# --------------------------------------------------
498# Start a testing chunk which compiles `calc' grammar with
499# BISON-OPTIONS, and performs several tests over the parser.
500# However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.
501m4_define([AT_CHECK_CALC],
502[# We use integers to avoid dependencies upon the precision of doubles.
503AT_SETUP([Calculator $1])
504
505m4_ifval([$2], [AT_CHECK([exit 77])])
506
507AT_BISON_OPTION_PUSHDEFS([$1])
508
509AT_DATA_CALC_Y([$1])
510AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
511
512# Test the priorities.
513_AT_CHECK_CALC([$1],
514[1 + 2 * 3 = 7
5151 + 2 * -3 = -5
516
517-1^2 = -1
518(-1)^2 = 1
519
520---1 = -1
521
5221 - 2 - 3 = -4
5231 - (2 - 3) = 2
524
5252^2^3 = 256
526(2^2)^3 = 64],
527 [842])
528
529# Some syntax errors.
530_AT_CHECK_CALC_ERROR([$1], [1], [0 0], [15],
531 [1.3: syntax error, unexpected number])
532_AT_CHECK_CALC_ERROR([$1], [1], [1//2], [20],
533 [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
534_AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
535 [1.1: syntax error, unexpected $undefined])
536_AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [30],
537 [1.7: syntax error, unexpected '='])
538_AT_CHECK_CALC_ERROR([$1], [1],
539 [
540+1],
541 [20],
542 [2.1: syntax error, unexpected '+'])
543# Exercise error messages with EOF: work on an empty file.
544_AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
545 [1.1: syntax error, unexpected end of input])
546
547# Exercise the error token: without it, we die at the first error,
548# hence be sure to
549#
550# - have several errors which exercise different shift/discardings
551# - (): nothing to pop, nothing to discard
552# - (1 + 1 + 1 +): a lot to pop, nothing to discard
553# - (* * *): nothing to pop, a lot to discard
554# - (1 + 2 * *): some to pop and discard
555#
556# - test the action associated to `error'
557#
558# - check the lookahead that triggers an error is not discarded
559# when we enter error recovery. Below, the lookahead causing the
560# first error is ")", which is needed to recover from the error and
561# produce the "0" that triggers the "0 != 1" error.
562#
563_AT_CHECK_CALC_ERROR([$1], [0],
564 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
565 [250],
566[1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5671.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5681.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5691.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
570calc: error: 4444 != 1])
571
572# The same, but this time exercising explicitly triggered syntax errors.
573# POSIX says the lookahead causing the error should not be discarded.
574_AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [102],
575[1.10: syntax error, unexpected number
576calc: error: 2222 != 1])
577_AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [113],
578[1.4: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5791.12: syntax error, unexpected number
580calc: error: 2222 != 1])
581
582# Check that yyerrok works properly: second error is not reported,
583# third and fourth are. Parse status is succesfull.
584_AT_CHECK_CALC_ERROR([$1], [0], [(* *) + (*) + (*)], [113],
585[1.2: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5861.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5871.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!'])
588
589AT_BISON_OPTION_POPDEFS
590
591AT_CLEANUP
592])# AT_CHECK_CALC
593
594
595
596
597# ------------------------ #
598# Simple LALR Calculator. #
599# ------------------------ #
600
601AT_BANNER([[Simple LALR(1) Calculator.]])
602
603# AT_CHECK_CALC_LALR([BISON-OPTIONS])
604# -----------------------------------
605# Start a testing chunk which compiles `calc' grammar with
606# BISON-OPTIONS, and performs several tests over the parser.
607m4_define([AT_CHECK_CALC_LALR],
608[AT_CHECK_CALC($@)])
609
610AT_CHECK_CALC_LALR()
611
612AT_CHECK_CALC_LALR([%defines])
613AT_CHECK_CALC_LALR([%locations])
614
615AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
616AT_CHECK_CALC_LALR([%verbose])
617AT_CHECK_CALC_LALR([%yacc])
618AT_CHECK_CALC_LALR([%error-verbose])
619
620AT_CHECK_CALC_LALR([%define api.pure %locations])
621AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations])
622AT_CHECK_CALC_LALR([%error-verbose %locations])
623
624AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
625
626AT_CHECK_CALC_LALR([%debug])
627AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
628
629AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
630AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
631
632AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
633
634
635# ----------------------- #
636# Simple GLR Calculator. #
637# ----------------------- #
638
639AT_BANNER([[Simple GLR Calculator.]])
640
641# AT_CHECK_CALC_GLR([BISON-OPTIONS])
642# ----------------------------------
643# Start a testing chunk which compiles `calc' grammar with
644# BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
645m4_define([AT_CHECK_CALC_GLR],
646[AT_CHECK_CALC([%glr-parser] $@)])
647
648
649AT_CHECK_CALC_GLR()
650
651AT_CHECK_CALC_GLR([%defines])
652AT_CHECK_CALC_GLR([%locations])
653AT_CHECK_CALC_GLR([%name-prefix "calc"])
654AT_CHECK_CALC_GLR([%verbose])
655AT_CHECK_CALC_GLR([%yacc])
656AT_CHECK_CALC_GLR([%error-verbose])
657
658AT_CHECK_CALC_GLR([%define api.pure %locations])
659AT_CHECK_CALC_GLR([%error-verbose %locations])
660
661AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
662
663AT_CHECK_CALC_GLR([%debug])
664AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
665
666AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
667
668AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
669
670
671# ----------------------------- #
672# Simple LALR1 C++ Calculator. #
673# ----------------------------- #
674
675AT_BANNER([[Simple LALR(1) C++ Calculator.]])
676
677# First let's try using %skeleton
678AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
679
680# AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
681# ---------------------------------------
682# Start a testing chunk which compiles `calc' grammar with
683# the C++ skeleton, and performs several tests over the parser.
684m4_define([AT_CHECK_CALC_LALR1_CC],
685[AT_CHECK_CALC([%language "C++" %defines %locations] $@)])
686
687AT_CHECK_CALC_LALR1_CC([])
688AT_CHECK_CALC_LALR1_CC([%define location_type Span])
689AT_CHECK_CALC_LALR1_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
690AT_CHECK_CALC_LALR1_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
691
692AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
693
694AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
695
696
697
698# --------------------------- #
699# Simple GLR C++ Calculator. #
700# --------------------------- #
701
702AT_BANNER([[Simple GLR C++ Calculator.]])
703
704# Again, we try also using %skeleton.
705AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
706
707# AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
708# -------------------------------------
709# Start a testing chunk which compiles `calc' grammar with
710# the GLR C++ skeleton, and performs several tests over the parser.
711m4_define([AT_CHECK_CALC_GLR_CC],
712[AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
713
714AT_CHECK_CALC_GLR_CC([])
715AT_CHECK_CALC_GLR_CC([%define location_type Span])
716AT_CHECK_CALC_GLR_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
717
718AT_CHECK_CALC_GLR_CC([%debug])
719AT_CHECK_CALC_GLR_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
720
721AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
722
723AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])