mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 12:23:04 +00:00
389 lines
12 KiB
Plaintext
389 lines
12 KiB
Plaintext
# Value type. -*- Autotest -*-
|
|
|
|
# Copyright (C) 2013-2015, 2018-2019 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 3 of the License, 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, see <http://www.gnu.org/licenses/>.
|
|
|
|
AT_BANNER([[Value type tests.]])
|
|
|
|
|
|
## ----------------------------------- ##
|
|
## %union vs. %define api.value.type. ##
|
|
## ----------------------------------- ##
|
|
|
|
AT_SETUP([[%union vs. %define api.value.type]])
|
|
|
|
AT_DATA([[input.y]],
|
|
[[%union { int ival; }
|
|
%define api.value.type union-directive
|
|
%%
|
|
exp: %empty;
|
|
]])
|
|
|
|
AT_BISON_CHECK([[input.y]], [[1]], [[]],
|
|
[[input.y:2.9-22: error: '%union' and '%define api.value.type' cannot be used together
|
|
]])
|
|
|
|
AT_CLEANUP
|
|
|
|
## ---------------------------------------- ##
|
|
## %yacc vs. %define api.value.type union. ##
|
|
## ---------------------------------------- ##
|
|
|
|
AT_SETUP([[%yacc vs. %define api.value.type union]])
|
|
|
|
AT_DATA([[input.y]],
|
|
[[%yacc
|
|
%define api.value.type union
|
|
%%
|
|
exp: %empty;
|
|
]])
|
|
|
|
AT_BISON_CHECK([[input.y]], [[1]], [[]],
|
|
[[input.y:2.9-22: error: '%yacc' and '%define api.value.type "union"' cannot be used together
|
|
]])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
## ---------------- ##
|
|
## api.value.type. ##
|
|
## ---------------- ##
|
|
|
|
# _AT_TEST($1: BISON-DIRECTIVES,
|
|
# $2: MORE-BISON-DIRECTIVES,
|
|
# $3: PARSER-ACTION,
|
|
# $4: INPUT,
|
|
# $5: SCANNER-ACTION,
|
|
# $6: RESULT,
|
|
# $7: REQUIREMENT)
|
|
# --------------------------------------
|
|
# Compile the grammar and check the expected result.
|
|
# BISON-DIRECTIVES are passed to AT_SETUP, contrary to MORE-BISON-DIRECTIVES.
|
|
#
|
|
# Use REQUIREMENT e.g. skip the test if the compiler does not meet the
|
|
# requirements.
|
|
m4_pushdef([_AT_TEST],
|
|
[
|
|
AT_SETUP([$1])
|
|
AT_KEYWORDS([api.value.type])
|
|
|
|
AT_BISON_OPTION_PUSHDEFS([%debug $1 $2])
|
|
AT_DATA_GRAMMAR([test.y],
|
|
[[%debug
|
|
|
|
%code
|
|
{
|
|
# include <stdio.h>
|
|
# include <stdlib.h>
|
|
]AT_YYERROR_DECLARE[
|
|
]AT_YYLEX_DECLARE[
|
|
}
|
|
|
|
]$1[
|
|
]$2[
|
|
|
|
%%
|
|
|
|
start: $3;
|
|
|
|
%%
|
|
]AT_YYERROR_DEFINE[
|
|
]AT_YYLEX_DEFINE([$4], [$5])[
|
|
]AT_MAIN_DEFINE[
|
|
]])
|
|
|
|
AT_LANG_FOR_EACH_STD([
|
|
$7
|
|
AT_FULL_COMPILE([[test]])
|
|
AT_PARSER_CHECK([[./test]], 0, [[$6
|
|
]])
|
|
])
|
|
|
|
AT_BISON_OPTION_POPDEFS
|
|
AT_CLEANUP
|
|
])
|
|
|
|
# AT_TEST($1: BISON-DIRECTIVES,
|
|
# $2: MORE-BISON-DIRECTIVES,
|
|
# $3: PARSER-ACTION,
|
|
# $4: INPUT,
|
|
# $5: SCANNER-ACTION,
|
|
# $6: RESULT,
|
|
# $7: REQUIREMENT)
|
|
# --------------------------------------
|
|
# Check with and without %defines, to avoid regressions. It turns out
|
|
# that in that case yacc.c calls the set-up of the %union twice,
|
|
# because YYSTYPE is defined once in the header, and once in the
|
|
# implementation file (eventually it'd be better to include the header
|
|
# file, but that's another story). Unfortunately running these macros
|
|
# a second time doubled the side-effects and resulted in a double
|
|
# definition of the union members.
|
|
m4_pushdef([AT_TEST],
|
|
[_AT_TEST([$1], [$2], [$3], [$4], [$5], [$6], [$7])
|
|
_AT_TEST([$1 %defines], [$2], [$3], [$4], [$5], [$6], [$7])
|
|
])
|
|
|
|
m4_foreach([b4_skel], [[yacc.c], [glr.c], [lalr1.cc], [glr.cc]],
|
|
[# A built-in type.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type {double}],
|
|
[],
|
|
['1' '2' { printf ("%2.1f\n", $1 + $2); }],
|
|
["12"],
|
|
[if (res)
|
|
AT_VAL = (res - '0') / 10.0],
|
|
[0.3])
|
|
|
|
# A typedef which looks like a Bison keyword, but it's using braces.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type {variant}],
|
|
[%code requires { typedef double variant; }],
|
|
['1' '2' { printf ("%2.1f\n", $1 + $2); }],
|
|
["12"],
|
|
[if (res)
|
|
AT_VAL = (res - '0') / 10.0],
|
|
[0.3])
|
|
|
|
# A user defined struct.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type {struct foo}],
|
|
[%code requires { struct foo { float fval; int ival; }; }],
|
|
['1' '2'
|
|
{ printf ("%d %2.1f\n", $1.ival + $2.ival, $1.fval + $2.fval); }],
|
|
["12"],
|
|
[if (res)
|
|
{
|
|
AT_VAL.ival = (res - '0') * 10;
|
|
AT_VAL.fval = (float) (res - '0') / 10.f;
|
|
}],
|
|
[30 0.3])
|
|
|
|
# A user defined struct that uses pointers.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type {struct bar}],
|
|
[%code requires
|
|
{
|
|
struct u
|
|
{
|
|
int ival;
|
|
};
|
|
struct bar
|
|
{
|
|
struct u *up;
|
|
};
|
|
}
|
|
%token <up->ival> '1' '2'
|
|
%printer { ]AT_CXX_IF([[yyo << $$]],
|
|
[[fprintf (yyo, "%d", $$)]])[; } <up->ival>
|
|
],
|
|
['1' '2'
|
|
{
|
|
printf ("%d %d\n", $1, $<up->ival>2);
|
|
free ($<up>1);
|
|
free ($<up>2);
|
|
}],
|
|
["12"],
|
|
[if (res)
|
|
{
|
|
AT_VAL.up = (struct u *) malloc (sizeof *AT_VAL.up);
|
|
assert (AT_VAL.up);
|
|
AT_VAL.up->ival = res - '0';
|
|
}
|
|
],
|
|
[1 2])
|
|
|
|
# A user defined union.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type {union foo}],
|
|
[%code requires { union foo { float fval; int ival; }; }],
|
|
['1' '2' { printf ("%d %2.1f\n", $1.ival, $2.fval); }],
|
|
["12"],
|
|
[if (res == '1')
|
|
AT_VAL.ival = 10;
|
|
else if (res == '2')
|
|
AT_VAL.fval = .2f],
|
|
[10 0.2])
|
|
|
|
# A %union and a named %union. In C++ named %union is an error.
|
|
m4_foreach([b4_union],
|
|
[m4_bmatch(b4_skel, [\.cc$],
|
|
[[%union]],
|
|
[[%union], [%union foo],
|
|
[%define api.value.union.name foo; %union]])],
|
|
[AT_TEST([%skeleton "]b4_skel["
|
|
]b4_union[ { float fval; int ival; };],
|
|
[%token <ival> '1';
|
|
%token <fval> '2';],
|
|
['1' '2' { printf ("%d %2.1f\n", $1, $2); }],
|
|
["12"],
|
|
[if (res == '1')
|
|
AT_VAL.ival = 10;
|
|
else if (res == '2')
|
|
AT_VAL.fval = 0.2f],
|
|
[10 0.2])])
|
|
|
|
# A Bison-defined union.
|
|
# The tokens names are not available directly in C++, we use their
|
|
# user number to keep it simple between C and C++.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type union],
|
|
[%token <int> ONE 101;
|
|
%token <float> TWO 102 THREE 103;
|
|
%printer { ]AT_CXX_IF([[yyo << $$]],
|
|
[[fprintf (yyo, "%d", $$)]])[; } <int>
|
|
%printer { ]AT_CXX_IF([[yyo << $$]],
|
|
[[fprintf (yyo, "%f", $$)]])[; } <float>
|
|
],
|
|
[ONE TWO THREE { printf ("%d %2.1f %2.1f\n", $1, $2, $3); }],
|
|
[{ 101, 102, 103, EOF }],
|
|
[if (res == 101)
|
|
AT_VAL.ONE = 10;
|
|
else if (res == 102)
|
|
AT_VAL.TWO = .2f;
|
|
else if (res == 103)
|
|
AT_VAL.THREE = 3.3f],
|
|
[10 0.2 3.3])
|
|
|
|
# A Bison-defined variant, for lalr1.cc only.
|
|
m4_if(b4_skel, [lalr1.cc], [
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type variant],
|
|
[%token <int> '1';
|
|
%token <std::string> '2';],
|
|
['1' '2' { std::cout << $1 << ", " << $2 << '\n'; }],
|
|
["12"],
|
|
[if (res == '1')
|
|
AT_VAL.build (10);
|
|
else if (res == '2')
|
|
AT_VAL.build<std::string> ("two");],
|
|
[10, two])
|
|
|
|
# Test a regression where we passed user types (we can include
|
|
# commas) to a CPP macro.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type variant],
|
|
[%token <std::pair<int, int>> '1';
|
|
%token <std::pair<std::string, std::string>> '2';],
|
|
['1' '2'
|
|
{
|
|
std::cout << $1.first << ':' << $1.second << ", "
|
|
<< $2.first << ':' << $2.second << '\n';
|
|
}],
|
|
["12"],
|
|
[if (res == '1')
|
|
AT_VAL.build (std::make_pair (10, 11));
|
|
else if (res == '2')
|
|
AT_VAL.build (std::pair<std::string, std::string> ("two", "deux"));],
|
|
[10:11, two:deux])
|
|
|
|
# Type-based token constructors on move-only types, and types with commas.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%define api.value.type variant
|
|
%define api.token.constructor],
|
|
[[%token <std::pair<int, int>> '1' '2';]],
|
|
['1' '2'
|
|
{
|
|
std::cout << $1.first << ':' << $1.second << ", "
|
|
<< $2.first << ':' << $2.second << '\n';
|
|
}],
|
|
["12"],
|
|
[[typedef yy::parser::symbol_type symbol;
|
|
if (res)
|
|
return symbol (res, std::make_pair (res - '0', res - '0' + 1));
|
|
else
|
|
return symbol (res)]],
|
|
[1:2, 2:3])
|
|
|
|
# Move-only types, and variadic emplace.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%code requires { #include <memory> }
|
|
%define api.value.type variant],
|
|
[[%token <std::unique_ptr<int>> '1';
|
|
%token <std::pair<int, int>> '2';]],
|
|
['1' '2' { std::cout << *$1 << ", "
|
|
<< $2.first << ':' << $2.second << '\n'; }],
|
|
["12"],
|
|
[[if (res == '1')
|
|
]AT_VAL[.emplace <std::unique_ptr<int>>
|
|
(std::make_unique <int> (10));
|
|
else if (res == '2')
|
|
]AT_VAL[.emplace <std::pair<int, int>> (21, 22);]],
|
|
[10, 21:22],
|
|
[AT_REQUIRE_CXX_STD(14, [echo "$at_std not supported"; continue])])
|
|
|
|
# Token constructors on move-only types, and types with commas.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%code requires { #include <memory> }
|
|
%define api.value.type variant
|
|
%define api.token.constructor],
|
|
[[%token <std::unique_ptr<int>> ONE;
|
|
%token <std::pair<int, int>> TWO;
|
|
%token EOI 0;]],
|
|
[ONE TWO { std::cout << *$1 << ", "
|
|
<< $2.first << ':' << $2.second << '\n'; }],
|
|
["12"],
|
|
[[if (res == '1')
|
|
return yy::parser::make_ONE (std::make_unique<int> (10));
|
|
else if (res == '2')
|
|
return yy::parser::make_TWO (std::make_pair (21, 22));
|
|
else
|
|
return yy::parser::make_EOI ()]],
|
|
[10, 21:22],
|
|
[AT_REQUIRE_CXX_STD(14, [echo "$at_std not supported"; continue])])
|
|
|
|
# Type-based token constructors on move-only types, and types with commas.
|
|
AT_TEST([%skeleton "]b4_skel["
|
|
%code requires { #include <memory> }
|
|
%define api.value.type variant
|
|
%define api.token.constructor],
|
|
[[%token <std::unique_ptr<int>> '1';
|
|
%token <std::pair<int, int>> '2';]],
|
|
['1' '2' { std::cout << *$1 << ", "
|
|
<< $2.first << ':' << $2.second << '\n'; }],
|
|
["12"],
|
|
[[if (res == '1')
|
|
return {res, std::make_unique<int> (10)};
|
|
else if (res == '2')
|
|
return {res, std::make_pair (21, 22)};
|
|
else
|
|
return res]],
|
|
[10, 21:22],
|
|
[AT_REQUIRE_CXX_STD(14, [echo "$at_std not supported"; continue])])
|
|
|
|
])
|
|
])
|
|
|
|
m4_popdef([AT_TEST])
|
|
m4_popdef([_AT_TEST])
|
|
|
|
|
|
## ------------------- ##
|
|
## C++: Named %union. ##
|
|
## ------------------- ##
|
|
|
|
m4_foreach([b4_skel], [[lalr1.cc], [glr.cc]],
|
|
[AT_SETUP([b4_skel: Named %union])
|
|
AT_DATA([input.y],
|
|
[%skeleton "]b4_skel["
|
|
%union foo { float fval; int ival; };
|
|
%%
|
|
exp: %empty;
|
|
])
|
|
AT_BISON_CHECK([input.y], 1, [],
|
|
[[input.y:2.8-10: error: named %union is invalid in C++
|
|
]])
|
|
AT_CLEANUP
|
|
])
|