mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 20:33:03 +00:00
601 lines
15 KiB
Plaintext
601 lines
15 KiB
Plaintext
# Checking the output filenames. -*- Autotest -*-
|
|
# Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2, or (at your option)
|
|
# any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
# 02111-1307, USA.
|
|
|
|
## ---------------------------------------------------- ##
|
|
## Compile the grammar described in the documentation. ##
|
|
## ---------------------------------------------------- ##
|
|
|
|
|
|
# ------------------------- #
|
|
# Helping Autotest macros. #
|
|
# ------------------------- #
|
|
|
|
|
|
# _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
|
|
# -----------------------------------------------
|
|
# Produce `calc.y'. Don't call this macro directly, because it contains
|
|
# some occurrences of `$1' etc. which will be interpreted by m4. So
|
|
# you should call it with $1, $2, and $3 as arguments, which is what
|
|
# AT_DATA_CALC_Y does.
|
|
m4_define([_AT_DATA_CALC_Y],
|
|
[m4_if([$1$2$3], $[1]$[2]$[3], [],
|
|
[m4_fatal([$0: Invalid arguments: $@])])dnl
|
|
AT_DATA_GRAMMAR([calc.y],
|
|
[[/* Infix notation calculator--calc */
|
|
]$4[
|
|
%{
|
|
#include <stdio.h>
|
|
|
|
#if STDC_HEADERS
|
|
# include <stdlib.h>
|
|
# include <string.h>
|
|
#endif
|
|
#include <ctype.h>
|
|
|
|
extern void perror (const char *s);
|
|
|
|
/* Exercise pre-prologue dependency to %union. */
|
|
typedef int value_t;
|
|
|
|
static value_t global_result = 0;
|
|
static int global_count = 0;
|
|
|
|
%}
|
|
|
|
/* Exercise %union. */
|
|
%union
|
|
{
|
|
value_t ival;
|
|
};
|
|
|
|
%{
|
|
#if YYPURE
|
|
# define LOC (*yylloc)
|
|
# define VAL (*yylval)
|
|
#else
|
|
# define LOC (yylloc)
|
|
# define VAL (yylval)
|
|
#endif
|
|
|
|
#define YYLLOC_FORMAL ]AT_LOCATION_IF([, YYLTYPE *yylloc])[
|
|
#define YYLLOC_ARG ]AT_LOCATION_IF([, yylloc])[
|
|
#define USE_YYLLOC ]AT_LOCATION_IF([(void) yylloc;])[
|
|
|
|
#if YYPURE
|
|
# define LEX_FORMALS YYSTYPE *yylval YYLLOC_FORMAL
|
|
# define LEX_ARGS yylval YYLLOC_ARG
|
|
# define USE_LEX_ARGS (void) yylval; USE_YYLLOC
|
|
# define LEX_PRE_FORMALS LEX_FORMALS,
|
|
# define LEX_PRE_ARGS LEX_ARGS,
|
|
#else
|
|
# define LEX_FORMALS void
|
|
# define LEX_PRE_FORMALS
|
|
# define LEX_ARGS
|
|
# define LEX_PRE_ARGS
|
|
# define USE_LEX_ARGS
|
|
#endif
|
|
|
|
static int power (int base, int exponent);
|
|
/* yyerror receives the location if:
|
|
- %location & %pure & %glr
|
|
- %location & %pure & %yacc & %parse-param. */
|
|
static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
|
|
]AT_PARAM_IF([value_t *result, int *count, ])[
|
|
const char *s
|
|
);
|
|
static int yylex (LEX_FORMALS);
|
|
static int yygetc (LEX_FORMALS);
|
|
static void yyungetc (LEX_PRE_FORMALS int c);
|
|
%}
|
|
|
|
/* Bison Declarations */
|
|
%token CALC_EOF 0 "end of input"
|
|
%token <ival> NUM "number"
|
|
%type <ival> exp
|
|
|
|
%nonassoc '=' /* comparison */
|
|
%left '-' '+'
|
|
%left '*' '/'
|
|
%left NEG /* negation--unary minus */
|
|
%right '^' /* exponentiation */
|
|
|
|
/* Grammar follows */
|
|
%%
|
|
input:
|
|
line
|
|
| input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
|
|
;
|
|
|
|
line:
|
|
'\n'
|
|
| exp '\n' { ]AT_PARAM_IF([*result = global_result = $1;])[ }
|
|
;
|
|
|
|
exp:
|
|
NUM { $$ = $1; }
|
|
| exp '=' exp
|
|
{
|
|
if ($1 != $3)
|
|
fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
|
|
$$ = $1;
|
|
}
|
|
| exp '+' exp { $$ = $1 + $3; }
|
|
| exp '-' exp { $$ = $1 - $3; }
|
|
| exp '*' exp { $$ = $1 * $3; }
|
|
| exp '/' exp { $$ = $1 / $3; }
|
|
| '-' exp %prec NEG { $$ = -$2; }
|
|
| exp '^' exp { $$ = power ($1, $3); }
|
|
| '(' exp ')' { $$ = $2; }
|
|
| '(' error ')' { $$ = 0; }
|
|
;
|
|
%%
|
|
/* The input. */
|
|
static FILE *yyin;
|
|
|
|
static void
|
|
yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
|
|
]AT_PARAM_IF([value_t *result, int *count, ])[
|
|
const char *s
|
|
)
|
|
{
|
|
]AT_PARAM_IF([(void) result; (void) count; ])[
|
|
]AT_YYERROR_SEES_LOC_IF([
|
|
fprintf (stderr, "%d.%d-%d.%d: ",
|
|
LOC.first_line, LOC.first_column,
|
|
LOC.last_line, LOC.last_column);
|
|
])[
|
|
fprintf (stderr, "%s\n", s);
|
|
}
|
|
|
|
|
|
]AT_LOCATION_IF([
|
|
static YYLTYPE last_yylloc;
|
|
])[
|
|
static int
|
|
yygetc (LEX_FORMALS)
|
|
{
|
|
int res = getc (yyin);
|
|
USE_LEX_ARGS;
|
|
]AT_LOCATION_IF([
|
|
last_yylloc = LOC;
|
|
if (res == '\n')
|
|
{
|
|
LOC.last_line++;
|
|
LOC.last_column = 1;
|
|
}
|
|
else
|
|
LOC.last_column++;
|
|
])[
|
|
return res;
|
|
}
|
|
|
|
|
|
static void
|
|
yyungetc (LEX_PRE_FORMALS int c)
|
|
{
|
|
USE_LEX_ARGS;
|
|
]AT_LOCATION_IF([
|
|
/* Wrong when C == `\n'. */
|
|
LOC = last_yylloc;
|
|
])[
|
|
ungetc (c, yyin);
|
|
}
|
|
|
|
static int
|
|
read_signed_integer (LEX_FORMALS)
|
|
{
|
|
int c = yygetc (LEX_ARGS);
|
|
int sign = 1;
|
|
int n = 0;
|
|
|
|
USE_LEX_ARGS;
|
|
if (c == '-')
|
|
{
|
|
c = yygetc (LEX_ARGS);
|
|
sign = -1;
|
|
}
|
|
|
|
while (isdigit (c))
|
|
{
|
|
n = 10 * n + (c - '0');
|
|
c = yygetc (LEX_ARGS);
|
|
}
|
|
|
|
yyungetc (LEX_PRE_ARGS c);
|
|
|
|
return sign * n;
|
|
}
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------.
|
|
| Lexical analyzer returns an integer on the stack and the token |
|
|
| NUM, or the ASCII character read if not a number. Skips all |
|
|
| blanks and tabs, returns 0 for EOF. |
|
|
`---------------------------------------------------------------*/
|
|
|
|
static int
|
|
yylex (LEX_FORMALS)
|
|
{
|
|
static int init = 1;
|
|
int c;
|
|
|
|
if (init)
|
|
{
|
|
init = 0;
|
|
]AT_LOCATION_IF([
|
|
LOC.last_column = 1;
|
|
LOC.last_line = 1;
|
|
])[
|
|
}
|
|
|
|
]AT_LOCATION_IF([
|
|
LOC.first_column = LOC.last_column;
|
|
LOC.first_line = LOC.last_line;
|
|
])[
|
|
|
|
/* Skip white space. */
|
|
while ((c = yygetc (LEX_ARGS)) == ' ' || c == '\t')
|
|
{
|
|
]AT_LOCATION_IF([
|
|
LOC.first_column = LOC.last_column;
|
|
LOC.first_line = LOC.last_line;
|
|
])[
|
|
}
|
|
|
|
/* process numbers */
|
|
if (c == '.' || isdigit (c))
|
|
{
|
|
yyungetc (LEX_PRE_ARGS c);
|
|
VAL.ival = read_signed_integer (LEX_ARGS);
|
|
return NUM;
|
|
}
|
|
|
|
/* Return end-of-file. */
|
|
if (c == EOF)
|
|
return CALC_EOF;
|
|
|
|
/* Return single chars. */
|
|
return c;
|
|
}
|
|
|
|
static int
|
|
power (int base, int exponent)
|
|
{
|
|
int res = 1;
|
|
if (exponent < 0)
|
|
exit (1);
|
|
for (/* Niente */; exponent; --exponent)
|
|
res *= base;
|
|
return res;
|
|
}
|
|
|
|
int
|
|
main (int argc, const char **argv)
|
|
{
|
|
value_t result = 0;
|
|
int count = 0;
|
|
int status;
|
|
|
|
if (argc == 2)
|
|
yyin = fopen (argv[1], "r");
|
|
else
|
|
yyin = stdin;
|
|
|
|
if (!yyin)
|
|
{
|
|
perror (argv[1]);
|
|
exit (1);
|
|
}
|
|
|
|
#if YYDEBUG
|
|
yydebug = 1;
|
|
#endif
|
|
status = yyparse (]AT_PARAM_IF([&result, &count])[);
|
|
if (global_result != result)
|
|
abort ();
|
|
if (global_count != count)
|
|
abort ();
|
|
return status;
|
|
}
|
|
]])
|
|
])# _AT_DATA_CALC_Y
|
|
|
|
|
|
# AT_DATA_CALC_Y([BISON-OPTIONS])
|
|
# -------------------------------
|
|
# Produce `calc.y'.
|
|
m4_define([AT_DATA_CALC_Y],
|
|
[_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
|
|
])
|
|
|
|
|
|
|
|
# _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES = 0])
|
|
# ------------------------------------------------------------
|
|
# Run `calc' on INPUT and expect no STDOUT nor STDERR.
|
|
#
|
|
# If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
|
|
# NUM-STDERR-LINES is the number of expected lines on stderr.
|
|
#
|
|
# We don't count GLR's traces yet, since its traces are somewhat
|
|
# different from LALR's.
|
|
m4_define([_AT_CHECK_CALC],
|
|
[AT_DATA([[input]],
|
|
[[$2
|
|
]])
|
|
AT_PARSER_CHECK([./calc input], 0, [], [stderr])
|
|
m4_bmatch([$1],
|
|
[%debug.*%glr\|%glr.*%debug],
|
|
[],
|
|
[%debug],
|
|
[AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
|
|
])])
|
|
])
|
|
|
|
|
|
# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
|
|
# [NUM-DEBUG-LINES],
|
|
# [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
|
|
# ---------------------------------------------------------
|
|
# Run `calc' on INPUT, and expect a `syntax error' message.
|
|
#
|
|
# If INPUT starts with a slash, it is used as absolute input file name,
|
|
# otherwise as contents.
|
|
#
|
|
# If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
|
|
# is correctly output on stderr.
|
|
#
|
|
# If BISON-OPTIONS contains `%error-verbose', then make sure the
|
|
# IF-YYERROR-VERBOSE message is properly output after `syntax error, '
|
|
# on STDERR.
|
|
#
|
|
# If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
|
|
# is the number of expected lines on stderr.
|
|
m4_define([_AT_CHECK_CALC_ERROR],
|
|
[m4_bmatch([$3], [^/],
|
|
[AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
|
|
[AT_DATA([[input]],
|
|
[[$3
|
|
]])
|
|
AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
|
|
m4_bmatch([$1],
|
|
[%debug.*%glr\|%glr.*%debug],
|
|
[],
|
|
[%debug],
|
|
[AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$4
|
|
])])
|
|
|
|
# Normalize the observed and expected error messages, depending upon the
|
|
# options.
|
|
# 1. Remove the traces from observed.
|
|
sed '/^Starting/d
|
|
/^Entering/d
|
|
/^Stack/d
|
|
/^Reading/d
|
|
/^Reducing/d
|
|
/^Shifting/d
|
|
/^state/d
|
|
/^Error:/d
|
|
/^Next/d
|
|
/^Discarding/d
|
|
/^yydestructor:/d' stderr >at-stderr
|
|
mv at-stderr stderr
|
|
# 2. Create the reference error message.
|
|
AT_DATA([[expout]],
|
|
[$5
|
|
])
|
|
# 3. If locations are not used, remove them.
|
|
AT_YYERROR_SEES_LOC_IF([],
|
|
[[sed 's/^[-0-9.]*: //' expout >at-expout
|
|
mv at-expout expout]])
|
|
# 4. If error-verbose is not used, strip the`, unexpected....' part.
|
|
m4_bmatch([$1], [%error-verbose], [],
|
|
[[sed 's/syntax error, .*$/syntax error/' expout >at-expout
|
|
mv at-expout expout]])
|
|
# 5. Check
|
|
AT_CHECK([cat stderr], 0, [expout])
|
|
])
|
|
|
|
|
|
# AT_CALC_PUSHDEFS($1, $2, [BISON-OPTIONS])
|
|
# -----------------------------------------
|
|
# This macro works around the impossibility to define macros
|
|
# inside macros, because issuing `[$1]' is not possible in M4 :(.
|
|
# This sucks hard, GNU M4 should really provide M5 like $$1.
|
|
m4_define([AT_CHECK_PUSHDEFS],
|
|
[m4_if([$1$2], $[1]$[2], [],
|
|
[m4_fatal([$0: Invalid arguments: $@])])dnl
|
|
m4_pushdef([AT_PARAM_IF],
|
|
[m4_bmatch([$3], [%parse-param], [$1], [$2])])
|
|
m4_pushdef([AT_LOCATION_IF],
|
|
[m4_bmatch([$3], [%locations], [$1], [$2])])
|
|
m4_pushdef([AT_PURE_IF],
|
|
[m4_bmatch([$3], [%pure-parser], [$1], [$2])])
|
|
m4_pushdef([AT_GLR_IF],
|
|
[m4_bmatch([$3], [%glr-parser], [$1], [$2])])
|
|
m4_pushdef([AT_PURE_AND_LOC_IF],
|
|
[m4_bmatch([$3], [%locations.*%pure-parser\|%pure-parser.*%locations],
|
|
[$1], [$2])])
|
|
m4_pushdef([AT_GLR_OR_PARAM_IF],
|
|
[m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])])
|
|
|
|
# yyerror receives the location if %location & %pure & (%glr or %parse-param).
|
|
m4_pushdef([AT_YYERROR_ARG_LOC_IF],
|
|
[AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
|
|
[$2])])
|
|
# yyerror cannot see the locations if !glr & pure & !param.
|
|
m4_pushdef([AT_YYERROR_SEES_LOC_IF],
|
|
[AT_LOCATION_IF([AT_GLR_IF([$1],
|
|
[AT_PURE_IF([AT_PARAM_IF([$1], [$2])],
|
|
[$1])])],
|
|
[$2])])
|
|
])
|
|
|
|
|
|
# AT_CALC_POPDEFS
|
|
# ---------------
|
|
m4_define([AT_CHECK_POPDEFS],
|
|
[m4_popdef([AT_YYERROR_SEES_LOC_IF])
|
|
m4_popdef([AT_YYERROR_ARG_LOC_IF])
|
|
m4_popdef([AT_GLR_OR_PARAM_IF])
|
|
m4_popdef([AT_PURE_AND_LOC_IF])
|
|
m4_popdef([AT_GLR_IF])
|
|
m4_popdef([AT_LOCATION_IF])
|
|
m4_popdef([AT_PARAM_IF])
|
|
])
|
|
|
|
|
|
|
|
# AT_CHECK_CALC([BISON-OPTIONS])
|
|
# ------------------------------
|
|
# Start a testing chunk which compiles `calc' grammar with
|
|
# BISON-OPTIONS, and performs several tests over the parser.
|
|
m4_define([AT_CHECK_CALC],
|
|
[# We use integers to avoid dependencies upon the precision of doubles.
|
|
AT_SETUP([Calculator $1])
|
|
|
|
AT_CHECK_PUSHDEFS($[1], $[2], [$1])
|
|
|
|
AT_DATA_CALC_Y([$1])
|
|
|
|
# Specify the output files to avoid problems on different file systems.
|
|
AT_CHECK([bison -o calc.c calc.y],
|
|
[0], [], [])
|
|
|
|
AT_COMPILE([calc])
|
|
|
|
# Test the priorities.
|
|
_AT_CHECK_CALC([$1],
|
|
[1 + 2 * 3 = 7
|
|
1 + 2 * -3 = -5
|
|
|
|
-1^2 = -1
|
|
(-1)^2 = 1
|
|
|
|
---1 = -1
|
|
|
|
1 - 2 - 3 = -4
|
|
1 - (2 - 3) = 2
|
|
|
|
2^2^3 = 256
|
|
(2^2)^3 = 64],
|
|
[486])
|
|
|
|
# Some syntax errors.
|
|
_AT_CHECK_CALC_ERROR([$1], [1], [0 0], [11],
|
|
[1.3-1.4: syntax error, unexpected "number"])
|
|
_AT_CHECK_CALC_ERROR([$1], [1], [1//2], [15],
|
|
[1.3-1.4: syntax error, unexpected '/', expecting "number" or '-' or '('])
|
|
_AT_CHECK_CALC_ERROR([$1], [1], [error], [4],
|
|
[1.1-1.2: syntax error, unexpected $undefined, expecting "number" or '-' or '\n' or '('])
|
|
_AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [22],
|
|
[1.7-1.8: syntax error, unexpected '='])
|
|
_AT_CHECK_CALC_ERROR([$1], [1],
|
|
[
|
|
+1],
|
|
[14],
|
|
[2.1-2.2: syntax error, unexpected '+'])
|
|
# Exercise error messages with EOF: work on an empty file.
|
|
_AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
|
|
[1.1-1.2: syntax error, unexpected "end of input", expecting "number" or '-' or '\n' or '('])
|
|
|
|
# Exercise the error token: without it, we die at the first error,
|
|
# hence be sure i. to have several errors, ii. to test the action
|
|
# associated to `error'.
|
|
_AT_CHECK_CALC_ERROR([$1], [0], [(1 ++ 2) + (0 0) = 1], [82],
|
|
[1.5-1.6: syntax error, unexpected '+', expecting "number" or '-' or '('
|
|
1.15-1.16: syntax error, unexpected "number"
|
|
calc: error: 0 != 1])
|
|
|
|
AT_CHECK_POPDEFS
|
|
|
|
AT_CLEANUP
|
|
])# AT_CHECK_CALC
|
|
|
|
|
|
|
|
|
|
# ------------------------ #
|
|
# Simple LALR Calculator. #
|
|
# ------------------------ #
|
|
|
|
AT_BANNER([[Simple LALR Calculator.]])
|
|
|
|
# AT_CHECK_CALC_LALR([BISON-OPTIONS])
|
|
# -----------------------------------
|
|
# Start a testing chunk which compiles `calc' grammar with
|
|
# BISON-OPTIONS, and performs several tests over the parser.
|
|
m4_define([AT_CHECK_CALC_LALR],
|
|
[AT_CHECK_CALC($@)])
|
|
|
|
AT_CHECK_CALC_LALR()
|
|
|
|
AT_CHECK_CALC_LALR([%defines])
|
|
AT_CHECK_CALC_LALR([%locations])
|
|
AT_CHECK_CALC_LALR([%name-prefix="calc"])
|
|
AT_CHECK_CALC_LALR([%verbose])
|
|
AT_CHECK_CALC_LALR([%yacc])
|
|
AT_CHECK_CALC_LALR([%error-verbose])
|
|
|
|
AT_CHECK_CALC_LALR([%error-verbose %locations])
|
|
|
|
AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
|
|
|
|
AT_CHECK_CALC_LALR([%debug])
|
|
AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
|
|
|
|
AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
|
|
|
|
AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value_t *result}, {result} %parse-param {int *count}, {count}])
|
|
|
|
|
|
# ----------------------- #
|
|
# Simple GLR Calculator. #
|
|
# ----------------------- #
|
|
|
|
AT_BANNER([[Simple GLR Calculator.]])
|
|
|
|
# AT_CHECK_CALC_GLR([BISON-OPTIONS])
|
|
# ----------------------------------
|
|
# Start a testing chunk which compiles `calc' grammar with
|
|
# BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
|
|
m4_define([AT_CHECK_CALC_GLR],
|
|
[AT_CHECK_CALC([%glr-parser] $@)])
|
|
|
|
|
|
AT_CHECK_CALC_GLR()
|
|
|
|
AT_CHECK_CALC_GLR([%defines])
|
|
AT_CHECK_CALC_GLR([%locations])
|
|
AT_CHECK_CALC_GLR([%name-prefix="calc"])
|
|
AT_CHECK_CALC_GLR([%verbose])
|
|
AT_CHECK_CALC_GLR([%yacc])
|
|
AT_CHECK_CALC_GLR([%error-verbose])
|
|
|
|
AT_CHECK_CALC_GLR([%error-verbose %locations])
|
|
|
|
AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
|
|
|
|
AT_CHECK_CALC_GLR([%debug])
|
|
AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
|
|
|
|
AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
|
|
|
|
AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value_t *result}, {result} %parse-param {int *count}, {count}])
|