]> git.saurik.com Git - bison.git/blame - data/c.m4
Check yyerrok in calc.at.
[bison.git] / data / c.m4
CommitLineData
08af01c2 1 -*- Autoconf -*-
fb8135fa
AD
2
3# C M4 Macros for Bison.
a3764451
EB
4# Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008 Free Software
5# Foundation, Inc.
fb8135fa 6
f16b0819 7# This program is free software: you can redistribute it and/or modify
fb8135fa 8# it under the terms of the GNU General Public License as published by
f16b0819 9# the Free Software Foundation, either version 3 of the License, or
fb8135fa 10# (at your option) any later version.
f16b0819 11#
fb8135fa
AD
12# This program is distributed in the hope that it will be useful,
13# but WITHOUT ANY WARRANTY; without even the implied warranty of
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15# GNU General Public License for more details.
f16b0819 16#
fb8135fa 17# You should have received a copy of the GNU General Public License
f16b0819 18# along with this program. If not, see <http://www.gnu.org/licenses/>.
fb8135fa 19
2a8d363a
AD
20## ---------------- ##
21## Identification. ##
22## ---------------- ##
fb8135fa 23
90b9908d
PB
24# b4_comment(TEXT)
25# ----------------
26m4_define([b4_comment], [/* m4_bpatsubst([$1], [
27], [
28 ]) */])
fb8135fa 29
2a8d363a
AD
30# b4_identification
31# -----------------
d9df47b6
JD
32# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or
33# b4_pull_flag if they use the values of the %define variables api.pure or
34# api.push_pull.
2a8d363a 35m4_define([b4_identification],
d9df47b6
JD
36[[/* Identify Bison output. */
37#define YYBISON 1
2a8d363a 38
55f64b82 39/* Bison version. */
d9df47b6 40#define YYBISON_VERSION "]b4_version["
55f64b82 41
2a8d363a 42/* Skeleton name. */
d9df47b6 43#define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[
2a8d363a
AD
44
45/* Pure parsers. */
d9df47b6
JD
46#define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[
47
48/* Push parsers. */
49#define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[
50
51/* Pull parsers. */
52#define YYPULL ]b4_pull_flag])[
2a8d363a
AD
53
54/* Using locations. */
d9df47b6
JD
55#define YYLSP_NEEDED ]b4_locations_flag[
56]])
2a8d363a
AD
57
58
7ec2d4cd
AD
59## ---------------- ##
60## Default values. ##
61## ---------------- ##
62
1b818f33
AD
63# If the %union is not named, its name is YYSTYPE.
64m4_define_default([b4_union_name], [YYSTYPE])
7ec2d4cd 65
90b9908d
PB
66# If the %name-prefix is not given, it is yy.
67m4_define_default([b4_prefix], [yy])
cd48d21d 68
2a8d363a
AD
69## ------------------------ ##
70## Pure/impure interfaces. ##
71## ------------------------ ##
72
2a8d363a
AD
73# b4_user_args
74# ------------
75m4_define([b4_user_args],
76[m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])])
77
78
79# b4_parse_param
80# --------------
81# If defined, b4_parse_param arrives double quoted, but below we prefer
82# it to be single quoted.
2a8d363a 83m4_define([b4_parse_param],
7ecec4dd 84b4_parse_param)
2a8d363a 85
8f7e3cf9 86
613d8952
AD
87# b4_parse_param_for(DECL, FORMAL, BODY)
88# ---------------------------------------
89# Iterate over the user parameters, binding the declaration to DECL,
90# the formal name to FORMAL, and evaluating the BODY.
91m4_define([b4_parse_param_for],
92[m4_foreach([$1_$2], m4_defn([b4_parse_param]),
6bbb2ed5 93[m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl
613d8952
AD
94m4_pushdef([$2], m4_shift($1_$2))dnl
95$3[]dnl
96m4_popdef([$2])dnl
97m4_popdef([$1])dnl
98])])
99
100# b4_parse_param_use
101# ------------------
102# `YYUSE' all the parse-params.
613d8952
AD
103m4_define([b4_parse_param_use],
104[b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal);
105])dnl
106])
2a8d363a 107
8e1687ae 108
fb8135fa
AD
109## ------------ ##
110## Data Types. ##
111## ------------ ##
112
a762e609
AD
113# b4_int_type(MIN, MAX)
114# ---------------------
115# Return the smallest int type able to handle numbers ranging from
116# MIN to MAX (included).
117m4_define([b4_int_type],
118[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
f1886bb2 119 b4_ints_in($@, [-128], [127]), [1], [signed char],
a762e609 120
779e7ceb
PE
121 b4_ints_in($@, [0], [65535]), [1], [unsigned short int],
122 b4_ints_in($@, [-32768], [32767]), [1], [short int],
a762e609
AD
123
124 m4_eval([0 <= $1]), [1], [unsigned int],
125
02650b7f 126 [int])])
a762e609 127
f1886bb2 128
a762e609
AD
129# b4_int_type_for(NAME)
130# ---------------------
131# Return the smallest int type able to handle numbers ranging from
132# `NAME_min' to `NAME_max' (included).
133m4_define([b4_int_type_for],
134[b4_int_type($1_min, $1_max)])
fb8135fa 135
8e1687ae
PE
136## ---------##
137## Values. ##
138## ---------##
139
140# b4_null
141---------
142# Return a null pointer constant. NULL infringes on the user name
143# space in C, so use 0 rather than NULL.
144m4_define([b4_null], [0])
145
146
fb8135fa
AD
147## ------------------------- ##
148## Assigning token numbers. ##
149## ------------------------- ##
150
151# b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
152# -----------------------------------------
153# Output the definition of this token as #define.
154m4_define([b4_token_define],
155[#define $1 $2
156])
157
158
cf147260
AD
159# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
160# -------------------------------------------------------
161# Output the definition of the tokens (if there are) as #defines.
162m4_define([b4_token_defines],
6bbb2ed5 163[m4_if([$#$1], [1], [],
cf147260
AD
164[/* Tokens. */
165m4_map([b4_token_define], [$@])])
166])
167
168
fb8135fa
AD
169# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
170# ---------------------------------------
171# Output the definition of this token as an enum.
172m4_define([b4_token_enum],
173[$1 = $2])
174
175
cf147260
AD
176# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
177# -----------------------------------------------------
178# Output the definition of the tokens (if there are) as enums.
179m4_define([b4_token_enums],
6bbb2ed5 180[m4_if([$#$1], [1], [],
fb8135fa 181[/* Tokens. */
6b8c3254
PE
182#ifndef YYTOKENTYPE
183# define YYTOKENTYPE
fb8135fa
AD
184 /* Put the tokens into the symbol table, so that GDB and other debuggers
185 know about them. */
186 enum yytokentype {
187m4_map_sep([ b4_token_enum], [,
188],
02650b7f 189 [$@])
fb8135fa 190 };
095b9f05 191#endif
cf147260
AD
192])])
193
194
195# b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
196# -------------------------------------------------------------
b931235e
JD
197# Output the definition of the tokens (if there are any) as enums and, if POSIX
198# Yacc is enabled, as #defines.
cf147260 199m4_define([b4_token_enums_defines],
b931235e 200[b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], [])
fb8135fa 201])
4a2a22f4
AD
202
203
ae7453f2 204
0245f82d
AD
205## --------------------------------------------- ##
206## Defining C functions in both K&R and ANSI-C. ##
207## --------------------------------------------- ##
4a2a22f4
AD
208
209
1b9c21fb
PE
210# b4_modern_c
211# -----------
212# A predicate useful in #if to determine whether C is ancient or modern.
213#
214# If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run
215# as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic
216# reasons, but it defines __C99__FUNC__ so check that as well.
217# Microsoft C normally doesn't define these macros, but it defines _MSC_VER.
7a0db73e 218# Consider a C++ compiler to be modern if it defines __cplusplus.
1b9c21fb
PE
219#
220m4_define([b4_c_modern],
02650b7f
PE
221 [[(defined __STDC__ || defined __C99__FUNC__ \
222 || defined __cplusplus || defined _MSC_VER)]])
1b9c21fb 223
0245f82d
AD
224# b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
225# ----------------------------------------------------------
4a2a22f4 226# Declare the function NAME.
0245f82d 227m4_define([b4_c_function_def],
1b9c21fb 228[#if b4_c_modern
0245f82d 229b4_c_ansi_function_def($@)
4a2a22f4 230#else
0245f82d 231$2
a3764451
EB
232$1 (b4_c_knr_formal_names(m4_shift2($@)))
233b4_c_knr_formal_decls(m4_shift2($@))
4a2a22f4
AD
234#endif[]dnl
235])
236
237
0245f82d
AD
238# b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
239# ---------------------------------------------------------------
240# Declare the function NAME in ANSI.
241m4_define([b4_c_ansi_function_def],
242[$2
a3764451 243$1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl
0245f82d
AD
244])
245
246
247# b4_c_ansi_formals([DECL1, NAME1], ...)
248# --------------------------------------
4a2a22f4 249# Output the arguments ANSI-C definition.
0245f82d 250m4_define([b4_c_ansi_formals],
6bbb2ed5
EB
251[m4_if([$#], [0], [void],
252 [$#$1], [1], [void],
02650b7f 253 [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
4a2a22f4 254
0245f82d
AD
255m4_define([b4_c_ansi_formal],
256[$1])
4a2a22f4
AD
257
258
0245f82d
AD
259# b4_c_knr_formal_names([DECL1, NAME1], ...)
260# ------------------------------------------
4a2a22f4 261# Output the argument names.
0245f82d
AD
262m4_define([b4_c_knr_formal_names],
263[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
4a2a22f4 264
0245f82d 265m4_define([b4_c_knr_formal_name],
4a2a22f4
AD
266[$2])
267
268
0245f82d
AD
269# b4_c_knr_formal_decls([DECL1, NAME1], ...)
270# ------------------------------------------
4a2a22f4 271# Output the K&R argument declarations.
0245f82d
AD
272m4_define([b4_c_knr_formal_decls],
273[m4_map_sep([b4_c_knr_formal_decl],
02650b7f 274 [
4a2a22f4 275],
02650b7f 276 [$@])])
4a2a22f4 277
0245f82d
AD
278m4_define([b4_c_knr_formal_decl],
279[ $1;])
21964f43
AD
280
281
282
0245f82d
AD
283## ------------------------------------------------------------ ##
284## Declaring (prototyping) C functions in both K&R and ANSI-C. ##
285## ------------------------------------------------------------ ##
21964f43
AD
286
287
0245f82d
AD
288# b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
289# -----------------------------------------------------------
290# Declare the function NAME.
291m4_define([b4_c_function_decl],
02650b7f 292[#if defined __STDC__ || defined __cplusplus
0245f82d
AD
293b4_c_ansi_function_decl($@)
294#else
295$2 $1 ();
296#endif[]dnl
297])
21964f43
AD
298
299
0245f82d
AD
300# b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
301# ----------------------------------------------------------------
302# Declare the function NAME.
303m4_define([b4_c_ansi_function_decl],
a3764451 304[$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl
0245f82d
AD
305])
306
307
308
309
310## --------------------- ##
311## Calling C functions. ##
312## --------------------- ##
313
314
315# b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
316# -----------------------------------------------------------
317# Call the function NAME with arguments NAME1, NAME2 etc.
318m4_define([b4_c_function_call],
a3764451 319[$1 (b4_c_args(m4_shift2($@)))[]dnl
0245f82d
AD
320])
321
322
323# b4_c_args([DECL1, NAME1], ...)
324# ------------------------------
325# Output the arguments NAME1, NAME2...
326m4_define([b4_c_args],
327[m4_map_sep([b4_c_arg], [, ], [$@])])
328
329m4_define([b4_c_arg],
330[$2])
437c2d80
AD
331
332
333## ----------- ##
334## Synclines. ##
335## ----------- ##
336
90b9908d 337# b4_sync_start(LINE, FILE)
8ec0a172 338# -----------------------
90b9908d 339m4_define([b4_sync_start], [[#]line $1 $2])
8ec0a172 340
613d8952
AD
341
342## -------------- ##
343## User actions. ##
344## -------------- ##
345
8e1687ae
PE
346# b4_case(LABEL, STATEMENTS)
347# --------------------------
348m4_define([b4_case],
349[ case $1:
350$2
351 break;])
352
b0400cc6
AD
353# b4_symbol_actions(FILENAME, LINENO,
354# SYMBOL-TAG, SYMBOL-NUM,
355# SYMBOL-ACTION, SYMBOL-TYPENAME)
356# -------------------------------------------------
357m4_define([b4_symbol_actions],
60c82948
PE
358[m4_pushdef([b4_dollar_dollar],
359 [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl
7bd6c77e 360m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
b0400cc6
AD
361 case $4: /* $3 */
362b4_syncline([$2], [$1])
02650b7f 363 $5;
b0400cc6 364b4_syncline([@oline@], [@ofile@])
02650b7f 365 break;
b0400cc6
AD
366m4_popdef([b4_at_dollar])dnl
367m4_popdef([b4_dollar_dollar])dnl
368])
369
370
14740648
PE
371# b4_yydestruct_generate(FUNCTION-DECLARATOR)
372# -------------------------------------------
b0400cc6 373# Generate the "yydestruct" function, which declaration is issued using
14740648 374# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
b0400cc6 375# or "b4_c_function_def" for K&R.
cf147260 376m4_define_default([b4_yydestruct_generate],
b0400cc6
AD
377[[/*-----------------------------------------------.
378| Release the memory associated to this symbol. |
379`-----------------------------------------------*/
380
12ce2df6 381/*ARGSUSED*/
b0400cc6
AD
382]$1([yydestruct],
383 [static void],
a0e68930 384 [[const char *yymsg], [yymsg]],
7bd6c77e 385 [[int yytype], [yytype]],
4b367315 386 [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl
327afc7c 387b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
4b367315 388m4_ifset([b4_parse_param], [, b4_parse_param]))[
b0400cc6 389{
2a4647a3 390 YYUSE (yyvaluep);
327afc7c 391]b4_locations_if([ YYUSE (yylocationp);
613d8952
AD
392])dnl
393b4_parse_param_use[]dnl
394[
a0e68930
AD
395 if (!yymsg)
396 yymsg = "Deleting";
397 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
398
b0400cc6
AD
399 switch (yytype)
400 {
401]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
402 default:
02650b7f 403 break;
b0400cc6
AD
404 }
405}]dnl
406])
7bd6c77e
AD
407
408
a0af42fc
AD
409# b4_yy_symbol_print_generate(FUNCTION-DECLARATOR)
410# ------------------------------------------------
411# Generate the "yy_symbol_print" function, which declaration is issued using
14740648 412# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
7bd6c77e 413# or "b4_c_function_def" for K&R.
a0af42fc
AD
414m4_define_default([b4_yy_symbol_print_generate],
415[[
416/*--------------------------------.
14740648
PE
417| Print this symbol on YYOUTPUT. |
418`--------------------------------*/
7bd6c77e 419
12ce2df6 420/*ARGSUSED*/
a0af42fc 421]$1([yy_symbol_value_print],
7bd6c77e 422 [static void],
02650b7f
PE
423 [[FILE *yyoutput], [yyoutput]],
424 [[int yytype], [yytype]],
50cce58e
PE
425 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl
426b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
4b367315 427m4_ifset([b4_parse_param], [, b4_parse_param]))[
7bd6c77e 428{
05449a2c
JD
429 if (!yyvaluep)
430 return;
327afc7c 431]b4_locations_if([ YYUSE (yylocationp);
7bd6c77e 432])dnl
613d8952 433b4_parse_param_use[]dnl
a0af42fc 434[# ifdef YYPRINT
619404e3
AD
435 if (yytype < YYNTOKENS)
436 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
c66dfadd
PE
437# else
438 YYUSE (yyoutput);
619404e3 439# endif
7bd6c77e
AD
440 switch (yytype)
441 {
3fc16193
AD
442]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
443[ default:
02650b7f 444 break;
7bd6c77e 445 }
a0af42fc
AD
446}
447
448
449/*--------------------------------.
450| Print this symbol on YYOUTPUT. |
451`--------------------------------*/
452
453]$1([yy_symbol_print],
454 [static void],
02650b7f
PE
455 [[FILE *yyoutput], [yyoutput]],
456 [[int yytype], [yytype]],
50cce58e
PE
457 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl
458b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
a0af42fc
AD
459m4_ifset([b4_parse_param], [, b4_parse_param]))[
460{
461 if (yytype < YYNTOKENS)
462 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
463 else
464 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
465
327afc7c 466]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp);
a0af42fc
AD
467 YYFPRINTF (yyoutput, ": ");
468])dnl
469[ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl
327afc7c 470b4_locations_if([, yylocationp])[]b4_user_args[);
2f4f028d 471 YYFPRINTF (yyoutput, ")");
4b367315
AD
472}]dnl
473])