mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 12:23:04 +00:00
a22ff96f32
test for valgrind; valgrind is independent of g++. (maintainer-check-posix): Add _POSIX2_VERSION=200112, to check for compatibility with POSIX 1003.1-2001 (if running coreutils). * tests/cxx-type.at (_AT_TEST_GLR_CXXTYPES): Port to stricter C++. Use a destructor, so that we can expand the stack. Change YYSTYPE to char * so that we can free it. Cast result of malloc.
378 lines
8.7 KiB
Plaintext
378 lines
8.7 KiB
Plaintext
# Checking GLR Parsing. -*- Autotest -*-
|
|
# Copyright (C) 2002, 2003, 2004, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
# 02110-1301, USA.
|
|
|
|
AT_BANNER([[C++ Type Syntax (GLR).]])
|
|
|
|
# _AT_TEST_GLR_CXXTYPES(DECL, RESOLVE1, RESOLVE2)
|
|
# -----------------------------------------------
|
|
# Store into types.y the calc program, with DECL inserted as a declaration,
|
|
# and with RESOLVE1 and RESOLVE2 as annotations on the conflicted rule for
|
|
# stmt. Then compile the result.
|
|
m4_define([_AT_TEST_GLR_CXXTYPES],
|
|
[
|
|
AT_BISON_OPTION_PUSHDEFS([$1])
|
|
|
|
AT_DATA_GRAMMAR([types.y],
|
|
[[/* Simplified C++ Type and Expression Grammar. */
|
|
|
|
$1
|
|
|
|
%{
|
|
#include <stdio.h>
|
|
#define YYSTYPE char *
|
|
]m4_bmatch([$2], [stmtMerge],
|
|
[ static YYSTYPE stmtMerge (YYSTYPE x0, YYSTYPE x1);])[
|
|
#define YYINITDEPTH 10
|
|
static char *format (char const *, ...);
|
|
struct YYLTYPE;
|
|
#if YYPURE
|
|
# if YYLSP_NEEDED
|
|
# define LEX_PARAMETERS YYSTYPE *lvalp, struct YYLTYPE *llocp
|
|
# define ERROR_PARAMETERS struct YYLTYPE *llocp, char const *s
|
|
# else
|
|
# define LEX_PARAMETERS YYSTYPE *lvalp
|
|
# endif
|
|
#endif
|
|
#ifndef LEX_PARAMETERS
|
|
# define LEX_PARAMETERS void
|
|
#endif
|
|
#ifndef ERROR_PARAMETERS
|
|
# define ERROR_PARAMETERS char const *s
|
|
#endif
|
|
int yylex (LEX_PARAMETERS);
|
|
int yyerror (ERROR_PARAMETERS);
|
|
%}
|
|
|
|
%token TYPENAME ID
|
|
|
|
%right '='
|
|
%left '+'
|
|
|
|
%glr-parser
|
|
|
|
%destructor { free ($$); } TYPENAME ID
|
|
|
|
%%
|
|
|
|
prog :
|
|
| prog stmt {
|
|
]AT_LOCATION_IF([
|
|
printf ("%d.%d-%d.%d: ",
|
|
@2.first_line, @2.first_column,
|
|
@2.last_line, @2.last_column);])[
|
|
printf ("%s\n", ]$[2);
|
|
}
|
|
;
|
|
|
|
stmt : expr ';' $2 { $$ = ]$[1; }
|
|
| decl $3
|
|
| error ';' { $$ = "<error>"; }
|
|
| '@' { YYACCEPT; }
|
|
;
|
|
|
|
expr : ID
|
|
| TYPENAME '(' expr ')' { $$ = format ("<cast>(%s,%s)", ]$[3, ]$[1); }
|
|
| expr '+' expr { $$ = format ("+(%s,%s)", ]$[1, ]$[3); }
|
|
| expr '=' expr { $$ = format ("=(%s,%s)", ]$[1, ]$[3); }
|
|
;
|
|
|
|
decl : TYPENAME declarator ';'
|
|
{ $$ = format ("<declare>(%s,%s)", ]$[1, ]$[2); }
|
|
| TYPENAME declarator '=' expr ';'
|
|
{ $$ = format ("<init-declare>(%s,%s,%s)", ]$[1, ]$[2, ]$[4); }
|
|
;
|
|
|
|
declarator : ID
|
|
| '(' declarator ')' { $$ = ]$[2; }
|
|
;
|
|
|
|
%%
|
|
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
if (argc != 2)
|
|
abort ();
|
|
if (!freopen (argv[1], "r", stdin))
|
|
abort ();
|
|
exit (yyparse ());
|
|
}
|
|
|
|
int
|
|
yylex (LEX_PARAMETERS)
|
|
{
|
|
char buffer[256];
|
|
int c;
|
|
unsigned int i;
|
|
static int lineNum = 1;
|
|
static int colNum = 0;
|
|
|
|
#if YYPURE
|
|
# define yylloc (*llocp)
|
|
# define yylval (*lvalp)
|
|
#endif
|
|
|
|
while (1)
|
|
{
|
|
c = getchar ();
|
|
switch (c)
|
|
{
|
|
case EOF:
|
|
return 0;
|
|
case '\t':
|
|
colNum = (colNum + 7) & ~7;
|
|
break;
|
|
case ' ': case '\f':
|
|
colNum += 1;
|
|
break;
|
|
case '\n':
|
|
lineNum += 1;
|
|
colNum = 0;
|
|
break;
|
|
default:
|
|
{
|
|
int tok;
|
|
#if YYLSP_NEEDED
|
|
yylloc.first_line = yylloc.last_line = lineNum;
|
|
yylloc.first_column = colNum;
|
|
#endif
|
|
if (isalpha (c))
|
|
{
|
|
i = 0;
|
|
|
|
do
|
|
{
|
|
buffer[i++] = c;
|
|
colNum += 1;
|
|
if (i == sizeof buffer - 1)
|
|
abort ();
|
|
c = getchar ();
|
|
}
|
|
while (isalnum (c) || c == '_');
|
|
|
|
ungetc (c, stdin);
|
|
buffer[i++] = 0;
|
|
tok = isupper ((unsigned char) buffer[0]) ? TYPENAME : ID;
|
|
yylval = strcpy ((char *) malloc (i), buffer);
|
|
}
|
|
else
|
|
{
|
|
colNum += 1;
|
|
tok = c;
|
|
yylval = "";
|
|
}
|
|
#if YYLSP_NEEDED
|
|
yylloc.last_column = colNum-1;
|
|
#endif
|
|
return tok;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
yyerror (ERROR_PARAMETERS)
|
|
{
|
|
#if YYPURE && YYLSP_NEEDED
|
|
/* Pacify GCC by using llocp. */
|
|
if (! llocp)
|
|
abort ();
|
|
#endif
|
|
fprintf (stderr, "%s\n", s);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static char *
|
|
format (char const *form, ...)
|
|
{
|
|
char buffer[1024];
|
|
va_list args;
|
|
va_start (args, form);
|
|
vsprintf (buffer, form, args);
|
|
va_end (args);
|
|
return strcpy ((char *) malloc (strlen (buffer) + 1), buffer);
|
|
}
|
|
|
|
]]
|
|
m4_bmatch([$2], [stmtMerge],
|
|
[[static YYSTYPE
|
|
stmtMerge (YYSTYPE x0, YYSTYPE x1)
|
|
{
|
|
return format ("<OR>(%s,%s)", x0, x1);
|
|
}
|
|
]])
|
|
)
|
|
|
|
AT_DATA([test-input],
|
|
[[
|
|
|
|
z + q;
|
|
|
|
T x;
|
|
|
|
T x = y;
|
|
|
|
x = y;
|
|
|
|
T (x) + y;
|
|
|
|
T (x);
|
|
|
|
T (y) = z + q;
|
|
|
|
T (y y) = z + q;
|
|
|
|
z + q;
|
|
|
|
@
|
|
|
|
This is total garbage, but it should be ignored.
|
|
]])
|
|
|
|
AT_CHECK([bison -o types.c types.y], 0, [], ignore)
|
|
AT_COMPILE([types])
|
|
AT_BISON_OPTION_POPDEFS
|
|
])
|
|
|
|
m4_define([_AT_RESOLVED_GLR_OUTPUT],
|
|
[[+(z,q)
|
|
<declare>(T,x)
|
|
<init-declare>(T,x,y)
|
|
=(x,y)
|
|
+(<cast>(x,T),y)
|
|
<declare>(T,x)
|
|
<init-declare>(T,y,+(z,q))
|
|
<error>
|
|
+(z,q)
|
|
]])
|
|
|
|
m4_define([_AT_RESOLVED_GLR_OUTPUT_WITH_LOC],
|
|
[[3.0-3.5: +(z,q)
|
|
5.0-5.3: <declare>(T,x)
|
|
7.0-7.7: <init-declare>(T,x,y)
|
|
9.0-9.5: =(x,y)
|
|
11.0-11.9: +(<cast>(x,T),y)
|
|
13.0-13.5: <declare>(T,x)
|
|
15.0-15.13: <init-declare>(T,y,+(z,q))
|
|
17.0-17.15: <error>
|
|
19.0-19.5: +(z,q)
|
|
]])
|
|
|
|
m4_define([_AT_AMBIG_GLR_OUTPUT],
|
|
[[+(z,q)
|
|
<declare>(T,x)
|
|
<init-declare>(T,x,y)
|
|
=(x,y)
|
|
+(<cast>(x,T),y)
|
|
<OR>(<declare>(T,x),<cast>(x,T))
|
|
<OR>(<init-declare>(T,y,+(z,q)),=(<cast>(y,T),+(z,q)))
|
|
<error>
|
|
+(z,q)
|
|
]])
|
|
|
|
m4_define([_AT_AMBIG_GLR_OUTPUT_WITH_LOC],
|
|
[[3.0-3.5: +(z,q)
|
|
5.0-5.3: <declare>(T,x)
|
|
7.0-7.7: <init-declare>(T,x,y)
|
|
9.0-9.5: =(x,y)
|
|
11.0-11.9: +(<cast>(x,T),y)
|
|
13.0-13.5: <OR>(<declare>(T,x),<cast>(x,T))
|
|
15.0-15.13: <OR>(<init-declare>(T,y,+(z,q)),=(<cast>(y,T),+(z,q)))
|
|
17.0-17.15: <error>
|
|
19.0-19.5: +(z,q)
|
|
]])
|
|
|
|
m4_define([_AT_GLR_STDERR],
|
|
[[syntax error
|
|
]])
|
|
|
|
m4_define([_AT_VERBOSE_GLR_STDERR],
|
|
[[syntax error, unexpected ID, expecting '=' or '+' or ')'
|
|
]])
|
|
|
|
## ---------------------------------------------------- ##
|
|
## Compile the grammar described in the documentation. ##
|
|
## ---------------------------------------------------- ##
|
|
|
|
AT_SETUP([GLR: Resolve ambiguity, impure, no locations])
|
|
_AT_TEST_GLR_CXXTYPES([],
|
|
[%dprec 1], [%dprec 2])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_RESOLVED_GLR_OUTPUT, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([GLR: Resolve ambiguity, impure, locations])
|
|
_AT_TEST_GLR_CXXTYPES([%locations],[%dprec 1],[%dprec 2])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_RESOLVED_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([GLR: Resolve ambiguity, pure, no locations])
|
|
_AT_TEST_GLR_CXXTYPES([%pure-parser],
|
|
[%dprec 1], [%dprec 2])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_RESOLVED_GLR_OUTPUT, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([GLR: Resolve ambiguity, pure, locations])
|
|
_AT_TEST_GLR_CXXTYPES([%pure-parser %locations],
|
|
[%dprec 1], [%dprec 2])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_RESOLVED_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([GLR: Merge conflicting parses, impure, no locations])
|
|
_AT_TEST_GLR_CXXTYPES([],
|
|
[%merge <stmtMerge>], [%merge <stmtMerge>])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_AMBIG_GLR_OUTPUT, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([GLR: Merge conflicting parses, impure, locations])
|
|
_AT_TEST_GLR_CXXTYPES([%locations],
|
|
[%merge <stmtMerge>], [%merge <stmtMerge>])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_AMBIG_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([GLR: Merge conflicting parses, pure, no locations])
|
|
_AT_TEST_GLR_CXXTYPES([%pure-parser],
|
|
[%merge <stmtMerge>], [%merge <stmtMerge>])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_AMBIG_GLR_OUTPUT, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
AT_SETUP([GLR: Merge conflicting parses, pure, locations])
|
|
_AT_TEST_GLR_CXXTYPES([%pure-parser %locations],
|
|
[%merge <stmtMerge>],[%merge <stmtMerge>])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_AMBIG_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([GLR: Verbose messages, resolve ambiguity, impure, no locations])
|
|
_AT_TEST_GLR_CXXTYPES([%error-verbose],
|
|
[%merge <stmtMerge>], [%merge <stmtMerge>])
|
|
AT_PARSER_CHECK([[./types test-input | sed 's/ *$//']], 0,
|
|
_AT_AMBIG_GLR_OUTPUT, _AT_VERBOSE_GLR_STDERR)
|
|
AT_CLEANUP
|