]> git.saurik.com Git - bison.git/blame_incremental - data/c.m4
regen.
[bison.git] / data / c.m4
... / ...
CommitLineData
1 -*- Autoconf -*-
2
3# C M4 Macros for Bison.
4
5# Copyright (C) 2002, 2004-2012 Free Software Foundation, Inc.
6
7# This program is free software: you can redistribute it and/or modify
8# it under the terms of the GNU General Public License as published by
9# the Free Software Foundation, either version 3 of the License, or
10# (at your option) any later version.
11#
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.
16#
17# You should have received a copy of the GNU General Public License
18# along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20
21# b4_tocpp(STRING)
22# ----------------
23# Convert STRING into a valid C macro name.
24m4_define([b4_tocpp],
25[m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))])
26
27
28# b4_cpp_guard(FILE)
29# ------------------
30# A valid C macro name to use as a CPP header guard for FILE.
31m4_define([b4_cpp_guard],
32[b4_tocpp(m4_defn([b4_prefix])/[$1])])
33
34
35# b4_cpp_guard_open(FILE)
36# b4_cpp_guard_close(FILE)
37# ------------------------
38# Open/close CPP inclusion guards for FILE.
39m4_define([b4_cpp_guard_open],
40[#ifndef b4_cpp_guard([$1])
41# define b4_cpp_guard([$1])])
42
43m4_define([b4_cpp_guard_close],
44[#endif b4_comment([!b4_cpp_guard([$1])])])
45
46
47## ---------------- ##
48## Identification. ##
49## ---------------- ##
50
51# b4_comment_(TEXT, OPEN, CONTINUE, END)
52# -------------------------------------
53# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines.
54# Avoid adding indentation to the first line, as the indentation comes
55# from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]).
56#
57# Prefix all the output lines with PREFIX.
58m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [
59\(.\)], [
60$3\1])$4])
61
62
63# b4_c_comment(TEXT, [PREFIX])
64# ----------------------------
65# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines.
66# Avoid adding indentation to the first line, as the indentation comes
67# from "/*". That's why we don't patsubst([$1], [^\(.\)], [ \1]).
68#
69# Prefix all the output lines with PREFIX.
70m4_define([b4_c_comment],
71[b4_comment_([$1], [$2/* ], [$2 ], [$2 */])])
72
73
74# b4_comment(TEXT, [PREFIX])
75# --------------------------
76# By default, C comments.
77m4_define([b4_comment], [b4_c_comment($@)])
78
79
80# b4_identification
81# -----------------
82# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or
83# b4_pull_flag if they use the values of the %define variables api.pure or
84# api.push-pull.
85m4_define([b4_identification],
86[[/* Identify Bison output. */
87#define YYBISON 1
88
89/* Bison version. */
90#define YYBISON_VERSION "]b4_version["
91
92/* Skeleton name. */
93#define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[
94
95/* Pure parsers. */
96#define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[
97
98/* Push parsers. */
99#define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[
100
101/* Pull parsers. */
102#define YYPULL ]b4_pull_flag])[
103]])
104
105
106## ---------------- ##
107## Default values. ##
108## ---------------- ##
109
110# b4_api_prefix, b4_api_PREFIX
111# ----------------------------
112# Corresponds to %define api.prefix
113b4_percent_define_default([[api.prefix]], [[yy]])
114m4_define([b4_api_prefix],
115[b4_percent_define_get([[api.prefix]])])
116m4_define([b4_api_PREFIX],
117[m4_toupper(b4_api_prefix)])
118
119
120# b4_prefix
121# ---------
122# If the %name-prefix is not given, it is api.prefix.
123m4_define_default([b4_prefix], [b4_api_prefix])
124
125# If the %union is not named, its name is YYSTYPE.
126m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE])
127
128
129## ------------------------ ##
130## Pure/impure interfaces. ##
131## ------------------------ ##
132
133# b4_user_args
134# ------------
135m4_define([b4_user_args],
136[m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])])
137
138
139# b4_parse_param
140# --------------
141# If defined, b4_parse_param arrives double quoted, but below we prefer
142# it to be single quoted.
143m4_define([b4_parse_param],
144b4_parse_param)
145
146
147# b4_parse_param_for(DECL, FORMAL, BODY)
148# ---------------------------------------
149# Iterate over the user parameters, binding the declaration to DECL,
150# the formal name to FORMAL, and evaluating the BODY.
151m4_define([b4_parse_param_for],
152[m4_foreach([$1_$2], m4_defn([b4_parse_param]),
153[m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl
154m4_pushdef([$2], m4_shift($1_$2))dnl
155$3[]dnl
156m4_popdef([$2])dnl
157m4_popdef([$1])dnl
158])])
159
160# b4_parse_param_use([VAL], [LOC])
161# --------------------------------
162# `YYUSE' VAL, LOC if locations are enabled, and all the parse-params.
163m4_define([b4_parse_param_use],
164[m4_ifvaln([$1], [ YYUSE([$1]);])dnl
165b4_locations_if([m4_ifvaln([$2], [ YYUSE ([$2]);])])dnl
166b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal);
167])dnl
168])
169
170
171## ------------ ##
172## Data Types. ##
173## ------------ ##
174
175# b4_int_type(MIN, MAX)
176# ---------------------
177# Return the smallest int type able to handle numbers ranging from
178# MIN to MAX (included).
179m4_define([b4_int_type],
180[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
181 b4_ints_in($@, [-128], [127]), [1], [signed char],
182
183 b4_ints_in($@, [0], [65535]), [1], [unsigned short int],
184 b4_ints_in($@, [-32768], [32767]), [1], [short int],
185
186 m4_eval([0 <= $1]), [1], [unsigned int],
187
188 [int])])
189
190
191# b4_int_type_for(NAME)
192# ---------------------
193# Return the smallest int type able to handle numbers ranging from
194# `NAME_min' to `NAME_max' (included).
195m4_define([b4_int_type_for],
196[b4_int_type($1_min, $1_max)])
197
198
199# b4_table_value_equals(TABLE, VALUE, LITERAL)
200# --------------------------------------------
201# Without inducing a comparison warning from the compiler, check if the
202# literal value LITERAL equals VALUE from table TABLE, which must have
203# TABLE_min and TABLE_max defined. YYID must be defined as an identity
204# function that suppresses warnings about constant conditions.
205m4_define([b4_table_value_equals],
206[m4_if(m4_eval($3 < m4_indir([b4_]$1[_min])
207 || m4_indir([b4_]$1[_max]) < $3), [1],
208 [[YYID (0)]],
209 [[((]$2[) == (]$3[))]])])
210
211
212## ---------##
213## Values. ##
214## ---------##
215
216
217# b4_null_define
218# --------------
219# Portability issues: define a YY_NULL appropriate for the current
220# language (C, C++98, or C++11).
221m4_define([b4_null_define],
222[# ifndef YY_NULL
223# if defined __cplusplus && 201103L <= __cplusplus
224# define YY_NULL nullptr
225# else
226# define YY_NULL 0
227# endif
228# endif[]dnl
229])
230
231
232# b4_null
233# -------
234# Return a null pointer constant.
235m4_define([b4_null], [YY_NULL])
236
237# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
238# -------------------------------------------------------------
239# Define "yy<TABLE-NAME>" which contents is CONTENT.
240m4_define([b4_integral_parser_table_define],
241[m4_ifvaln([$3], [b4_c_comment([$3], [ ])])dnl
242static const b4_int_type_for([$2]) yy$1[[]] =
243{
244 $2
245};dnl
246])
247
248
249## ------------------------- ##
250## Assigning token numbers. ##
251## ------------------------- ##
252
253# b4_token_define(TOKEN-NUM)
254# --------------------------
255# Output the definition of this token as #define.
256m4_define([b4_token_define],
257[b4_token_format([#define %s %s], [$1])])
258
259# b4_token_defines
260# ----------------
261# Output the definition of the tokens.
262m4_define([b4_token_defines],
263[b4_any_token_visible_if([/* Tokens. */
264m4_join([
265], b4_symbol_map([b4_token_define]))
266])])
267
268
269# b4_token_enum(TOKEN-NUM)
270# ------------------------
271# Output the definition of this token as an enum.
272m4_define([b4_token_enum],
273[b4_token_format([%s = %s], [$1])])
274
275
276# b4_token_enums
277# --------------
278# Output the definition of the tokens (if there are) as enums.
279m4_define([b4_token_enums],
280[b4_any_token_visible_if([[/* Tokens. */
281#ifndef ]b4_api_PREFIX[TOKENTYPE
282# define ]b4_api_PREFIX[TOKENTYPE
283 /* Put the tokens into the symbol table, so that GDB and other debuggers
284 know about them. */
285 enum ]b4_api_prefix[tokentype
286 {
287 ]m4_join([,
288 ],
289 b4_symbol_map([b4_token_enum]))[
290 };
291#endif
292]])])
293
294
295# b4_token_enums_defines
296# ----------------------
297# Output the definition of the tokens (if there are any) as enums and,
298# if POSIX Yacc is enabled, as #defines.
299m4_define([b4_token_enums_defines],
300[b4_token_enums[]b4_yacc_if([b4_token_defines])])
301
302
303## ----------------- ##
304## Semantic Values. ##
305## ----------------- ##
306
307
308# b4_symbol_value(VAL, [TYPE])
309# ----------------------------
310# Given a semantic value VAL ($$, $1 etc.), extract its value of type
311# TYPE if TYPE is given, otherwise just return VAL. The result can be
312# used safetly, it is put in parens to avoid nasty precedence issues.
313# TYPE is *not* put in braces, provide some if needed.
314m4_define([b4_symbol_value],
315[($1[]m4_ifval([$2], [.$2]))])
316
317
318
319## --------------------------------------------- ##
320## Defining C functions in both K&R and ANSI-C. ##
321## --------------------------------------------- ##
322
323
324# b4_modern_c
325# -----------
326# A predicate useful in #if to determine whether C is ancient or modern.
327#
328# If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run
329# as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic
330# reasons, but it defines __C99__FUNC__ so check that as well.
331# Microsoft C normally doesn't define these macros, but it defines _MSC_VER.
332# Consider a C++ compiler to be modern if it defines __cplusplus.
333#
334m4_define([b4_c_modern],
335 [[(defined __STDC__ || defined __C99__FUNC__ \
336 || defined __cplusplus || defined _MSC_VER)]])
337
338# b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
339# ----------------------------------------------------------
340# Declare the function NAME.
341m4_define([b4_c_function_def],
342[#if b4_c_modern
343b4_c_ansi_function_def($@)
344#else
345$2
346$1 (b4_c_knr_formal_names(m4_shift2($@)))
347b4_c_knr_formal_decls(m4_shift2($@))
348#endif[]dnl
349])
350
351
352# b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
353# ---------------------------------------------------------------
354# Declare the function NAME in ANSI.
355m4_define([b4_c_ansi_function_def],
356[$2
357$1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl
358])
359
360
361# b4_c_ansi_formals([DECL1, NAME1], ...)
362# --------------------------------------
363# Output the arguments ANSI-C definition.
364m4_define([b4_c_ansi_formals],
365[m4_if([$#], [0], [void],
366 [$#$1], [1], [void],
367 [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
368
369m4_define([b4_c_ansi_formal],
370[$1])
371
372
373# b4_c_knr_formal_names([DECL1, NAME1], ...)
374# ------------------------------------------
375# Output the argument names.
376m4_define([b4_c_knr_formal_names],
377[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
378
379m4_define([b4_c_knr_formal_name],
380[$2])
381
382
383# b4_c_knr_formal_decls([DECL1, NAME1], ...)
384# ------------------------------------------
385# Output the K&R argument declarations.
386m4_define([b4_c_knr_formal_decls],
387[m4_map_sep([b4_c_knr_formal_decl],
388 [
389],
390 [$@])])
391
392m4_define([b4_c_knr_formal_decl],
393[ $1;])
394
395
396
397## ------------------------------------------------------------ ##
398## Declaring (prototyping) C functions in both K&R and ANSI-C. ##
399## ------------------------------------------------------------ ##
400
401
402# b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
403# -----------------------------------------------------------
404# Declare the function NAME.
405m4_define([b4_c_function_decl],
406[#if b4_c_modern
407b4_c_ansi_function_decl($@)
408#else
409$2 $1 ();
410#endif[]dnl
411])
412
413
414# b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
415# ----------------------------------------------------------------
416# Declare the function NAME.
417m4_define([b4_c_ansi_function_decl],
418[$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl
419])
420
421
422
423
424## --------------------- ##
425## Calling C functions. ##
426## --------------------- ##
427
428
429# b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
430# -----------------------------------------------------------
431# Call the function NAME with arguments NAME1, NAME2 etc.
432m4_define([b4_c_function_call],
433[$1 (b4_c_args(m4_shift2($@)))[]dnl
434])
435
436
437# b4_c_args([DECL1, NAME1], ...)
438# ------------------------------
439# Output the arguments NAME1, NAME2...
440m4_define([b4_c_args],
441[m4_map_sep([b4_c_arg], [, ], [$@])])
442
443m4_define([b4_c_arg],
444[$2])
445
446
447## ----------- ##
448## Synclines. ##
449## ----------- ##
450
451# b4_sync_start(LINE, FILE)
452# -----------------------
453m4_define([b4_sync_start], [[#]line $1 $2])
454
455
456## -------------- ##
457## User actions. ##
458## -------------- ##
459
460# b4_case(LABEL, STATEMENTS)
461# --------------------------
462m4_define([b4_case],
463[ case $1:
464$2
465b4_syncline([@oline@], [@ofile@])
466 break;])
467
468
469# b4_predicate_case(LABEL, CONDITIONS)
470# ------------------------------------
471m4_define([b4_predicate_case],
472[ case $1:
473 if (! ($2)) YYERROR;
474b4_syncline([@oline@], [@ofile@])
475 break;])
476
477
478# b4_yydestruct_generate(FUNCTION-DECLARATOR)
479# -------------------------------------------
480# Generate the "yydestruct" function, which declaration is issued using
481# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
482# or "b4_c_function_def" for K&R.
483m4_define_default([b4_yydestruct_generate],
484[[/*-----------------------------------------------.
485| Release the memory associated to this symbol. |
486`-----------------------------------------------*/
487
488/*ARGSUSED*/
489]$1([yydestruct],
490 [static void],
491 [[const char *yymsg], [yymsg]],
492 [[int yytype], [yytype]],
493 [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl
494b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
495m4_ifset([b4_parse_param], [, b4_parse_param]))[
496{
497]b4_parse_param_use([yyvaluep], [yylocationp])dnl
498[ if (!yymsg)
499 yymsg = "Deleting";
500 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
501
502 switch (yytype)
503 {
504]b4_symbol_foreach([b4_symbol_destructor])dnl
505[ default:
506 break;
507 }
508}]dnl
509])
510
511
512# b4_yy_symbol_print_generate(FUNCTION-DECLARATOR)
513# ------------------------------------------------
514# Generate the "yy_symbol_print" function, which declaration is issued using
515# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
516# or "b4_c_function_def" for K&R.
517m4_define_default([b4_yy_symbol_print_generate],
518[[
519/*--------------------------------.
520| Print this symbol on YYOUTPUT. |
521`--------------------------------*/
522
523/*ARGSUSED*/
524]$1([yy_symbol_value_print],
525 [static void],
526 [[FILE *yyoutput], [yyoutput]],
527 [[int yytype], [yytype]],
528 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl
529b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
530m4_ifset([b4_parse_param], [, b4_parse_param]))[
531{
532 FILE *yyo = yyoutput;
533]b4_parse_param_use([yyo], [yylocationp])dnl
534[ if (!yyvaluep)
535 return;]
536dnl glr.c does not feature yytoknum.
537m4_if(b4_skeleton, ["yacc.c"],
538[[# ifdef YYPRINT
539 if (yytype < YYNTOKENS)
540 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
541# endif
542]])dnl
543[ switch (yytype)
544 {
545]b4_symbol_foreach([b4_symbol_printer])dnl
546[ default:
547 break;
548 }
549}
550
551
552/*--------------------------------.
553| Print this symbol on YYOUTPUT. |
554`--------------------------------*/
555
556]$1([yy_symbol_print],
557 [static void],
558 [[FILE *yyoutput], [yyoutput]],
559 [[int yytype], [yytype]],
560 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl
561b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
562m4_ifset([b4_parse_param], [, b4_parse_param]))[
563{
564 if (yytype < YYNTOKENS)
565 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
566 else
567 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
568
569]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp);
570 YYFPRINTF (yyoutput, ": ");
571])dnl
572[ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl
573b4_locations_if([, yylocationp])[]b4_user_args[);
574 YYFPRINTF (yyoutput, ")");
575}]dnl
576])
577
578## -------------- ##
579## Declarations. ##
580## -------------- ##
581
582# b4_declare_yylstype
583# -------------------
584# Declarations that might either go into the header (if --defines) or
585# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc.
586m4_define([b4_declare_yylstype],
587[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED
588]m4_ifdef([b4_stype],
589[[typedef union ]b4_union_name[
590{
591]b4_user_stype[
592} ]b4_api_PREFIX[STYPE;
593# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]],
594[m4_if(b4_tag_seen_flag, 0,
595[[typedef int ]b4_api_PREFIX[STYPE;
596# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]])])[
597# define ]b4_api_prefix[stype ]b4_api_PREFIX[STYPE /* obsolescent; will be withdrawn */
598# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1
599#endif]b4_locations_if([[
600
601#if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED
602typedef struct ]b4_api_PREFIX[LTYPE
603{
604 int first_line;
605 int first_column;
606 int last_line;
607 int last_column;
608} ]b4_api_PREFIX[LTYPE;
609# define ]b4_api_prefix[ltype ]b4_api_PREFIX[LTYPE /* obsolescent; will be withdrawn */
610# define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1
611# define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1
612#endif]])
613
614b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval;
615]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl
616])
617
618# b4_YYDEBUG_define
619# ------------------
620m4_define([b4_YYDEBUG_define],
621[[/* Enabling traces. */
622]m4_if(b4_api_prefix, [yy],
623[[#ifndef YYDEBUG
624# define YYDEBUG ]b4_parse_trace_if([1], [0])[
625#endif]],
626[[#ifndef ]b4_api_PREFIX[DEBUG
627# if defined YYDEBUG
628#if YYDEBUG
629# define ]b4_api_PREFIX[DEBUG 1
630# else
631# define ]b4_api_PREFIX[DEBUG 0
632# endif
633# else /* ! defined YYDEBUG */
634# define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[
635# endif /* ! defined ]b4_api_PREFIX[DEBUG */
636#endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl
637])
638
639# b4_declare_yydebug
640# ------------------
641m4_define([b4_declare_yydebug],
642[b4_YYDEBUG_define[
643#if ]b4_api_PREFIX[DEBUG
644extern int ]b4_prefix[debug;
645#endif][]dnl
646])
647
648# b4_yylloc_default_define
649# ------------------------
650# Define YYLLOC_DEFAULT.
651m4_define([b4_yylloc_default_define],
652[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
653 If N is 0, then set CURRENT to the empty location which ends
654 the previous symbol: RHS[0] (always defined). */
655
656#ifndef YYLLOC_DEFAULT
657# define YYLLOC_DEFAULT(Current, Rhs, N) \
658 do \
659 if (YYID (N)) \
660 { \
661 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
662 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
663 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
664 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
665 } \
666 else \
667 { \
668 (Current).first_line = (Current).last_line = \
669 YYRHSLOC (Rhs, 0).last_line; \
670 (Current).first_column = (Current).last_column = \
671 YYRHSLOC (Rhs, 0).last_column; \
672 } \
673 while (YYID (0))
674#endif
675]])