Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-28 21:53:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

skeletons: renamings after knr removal

Browse Source 
* data/c.m4 (b4_c_comment_, b4_c_args, b4_c_function_def)
(b4_c_function_decl, b4_c_formals, b4_c_call, b4_c_arg): Rename as...
(b4_comment, b4_args, b4_function_define, b4_function_declare,
b4_formals, b4_function_call, b4_arg): these.
* data/glr.c, data/glr.cc, data/lalr1.cc, data/yacc.c: Adjust.
This commit is contained in:
Akim Demaille
2012-08-02 14:11:04 +02:00
parent 710c4a6571
commit 15f6666958
5 changed files with 68 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
data/c.m4
View File

@@ -50,7 +50,7 @@ m4_define([b4_cpp_guard_close],
## ---------------- ## ## ---------------- ##
# b4_comment_(TEXT, OPEN, CONTINUE, END) # b4_comment_(TEXT, OPEN, CONTINUE, END)
# ------------------------------------- # --------------------------------------
# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. # Put TEXT in comment. Avoid trailing spaces: don't indent empty lines.
# Avoid adding indentation to the first line, as the indentation comes # Avoid adding indentation to the first line, as the indentation comes
# from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]). # from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]).
@@ -61,23 +61,17 @@ m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [
$3\1])$4]) $3\1])$4])
# b4_c_comment(TEXT, [PREFIX]) # b4_comment(TEXT, [PREFIX])
# ---------------------------- # --------------------------
# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. # Put TEXT in comment. Avoid trailing spaces: don't indent empty lines.
# Avoid adding indentation to the first line, as the indentation comes # Avoid adding indentation to the first line, as the indentation comes
# from "/*". That's why we don't patsubst([$1], [^\(.\)], [ \1]). # from "/*". That's why we don't patsubst([$1], [^\(.\)], [ \1]).
# #
# Prefix all the output lines with PREFIX. # Prefix all the output lines with PREFIX.
m4_define([b4_c_comment], m4_define([b4_comment],
[b4_comment_([$1], [$2/* ], [$2 ], [$2 */])]) [b4_comment_([$1], [$2/* ], [$2 ], [$2 */])])
# b4_comment(TEXT, [PREFIX])
# --------------------------
# By default, C comments.
m4_define([b4_comment], [b4_c_comment($@)])
# b4_identification # b4_identification
# ----------------- # -----------------
# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or # Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or
@@ -134,7 +128,7 @@ m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE])
# b4_user_args # b4_user_args
# ------------ # ------------
m4_define([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 # b4_parse_param
@@ -239,7 +233,7 @@ m4_define([b4_null], [YY_NULL])
# ------------------------------------------------------------- # -------------------------------------------------------------
# Define "yy<TABLE-NAME>" which contents is CONTENT. # Define "yy<TABLE-NAME>" which contents is CONTENT.
m4_define([b4_integral_parser_table_define], m4_define([b4_integral_parser_table_define],
[m4_ifvaln([$3], [b4_c_comment([$3], [ ])])dnl [m4_ifvaln([$3], [b4_comment([$3], [ ])])dnl
static const b4_int_type_for([$2]) yy$1[[]] = static const b4_int_type_for([$2]) yy$1[[]] =
{ {
$2 $2
@@ -322,24 +316,24 @@ m4_define([b4_symbol_value],
## ---------------------- ## ## ---------------------- ##
# b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) # b4_function_define(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
# ---------------------------------------------------------- # -----------------------------------------------------------
# Declare the function NAME in C. # Declare the function NAME in C.
m4_define([b4_c_function_def], m4_define([b4_function_define],
[$2 [$2
$1 (b4_c_formals(m4_shift2($@)))[]dnl $1 (b4_formals(m4_shift2($@)))[]dnl
]) ])
# b4_c_formals([DECL1, NAME1], ...) # b4_formals([DECL1, NAME1], ...)
# --------------------------------- # -------------------------------
# The formal arguments of a C function definition. # The formal arguments of a C function definition.
m4_define([b4_c_formals], m4_define([b4_formals],
[m4_if([$#], [0], [void], [m4_if([$#], [0], [void],
[$#$1], [1], [void], [$#$1], [1], [void],
[m4_map_sep([b4_c_formal], [, ], [$@])])]) [m4_map_sep([b4_formal], [, ], [$@])])])
m4_define([b4_c_formal], m4_define([b4_formal],
[$1]) [$1])
@@ -349,11 +343,11 @@ m4_define([b4_c_formal],
## ----------------------- ## ## ----------------------- ##
# b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) # b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
# ----------------------------------------------------------- # ------------------------------------------------------------
# Declare the function NAME. # Declare the function NAME.
m4_define([b4_c_function_decl], m4_define([b4_function_declare],
[$2 $1 (b4_c_formals(m4_shift2($@)));[]dnl [$2 $1 (b4_formals(m4_shift2($@)));[]dnl
]) ])
@@ -364,21 +358,21 @@ m4_define([b4_c_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. # Call the function NAME with arguments NAME1, NAME2 etc.
m4_define([b4_c_function_call], m4_define([b4_function_call],
[$1 (b4_c_args(m4_shift2($@)))[]dnl [$1 (b4_args(m4_shift2($@)))[]dnl
]) ])
# b4_c_args([DECL1, NAME1], ...) # b4_args([DECL1, NAME1], ...)
# ------------------------------ # ----------------------------
# Output the arguments NAME1, NAME2... # Output the arguments NAME1, NAME2...
m4_define([b4_c_args], m4_define([b4_args],
[m4_map_sep([b4_c_arg], [, ], [$@])]) [m4_map_sep([b4_arg], [, ], [$@])])
m4_define([b4_c_arg], m4_define([b4_arg],
[$2]) [$2])
@@ -387,7 +381,7 @@ m4_define([b4_c_arg],
## ----------- ## ## ----------- ##
# b4_sync_start(LINE, FILE) # b4_sync_start(LINE, FILE)
# ----------------------- # -------------------------
m4_define([b4_sync_start], [[#]line $1 $2]) m4_define([b4_sync_start], [[#]line $1 $2])
@@ -416,7 +410,7 @@ b4_syncline([@oline@], [@ofile@])
# b4_yydestruct_generate(FUNCTION-DECLARATOR) # b4_yydestruct_generate(FUNCTION-DECLARATOR)
# ------------------------------------------- # -------------------------------------------
# Generate the "yydestruct" function, which declaration is issued using # Generate the "yydestruct" function, which declaration is issued using
# FUNCTION-DECLARATOR, which may be "b4_c_function_def". # FUNCTION-DECLARATOR, which may be "b4_function_define".
m4_define_default([b4_yydestruct_generate], m4_define_default([b4_yydestruct_generate],
[[/*-----------------------------------------------. [[/*-----------------------------------------------.
| Release the memory associated to this symbol. | | Release the memory associated to this symbol. |
@@ -449,7 +443,7 @@ m4_ifset([b4_parse_param], [, b4_parse_param]))[
# b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR)
# ------------------------------------------------ # ------------------------------------------------
# Generate the "yy_symbol_print" function, which declaration is issued using # Generate the "yy_symbol_print" function, which declaration is issued using
# FUNCTION-DECLARATOR, which may be "b4_c_function_def". # FUNCTION-DECLARATOR, which may be "b4_function_define".
m4_define_default([b4_yy_symbol_print_generate], m4_define_default([b4_yy_symbol_print_generate],
[[ [[
/*--------------------------------. /*--------------------------------.

18
data/glr.c
View File

@@ -52,7 +52,7 @@ m4_ifndef([b4_pure_flag],
# This is not shared with yacc.c in c.m4 because GLR relies on ISO C # This is not shared with yacc.c in c.m4 because GLR relies on ISO C
# formal argument declarations. # formal argument declarations.
m4_define([b4_user_formals], m4_define([b4_user_formals],
[m4_ifset([b4_parse_param], [, b4_c_formals(b4_parse_param)])]) [m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])])
# b4_lex_param # b4_lex_param
@@ -71,7 +71,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
# a trailing comma. # a trailing comma.
m4_define([b4_yyerror_args], m4_define([b4_yyerror_args],
[b4_pure_if([b4_locations_if([yylocp, ])])dnl [b4_pure_if([b4_locations_if([yylocp, ])])dnl
m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
# b4_lyyerror_args # b4_lyyerror_args
@@ -79,7 +79,7 @@ m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
# Same as above, but on the lookahead, hence &yylloc instead of yylocp. # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
m4_define([b4_lyyerror_args], m4_define([b4_lyyerror_args],
[b4_pure_if([b4_locations_if([&yylloc, ])])dnl [b4_pure_if([b4_locations_if([&yylloc, ])])dnl
m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
# b4_pure_args # b4_pure_args
@@ -178,7 +178,7 @@ m4_define([b4_shared_declarations],
]b4_percent_code_get([[requires]])[ ]b4_percent_code_get([[requires]])[
]b4_token_enums[ ]b4_token_enums[
]b4_declare_yylstype[ ]b4_declare_yylstype[
]b4_c_function_decl(b4_prefix[parse], [int], b4_parse_param)[ ]b4_function_declare(b4_prefix[parse], [int], b4_parse_param)[
]b4_percent_code_get([[provides]])[]dnl ]b4_percent_code_get([[provides]])[]dnl
]) ])
@@ -268,7 +268,7 @@ b4_percent_code_get[]dnl
#ifndef lint #ifndef lint
# define YYID(n) (n) # define YYID(n) (n)
#else #else
]b4_c_function_def([YYID], [static int], [[int i], [i]])[ ]b4_function_define([YYID], [static int], [[int i], [i]])[
{ {
return i; return i;
} }
@@ -444,7 +444,7 @@ dnl We probably ought to introduce a type for confl.
#endif #endif
/* YYLEX -- calling `yylex' with the right arguments. */ /* YYLEX -- calling `yylex' with the right arguments. */
#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ #define YYLEX ]b4_function_call([yylex], [int], b4_lex_param)[
]b4_pure_if( ]b4_pure_if(
[ [
@@ -491,7 +491,7 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
YYFPRINTF Args; \ YYFPRINTF Args; \
} while (YYID (0)) } while (YYID (0))
]b4_yy_symbol_print_generate([b4_c_function_def])[ ]b4_yy_symbol_print_generate([b4_function_define])[
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \ do { \
@@ -872,7 +872,7 @@ yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
/* Bison grammar-table manipulation. */ /* Bison grammar-table manipulation. */
]b4_yydestruct_generate([b4_c_function_def])[ ]b4_yydestruct_generate([b4_function_define])[
/** Number of symbols composing the right hand side of rule #RULE. */ /** Number of symbols composing the right hand side of rule #RULE. */
static inline int static inline int
@@ -2276,7 +2276,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
| yyparse. | | yyparse. |
`----------*/ `----------*/
]b4_c_function_def([yyparse], [int], b4_parse_param)[ ]b4_function_define([yyparse], [int], b4_parse_param)[
{ {
int yyresult; int yyresult;
yyGLRStack yystack; yyGLRStack yystack;

6
data/glr.cc
View File

@@ -71,7 +71,7 @@ m4_define([b4_yy_symbol_print_generate],
| Print this symbol. | | Print this symbol. |
`--------------------*/ `--------------------*/
]b4_c_function_def([yy_symbol_print], ]b4_function_define([yy_symbol_print],
[static void], [static void],
[[FILE *], []], [[FILE *], []],
[[int yytype], [yytype]], [[int yytype], [yytype]],
@@ -94,7 +94,7 @@ m4_append([b4_post_prologue],
[b4_syncline([@oline@], [@ofile@])[ [b4_syncline([@oline@], [@ofile@])[
]b4_yylloc_default_define[ ]b4_yylloc_default_define[
#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
]b4_c_function_decl([yyerror], ]b4_function_declare([yyerror],
[static void],b4_locations_if([ [static void],b4_locations_if([
[[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
[yylocationp]],]) [yylocationp]],])
@@ -110,7 +110,7 @@ m4_append([b4_epilogue],
| Report an error. | | Report an error. |
`------------------*/ `------------------*/
]b4_c_function_def([yyerror], ]b4_function_define([yyerror],
[static void],b4_locations_if([ [static void],b4_locations_if([
[[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
[yylocationp]],]) [yylocationp]],])

6
data/lalr1.cc
View File

@@ -22,7 +22,7 @@ m4_include(b4_pkgdatadir/[c++.m4])
# -------------------------------------------------------------- # --------------------------------------------------------------
# Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT. # Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT.
m4_define([b4_integral_parser_table_declare], m4_define([b4_integral_parser_table_declare],
[m4_ifval([$3], [b4_c_comment([$3], [ ]) [m4_ifval([$3], [b4_comment([$3], [ ])
])dnl ])dnl
static const b4_int_type_for([$2]) yy$1_[[]];dnl static const b4_int_type_for([$2]) yy$1_[[]];dnl
]) ])
@@ -723,9 +723,9 @@ b4_dollar_popdef])[]dnl
try try
{ {
]b4_lex_symbol_if( ]b4_lex_symbol_if(
[ yyla = b4_c_function_call([yylex], [symbol_type], [ yyla = b4_function_call([yylex], [symbol_type],
m4_ifdef([b4_lex_param], b4_lex_param));], m4_ifdef([b4_lex_param], b4_lex_param));],
[ yyla.type = yytranslate_ (b4_c_function_call([yylex], [int], [ yyla.type = yytranslate_ (b4_function_call([yylex], [int],
[b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl
b4_locations_if([, [[location*], [&yyla.location]]])dnl b4_locations_if([, [[location*], [&yyla.location]]])dnl
m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[

46
data/yacc.c
View File

@@ -85,7 +85,7 @@ m4_define([b4_yacc_pure_if],
# Arguments passed to yyerror: user args plus yylloc. # Arguments passed to yyerror: user args plus yylloc.
m4_define([b4_yyerror_args], m4_define([b4_yyerror_args],
[b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
# b4_lex_param # b4_lex_param
@@ -239,19 +239,19 @@ enum { YYPUSH_MORE = 4 };
typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param) ]b4_pull_if([b4_function_declare([b4_prefix[parse]], [[int]], b4_parse_param)
])b4_c_function_decl([b4_prefix[push_parse]], [[int]], ])b4_function_declare([b4_prefix[push_parse]], [[int]],
[[b4_prefix[pstate *ps]], [[ps]]]b4_pure_if([, [[b4_prefix[pstate *ps]], [[ps]]]b4_pure_if([,
[[[int pushed_char]], [[pushed_char]]], [[[int pushed_char]], [[pushed_char]]],
[[b4_api_PREFIX[STYPE const *pushed_val]], [[pushed_val]]]b4_locations_if([, [[b4_api_PREFIX[STYPE const *pushed_val]], [[pushed_val]]]b4_locations_if([,
[[b4_api_PREFIX[LTYPE const *pushed_loc]], [[pushed_loc]]]])])m4_ifset([b4_parse_param], [, [[b4_api_PREFIX[LTYPE const *pushed_loc]], [[pushed_loc]]]])])m4_ifset([b4_parse_param], [,
b4_parse_param])) b4_parse_param]))
b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]], b4_pull_if([b4_function_declare([b4_prefix[pull_parse]], [[int]],
[[b4_prefix[pstate *ps]], [[ps]]]m4_ifset([b4_parse_param], [, [[b4_prefix[pstate *ps]], [[ps]]]m4_ifset([b4_parse_param], [,
b4_parse_param]))]) b4_parse_param]))])
b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]], b4_function_declare([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
[[[void]], []]) [[[void]], []])
b4_c_function_decl([b4_prefix[pstate_delete]], [[void]], b4_function_declare([b4_prefix[pstate_delete]], [[void]],
[[b4_prefix[pstate *ps]], [[ps]]])dnl [[b4_prefix[pstate *ps]], [[ps]]])dnl
]) ])
@@ -259,7 +259,7 @@ b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
# ------------------- # -------------------
# When not the push parser. # When not the push parser.
m4_define([b4_declare_yyparse_], m4_define([b4_declare_yyparse_],
[b4_c_function_decl(b4_prefix[parse], [int], b4_parse_param)]) [b4_function_declare(b4_prefix[parse], [int], b4_parse_param)])
# b4_declare_yyparse # b4_declare_yyparse
@@ -414,7 +414,7 @@ typedef short int yytype_int16;
#ifndef lint #ifndef lint
# define YYID(n) (n) # define YYID(n) (n)
#else #else
]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[ ]b4_function_define([YYID], [static int], [[int yyi], [yyi]])[
{ {
return yyi; return yyi;
} }
@@ -686,7 +686,7 @@ while (YYID (0))
#ifdef YYLEX_PARAM #ifdef YYLEX_PARAM
# define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM) # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
#else #else
# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ # define YYLEX ]b4_function_call([yylex], [int], b4_lex_param)[
#endif #endif
/* Enable debugging if requested. */ /* Enable debugging if requested. */
@@ -714,14 +714,14 @@ do { \
} \ } \
} while (YYID (0)) } while (YYID (0))
]b4_yy_symbol_print_generate([b4_c_function_def])[ ]b4_yy_symbol_print_generate([b4_function_define])[
/*------------------------------------------------------------------. /*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its | | yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). | | TOP (included). |
`------------------------------------------------------------------*/ `------------------------------------------------------------------*/
]b4_c_function_def([yy_stack_print], [static void], ]b4_function_define([yy_stack_print], [static void],
[[yytype_int16 *yybottom], [yybottom]], [[yytype_int16 *yybottom], [yybottom]],
[[yytype_int16 *yytop], [yytop]])[ [[yytype_int16 *yytop], [yytop]])[
{ {
@@ -745,7 +745,7 @@ do { \
| Report that the YYRULE is going to be reduced. | | Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/ `------------------------------------------------*/
]b4_c_function_def([yy_reduce_print], [static void], ]b4_function_define([yy_reduce_print], [static void],
[[yytype_int16 *yyssp], [yyssp]], [[yytype_int16 *yyssp], [yyssp]],
[[YYSTYPE *yyvsp], [yyvsp]], [[YYSTYPE *yyvsp], [yyvsp]],
b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
@@ -1047,7 +1047,7 @@ yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes,
# define yystrlen strlen # define yystrlen strlen
# else # else
/* Return the length of YYSTR. */ /* Return the length of YYSTR. */
]b4_c_function_def([yystrlen], [static YYSIZE_T], ]b4_function_define([yystrlen], [static YYSIZE_T],
[[const char *yystr], [yystr]])[ [[const char *yystr], [yystr]])[
{ {
YYSIZE_T yylen; YYSIZE_T yylen;
@@ -1064,7 +1064,7 @@ yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes,
# else # else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */ YYDEST. */
]b4_c_function_def([yystpcpy], [static char *], ]b4_function_define([yystpcpy], [static char *],
[[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[ [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
{ {
char *yyd = yydest; char *yyd = yydest;
@@ -1284,7 +1284,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
} }
#endif /* YYERROR_VERBOSE */ #endif /* YYERROR_VERBOSE */
]b4_yydestruct_generate([b4_c_function_def])[ ]b4_yydestruct_generate([b4_function_define])[
]b4_pure_if([], [ ]b4_pure_if([], [
@@ -1299,13 +1299,13 @@ struct yypstate
static char yypstate_allocated = 0;]])b4_pull_if([ static char yypstate_allocated = 0;]])b4_pull_if([
b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ b4_function_define([[yyparse]], [[int]], b4_parse_param)[
{ {
return yypull_parse (YY_NULL]m4_ifset([b4_parse_param], return yypull_parse (YY_NULL]m4_ifset([b4_parse_param],
[[, ]b4_c_args(b4_parse_param)])[); [[, ]b4_args(b4_parse_param)])[);
} }
]b4_c_function_def([[yypull_parse]], [[int]], ]b4_function_define([[yypull_parse]], [[int]],
[[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
b4_parse_param]))[ b4_parse_param]))[
{ {
@@ -1330,7 +1330,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
do { do {
yychar = YYLEX; yychar = YYLEX;
yystatus = yystatus =
yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[); yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])[);
} while (yystatus == YYPUSH_MORE); } while (yystatus == YYPUSH_MORE);
if (!yyps) if (!yyps)
yypstate_delete (yyps_local); yypstate_delete (yyps_local);
@@ -1338,7 +1338,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
}]])[ }]])[
/* Initialize the parser data structure. */ /* Initialize the parser data structure. */
]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ ]b4_function_define([[yypstate_new]], [[yypstate *]])[
{ {
yypstate *yyps;]b4_pure_if([], [[ yypstate *yyps;]b4_pure_if([], [[
if (yypstate_allocated) if (yypstate_allocated)
@@ -1351,7 +1351,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
return yyps; return yyps;
} }
]b4_c_function_def([[yypstate_delete]], [[void]], ]b4_function_define([[yypstate_delete]], [[void]],
[[[yypstate *yyps]], [[yyps]]])[ [[[yypstate *yyps]], [[yyps]]])[
{ {
#ifndef yyoverflow #ifndef yyoverflow
@@ -1389,7 +1389,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
| yypush_parse. | | yypush_parse. |
`---------------*/ `---------------*/
]b4_c_function_def([[yypush_parse]], [[int]], ]b4_function_define([[yypush_parse]], [[int]],
[[[yypstate *yyps]], [[yyps]]]b4_pure_if([, [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
[[[int yypushed_char]], [[yypushed_char]]], [[[int yypushed_char]], [[yypushed_char]]],
[[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
@@ -1401,7 +1401,7 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
| yyparse. | | yyparse. |
`----------*/ `----------*/
]b4_c_function_def([yyparse], [int], b4_parse_param)])[ ]b4_function_define([yyparse], [int], b4_parse_param)])[
{]b4_pure_if([b4_declare_scanner_communication_variables {]b4_pure_if([b4_declare_scanner_communication_variables
])b4_push_if([b4_pure_if([], [[ ])b4_push_if([b4_pure_if([], [[
int yypushed_char = yychar; int yypushed_char = yychar;