X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/a68b1f237e63c96ee905916424013f79d01908ba..be29c71dd8867cca0c1aab4cf3ef9d4d4d0cb7b6:/data/c.m4 diff --git a/data/c.m4 b/data/c.m4 index 136b46e1..b0524ef3 100644 --- a/data/c.m4 +++ b/data/c.m4 @@ -2,7 +2,7 @@ # C M4 Macros for Bison. -# Copyright (C) 2002, 2004-2012 Free Software Foundation, Inc. +# Copyright (C) 2002, 2004-2013 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 @@ -51,12 +51,6 @@ m4_define([b4_cpp_guard_close], ## Identification. ## ## ---------------- ## -# b4_comment(TEXT) -# ---------------- -m4_define([b4_comment], [/* m4_bpatsubst([$1], [ -], [ - ]) */]) - # b4_identification # ----------------- # Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or @@ -110,10 +104,27 @@ m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE]) ## Pure/impure interfaces. ## ## ------------------------ ## +# b4_lex_formals +# -------------- +# All the yylex formal arguments. +# b4_lex_param arrives quoted twice, but we want to keep only one level. +m4_define([b4_lex_formals], +[b4_pure_if([[[[YYSTYPE *yylvalp]], [[&yylval]]][]dnl +b4_locations_if([, [[YYLTYPE *yyllocp], [&yylloc]]])])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param)]) + + +# b4_lex +# ------ +# Call yylex. +m4_define([b4_lex], +[b4_function_call([yylex], [int], b4_lex_formals)]) + + # b4_user_args # ------------ m4_define([b4_user_args], -[m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])]) +[m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])]) # b4_parse_param @@ -137,11 +148,13 @@ m4_popdef([$2])dnl m4_popdef([$1])dnl ])]) -# b4_parse_param_use -# ------------------ -# `YYUSE' all the parse-params. +# b4_parse_param_use([VAL], [LOC]) +# -------------------------------- +# 'YYUSE' VAL, LOC if locations are enabled, and all the parse-params. m4_define([b4_parse_param_use], -[b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); +[m4_ifvaln([$1], [ YYUSE ([$1]);])dnl +b4_locations_if([m4_ifvaln([$2], [ YYUSE ([$2]);])])dnl +b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); ])dnl ]) @@ -163,13 +176,13 @@ m4_define([b4_int_type], m4_eval([0 <= $1]), [1], [unsigned int], - [int])]) + [int])]) # b4_int_type_for(NAME) # --------------------- # Return the smallest int type able to handle numbers ranging from -# `NAME_min' to `NAME_max' (included). +# 'NAME_min' to 'NAME_max' (included). m4_define([b4_int_type_for], [b4_int_type($1_min, $1_max)]) @@ -178,15 +191,77 @@ m4_define([b4_int_type_for], # -------------------------------------------- # Without inducing a comparison warning from the compiler, check if the # literal value LITERAL equals VALUE from table TABLE, which must have -# TABLE_min and TABLE_max defined. YYID must be defined as an identity -# function that suppresses warnings about constant conditions. +# TABLE_min and TABLE_max defined. m4_define([b4_table_value_equals], [m4_if(m4_eval($3 < m4_indir([b4_]$1[_min]) || m4_indir([b4_]$1[_max]) < $3), [1], - [[YYID (0)]], + [[0]], [(!!(($2) == ($3)))])]) +## ----------------- ## +## Compiler issues. ## +## ----------------- ## + +# b4_attribute_define +# ------------------- +# Provide portable compiler "attributes". +m4_define([b4_attribute_define], +[#ifndef YY_ATTRIBUTE +# if (defined __GNUC__ \ + && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ + || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C +# define YY_ATTRIBUTE(Spec) __attribute__(Spec) +# else +# define YY_ATTRIBUTE(Spec) /* empty */ +# endif +#endif + +#ifndef YY_ATTRIBUTE_PURE +# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) +#endif + +#if !defined _Noreturn \ + && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) +# if defined _MSC_VER && 1200 <= _MSC_VER +# define _Noreturn __declspec (noreturn) +# else +# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(E) ((void) (E)) +#else +# define YYUSE(E) /* empty */ +#endif + +#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif +]) + + ## ---------## ## Values. ## ## ---------## @@ -194,14 +269,14 @@ m4_define([b4_table_value_equals], # b4_null_define # -------------- -# Portability issues: define a YY_NULL appropriate for the current +# Portability issues: define a YY_NULLPTR appropriate for the current # language (C, C++98, or C++11). m4_define([b4_null_define], -[# ifndef YY_NULL +[# ifndef YY_NULLPTR # if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULL nullptr +# define YY_NULLPTR nullptr # else -# define YY_NULL 0 +# define YY_NULLPTR 0 # endif # endif[]dnl ]) @@ -210,168 +285,125 @@ m4_define([b4_null_define], # b4_null # ------- # Return a null pointer constant. -m4_define([b4_null], [YY_NULL]) +m4_define([b4_null], [YY_NULLPTR]) +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "yy" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_comment([$3], [ ])])dnl +static const b4_int_type_for([$2]) yy$1[[]] = +{ + $2 +};dnl +]) ## ------------------------- ## ## Assigning token numbers. ## ## ------------------------- ## -# b4_token_define(TOKEN-NAME, TOKEN-NUMBER) -# ----------------------------------------- +# b4_token_define(TOKEN-NUM) +# -------------------------- # Output the definition of this token as #define. m4_define([b4_token_define], -[#define $1 $2 -]) - +[b4_token_format([#define %s %s], [$1])]) -# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ------------------------------------------------------- -# Output the definition of the tokens (if there are) as #defines. +# b4_token_defines +# ---------------- +# Output the definition of the tokens. m4_define([b4_token_defines], -[m4_if([$#$1], [1], [], -[/* Tokens. */ -m4_map([b4_token_define], [$@])]) -]) +[b4_any_token_visible_if([/* Tokens. */ +m4_join([ +], b4_symbol_map([b4_token_define])) +])]) -# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) -# --------------------------------------- +# b4_token_enum(TOKEN-NUM) +# ------------------------ # Output the definition of this token as an enum. m4_define([b4_token_enum], -[$1 = $2]) +[b4_token_format([%s = %s], [$1])]) -# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ----------------------------------------------------- +# b4_token_enums +# -------------- # Output the definition of the tokens (if there are) as enums. m4_define([b4_token_enums], -[m4_if([$#$1], [1], [], -[[/* Tokens. */ +[b4_any_token_visible_if([[/* Token type. */ #ifndef ]b4_api_PREFIX[TOKENTYPE # define ]b4_api_PREFIX[TOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum ]b4_api_prefix[tokentype { -]m4_map_sep([ b4_token_enum], [, -], - [$@])[ - }; + enum ]b4_api_prefix[tokentype + { + ]m4_join([, + ], + b4_symbol_map([b4_token_enum]))[ + }; #endif ]])]) -# b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ------------------------------------------------------------- -# Output the definition of the tokens (if there are any) as enums and, if POSIX -# Yacc is enabled, as #defines. +# b4_token_enums_defines +# ---------------------- +# Output the definition of the tokens (if there are any) as enums and, +# if POSIX Yacc is enabled, as #defines. m4_define([b4_token_enums_defines], -[b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], []) -]) +[b4_token_enums[]b4_yacc_if([b4_token_defines])]) +## ----------------- ## +## Semantic Values. ## +## ----------------- ## -## --------------------------------------------- ## -## Defining C functions in both K&R and ANSI-C. ## -## --------------------------------------------- ## +# b4_symbol_value(VAL, [TYPE]) +# ---------------------------- +# Given a semantic value VAL ($$, $1 etc.), extract its value of type +# TYPE if TYPE is given, otherwise just return VAL. The result can be +# used safetly, it is put in parens to avoid nasty precedence issues. +# TYPE is *not* put in braces, provide some if needed. +m4_define([b4_symbol_value], +[($1[]m4_ifval([$2], [.$2]))]) -# b4_modern_c -# ----------- -# A predicate useful in #if to determine whether C is ancient or modern. -# -# If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run -# as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic -# reasons, but it defines __C99__FUNC__ so check that as well. -# Microsoft C normally doesn't define these macros, but it defines _MSC_VER. -# Consider a C++ compiler to be modern if it defines __cplusplus. -# -m4_define([b4_c_modern], - [[(defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER)]]) -# b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# ---------------------------------------------------------- -# Declare the function NAME. -m4_define([b4_c_function_def], -[#if b4_c_modern -b4_c_ansi_function_def($@) -#else -$2 -$1 (b4_c_knr_formal_names(m4_shift2($@))) -b4_c_knr_formal_decls(m4_shift2($@)) -#endif[]dnl -]) +## ---------------------- ## +## Defining C functions. ## +## ---------------------- ## -# b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# --------------------------------------------------------------- -# Declare the function NAME in ANSI. -m4_define([b4_c_ansi_function_def], + +# b4_function_define(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ----------------------------------------------------------- +# Declare the function NAME in C. +m4_define([b4_function_define], [$2 -$1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl +$1 (b4_formals(m4_shift2($@)))[]dnl ]) -# b4_c_ansi_formals([DECL1, NAME1], ...) -# -------------------------------------- -# Output the arguments ANSI-C definition. -m4_define([b4_c_ansi_formals], +# b4_formals([DECL1, NAME1], ...) +# ------------------------------- +# The formal arguments of a C function definition. +m4_define([b4_formals], [m4_if([$#], [0], [void], [$#$1], [1], [void], - [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) + [m4_map_sep([b4_formal], [, ], [$@])])]) -m4_define([b4_c_ansi_formal], +m4_define([b4_formal], [$1]) -# b4_c_knr_formal_names([DECL1, NAME1], ...) -# ------------------------------------------ -# Output the argument names. -m4_define([b4_c_knr_formal_names], -[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) - -m4_define([b4_c_knr_formal_name], -[$2]) - - -# b4_c_knr_formal_decls([DECL1, NAME1], ...) -# ------------------------------------------ -# Output the K&R argument declarations. -m4_define([b4_c_knr_formal_decls], -[m4_map_sep([b4_c_knr_formal_decl], - [ -], - [$@])]) - -m4_define([b4_c_knr_formal_decl], -[ $1;]) +## ----------------------- ## +## Declaring C functions. ## +## ----------------------- ## -## ------------------------------------------------------------ ## -## Declaring (prototyping) C functions in both K&R and ANSI-C. ## -## ------------------------------------------------------------ ## - - -# b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# ----------------------------------------------------------- -# Declare the function NAME. -m4_define([b4_c_function_decl], -[#if defined __STDC__ || defined __cplusplus -b4_c_ansi_function_decl($@) -#else -$2 $1 (); -#endif[]dnl -]) - - -# b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# ---------------------------------------------------------------- +# b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ------------------------------------------------------------ # Declare the function NAME. -m4_define([b4_c_ansi_function_decl], -[$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl +m4_define([b4_function_declare], +[$2 $1 (b4_formals(m4_shift2($@)));[]dnl ]) @@ -382,21 +414,21 @@ m4_define([b4_c_ansi_function_decl], ## --------------------- ## -# b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# b4_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) # ----------------------------------------------------------- # Call the function NAME with arguments NAME1, NAME2 etc. -m4_define([b4_c_function_call], -[$1 (b4_c_args(m4_shift2($@)))[]dnl +m4_define([b4_function_call], +[$1 (b4_args(m4_shift2($@)))[]dnl ]) -# b4_c_args([DECL1, NAME1], ...) -# ------------------------------ +# b4_args([DECL1, NAME1], ...) +# ---------------------------- # Output the arguments NAME1, NAME2... -m4_define([b4_c_args], -[m4_map_sep([b4_c_arg], [, ], [$@])]) +m4_define([b4_args], +[m4_map_sep([b4_arg], [, ], [$@])]) -m4_define([b4_c_arg], +m4_define([b4_arg], [$2]) @@ -405,7 +437,7 @@ m4_define([b4_c_arg], ## ----------- ## # b4_sync_start(LINE, FILE) -# ----------------------- +# ------------------------- m4_define([b4_sync_start], [[#]line $1 $2]) @@ -418,39 +450,28 @@ m4_define([b4_sync_start], [[#]line $1 $2]) m4_define([b4_case], [ case $1: $2 +b4_syncline([@oline@], [@ofile@]) break;]) -# b4_symbol_actions(FILENAME, LINENO, -# SYMBOL-TAG, SYMBOL-NUM, -# SYMBOL-ACTION, SYMBOL-TYPENAME) -# ------------------------------------------------- -# Issue the code for a symbol action (e.g., %printer). -# -# Define b4_dollar_dollar([TYPE-NAME]), and b4_at_dollar, which are -# invoked where $$ and @$ were specified by the user. -m4_define([b4_symbol_actions], -[b4_dollar_pushdef([(*yyvaluep)], [$6], [(*yylocationp)])dnl - case $4: /* $3 */ -b4_syncline([$2], [$1]) - $5; + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], +[ case $1: + if (! ($2)) YYERROR; b4_syncline([@oline@], [@ofile@]) - break; -b4_dollar_popdef[]dnl -]) + break;]) -# b4_yydestruct_generate(FUNCTION-DECLARATOR) -# ------------------------------------------- -# Generate the "yydestruct" function, which declaration is issued using -# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C -# or "b4_c_function_def" for K&R. -m4_define_default([b4_yydestruct_generate], +# b4_yydestruct_define +# -------------------- +# Define the "yydestruct" function. +m4_define_default([b4_yydestruct_define], [[/*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ -/*ARGSUSED*/ -]$1([yydestruct], +]b4_function_define([yydestruct], [static void], [[const char *yymsg], [yymsg]], [[int yytype], [yytype]], @@ -458,64 +479,47 @@ m4_define_default([b4_yydestruct_generate], b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl m4_ifset([b4_parse_param], [, b4_parse_param]))[ { - YYUSE (yyvaluep); -]b4_locations_if([ YYUSE (yylocationp); -])dnl -b4_parse_param_use[]dnl -[ - if (!yymsg) +]b4_parse_param_use([yyvaluep], [yylocationp])dnl +[ if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); - switch (yytype) - { -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ - default: - break; - } + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + ]b4_symbol_actions([destructor])[ + YY_IGNORE_MAYBE_UNINITIALIZED_END }]dnl ]) -# b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) -# ------------------------------------------------ -# Generate the "yy_symbol_print" function, which declaration is issued using -# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C -# or "b4_c_function_def" for K&R. -m4_define_default([b4_yy_symbol_print_generate], +# b4_yy_symbol_print_define +# ------------------------- +# Define the "yy_symbol_print" function. +m4_define_default([b4_yy_symbol_print_define], [[ -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +/*----------------------------------------. +| Print this symbol's value on YYOUTPUT. | +`----------------------------------------*/ -/*ARGSUSED*/ -]$1([yy_symbol_value_print], +]b4_function_define([yy_symbol_value_print], [static void], - [[FILE *yyoutput], [yyoutput]], - [[int yytype], [yytype]], - [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl + [[FILE *yyoutput], [yyoutput]], + [[int yytype], [yytype]], + [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl m4_ifset([b4_parse_param], [, b4_parse_param]))[ { FILE *yyo = yyoutput; - YYUSE (yyo); - if (!yyvaluep) - return; -]b4_locations_if([ YYUSE (yylocationp); -])dnl -b4_parse_param_use[]dnl -[# ifdef YYPRINT +]b4_parse_param_use([yyo], [yylocationp])dnl +[ if (!yyvaluep) + return;] +dnl glr.c does not feature yytoknum. +m4_if(b4_skeleton, ["yacc.c"], +[[# ifdef YYPRINT if (yytype < YYNTOKENS) YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); -# else - YYUSE (yyoutput); # endif - switch (yytype) - { -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl -[ default: - break; - } +]])dnl + b4_symbol_actions([printer])[ } @@ -523,18 +527,16 @@ b4_parse_param_use[]dnl | Print this symbol on YYOUTPUT. | `--------------------------------*/ -]$1([yy_symbol_print], +]b4_function_define([yy_symbol_print], [static void], - [[FILE *yyoutput], [yyoutput]], - [[int yytype], [yytype]], - [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl + [[FILE *yyoutput], [yyoutput]], + [[int yytype], [yytype]], + [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl m4_ifset([b4_parse_param], [, b4_parse_param]))[ { - if (yytype < YYNTOKENS) - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + YYFPRINTF (yyoutput, "%s %s (", + yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); ]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); YYFPRINTF (yyoutput, ": "); @@ -545,63 +547,205 @@ b4_locations_if([, yylocationp])[]b4_user_args[); }]dnl ]) + +## ---------------- ## +## api.value.type. ## +## ---------------- ## + + +# ---------------------- # +# api.value.type=union. # +# ---------------------- # + +# b4_symbol_type_register(SYMBOL-NUM) +# ----------------------------------- +# Symbol SYMBOL-NUM has a type (for variant) instead of a type-tag. +# Extend the definition of %union's body with a field of that type, +# and extend the symbol's "type" field to point to the field name, +# instead of the type name. +m4_define([b4_symbol_type_register], +[m4_define([b4_symbol($1, type_tag)], + [b4_symbol_if([$1], [has_id], + [b4_symbol([$1], [id])], + [yytype_[]b4_symbol([$1], [number])])])dnl +m4_append([b4_user_union_members], +m4_expand([ + b4_symbol_tag_comment([$1])dnl + b4_symbol([$1], [type]) b4_symbol([$1], [type_tag]);])) +]) + + +# b4_type_define_tag(SYMBOL1-NUM, ...) +# ------------------------------------ +# For the batch of symbols SYMBOL1-NUM... (which all have the same +# type), enhance the %union definition for each of them, and set +# there "type" field to the field tag name, instead of the type name. +m4_define([b4_type_define_tag], +[b4_symbol_if([$1], [has_type], + [m4_map([b4_symbol_type_register], [$@])]) +]) + + +# b4_symbol_value_union(VAL, [TYPE]) +# ---------------------------------- +# Same of b4_symbol_value, but when api.value.type=union. +m4_define([b4_symbol_value_union], +[m4_ifval([$2], + [(*($2*)(&$1))], + [$1])]) +]) + + +# b4_value_type_setup_union +# ------------------------- +# Setup support for api.value.type=union. Symbols are defined with a +# type instead of a union member name: build the corresponding union, +# and give the symbols their tag. +m4_define([b4_value_type_setup_union], +[m4_define([b4_union_members]) +b4_type_foreach([b4_type_define_tag]) +m4_copy_force([b4_symbol_value_union], [b4_symbol_value]) +]) + + +# ---------------- # +# api.value.type. # +# ---------------- # + + +# b4_value_type_setup_variant +# --------------------------- +# Setup support for api.value.type=variant. By default, fail, specialized +# by other skeletons. +m4_define([b4_value_type_setup_variant], +[b4_complain_at(b4_percent_define_get_loc([[api.value.type]]), + [['%s' does not support '%s']], + [b4_skeleton], + [%define api.value.type variant])]) + + +# _b4_value_type_setup_keyword +# ---------------------------- +# api.value.type is defined with a keyword/string syntax. Check if +# that is properly defined, and prepare its use. +m4_define([_b4_value_type_setup_keyword], +[b4_percent_define_check_values([[[[api.value.type]], + [[none]], + [[union]], + [[union-directive]], + [[variant]], + [[yystype]]]])dnl +m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_value_type_setup_union], + [variant], [b4_value_type_setup_variant])]) + + +# b4_value_type_setup +# ------------------- +# Check if api.value.type is properly defined, and possibly prepare +# its use. +b4_define_silent([b4_value_type_setup], +[# Define default value. +b4_percent_define_ifdef([[api.value.type]], [], +[# %union => api.value.type=union-directive +m4_ifdef([b4_union_members], +[m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [union-directive])], +[# no tag seen => api.value.type={int} +m4_if(b4_tag_seen_flag, 0, +[m4_define([b4_percent_define_kind(api.value.type)], [code]) +m4_define([b4_percent_define(api.value.type)], [int])], +[# otherwise api.value.type=yystype +m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [yystype])])])]) + +# Set up. +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), + [keyword\|string], [_b4_value_type_setup_keyword]) +]) + + ## -------------- ## ## Declarations. ## ## -------------- ## -# b4_declare_yylstype -# ------------------- -# Declarations that might either go into the header (if --defines) or -# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc. -m4_define([b4_declare_yylstype], + +# b4_value_type_define +# -------------------- +m4_define([b4_value_type_define], +[b4_value_type_setup[]dnl +/* Value type. */ +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), +[code], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +typedef ]b4_percent_define_get([[api.value.type]])[ ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif +]], +[m4_bmatch(b4_percent_define_get([[api.value.type]]), +[union\|union-directive], [[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED -]m4_ifdef([b4_stype], -[[typedef union ]b4_union_name[ +typedef union ]b4_union_name[ ]b4_api_PREFIX[STYPE; +union ]b4_union_name[ { -]b4_user_stype[ -} ]b4_api_PREFIX[STYPE; -# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]], -[m4_if(b4_tag_seen_flag, 0, -[[typedef int ]b4_api_PREFIX[STYPE; -# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]])])[ -# define ]b4_api_prefix[stype ]b4_api_PREFIX[STYPE /* obsolescent; will be withdrawn */ +]b4_user_union_members[ +}; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 # define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 -#endif]b4_locations_if([[ +#endif +]])])]) + +# b4_location_type_define +# ----------------------- +m4_define([b4_location_type_define], +[[/* Location type. */ #if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED -typedef struct ]b4_api_PREFIX[LTYPE +typedef struct ]b4_api_PREFIX[LTYPE ]b4_api_PREFIX[LTYPE; +struct ]b4_api_PREFIX[LTYPE { int first_line; int first_column; int last_line; int last_column; -} ]b4_api_PREFIX[LTYPE; -# define ]b4_api_prefix[ltype ]b4_api_PREFIX[LTYPE /* obsolescent; will be withdrawn */ +}; # define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 # define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 -#endif]]) +#endif +]]) + + +# b4_declare_yylstype +# ------------------- +# Declarations that might either go into the header (if --defines) or +# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc. +m4_define([b4_declare_yylstype], +[b4_value_type_define[]b4_locations_if([ +b4_location_type_define]) b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval; ]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl ]) + # b4_YYDEBUG_define -# ------------------ +# ----------------- m4_define([b4_YYDEBUG_define], -[[/* Enabling traces. */ +[[/* Debug traces. */ ]m4_if(b4_api_prefix, [yy], [[#ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ +# define YYDEBUG ]b4_parse_trace_if([1], [0])[ #endif]], [[#ifndef ]b4_api_PREFIX[DEBUG # if defined YYDEBUG -# if YYDEBUG +#if YYDEBUG # define ]b4_api_PREFIX[DEBUG 1 # else # define ]b4_api_PREFIX[DEBUG 0 # endif # else /* ! defined YYDEBUG */ -# define ]b4_api_PREFIX[DEBUG ]b4_debug_flag[ +# define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[ # endif /* ! defined YYDEBUG */ #endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl ]) @@ -626,7 +770,7 @@ m4_define([b4_yylloc_default_define], #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ do \ - if (YYID (N)) \ + if (N) \ { \ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ @@ -640,16 +784,70 @@ m4_define([b4_yylloc_default_define], (Current).first_column = (Current).last_column = \ YYRHSLOC (Rhs, 0).last_column; \ } \ - while (YYID (0)) + while (0) #endif ]]) -# b4_yyloc_default_define -# ------------------------ -# Define yyloc_default, which can be used to initialize location -# variables. -m4_define([b4_yyloc_default_define], -[[static YYLTYPE yyloc_default +# b4_yy_location_print_define +# --------------------------- +# Define YY_LOCATION_PRINT. +m4_define([b4_yy_location_print_define], +[b4_locations_if([[ +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + +/* Print *YYLOCP on YYO. Private, do not rely on its existence. */ + +YY_ATTRIBUTE_UNUSED +]b4_function_define([yy_location_print_], + [static unsigned], + [[FILE *yyo], [yyo]], + [[YYLTYPE const * const yylocp], [yylocp]])[ +{ + unsigned res = 0; + int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; + if (0 <= yylocp->first_line) + { + res += YYFPRINTF (yyo, "%d", yylocp->first_line); + if (0 <= yylocp->first_column) + res += YYFPRINTF (yyo, ".%d", yylocp->first_column); + } + if (0 <= yylocp->last_line) + { + if (yylocp->first_line < yylocp->last_line) + { + res += YYFPRINTF (yyo, "-%d", yylocp->last_line); + if (0 <= end_col) + res += YYFPRINTF (yyo, ".%d", end_col); + } + else if (0 <= end_col && yylocp->first_column < end_col) + res += YYFPRINTF (yyo, "-%d", end_col); + } + return res; + } + +# define YY_LOCATION_PRINT(File, Loc) \ + yy_location_print_ (File, &(Loc)) + +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif]], +[[/* This macro is provided for backward compatibility. */ +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif]]) +]) + +# b4_yyloc_default +# ---------------- +# Expand to a possible default value for yylloc. +m4_define([b4_yyloc_default], +[[ # if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL = { ]m4_join([, ], m4_defn([b4_location_initial_line]), @@ -657,5 +855,4 @@ m4_define([b4_yyloc_default_define], m4_defn([b4_location_initial_line]), m4_defn([b4_location_initial_column]))[ } # endif - ;]dnl -]) +]])