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