Edit File: c.m4
-*- Autoconf -*- # C M4 Macros for Bison. # Copyright (C) 2002, 2004-2015 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 # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. m4_include(b4_pkgdatadir/[c-like.m4]) # b4_tocpp(STRING) # ---------------- # Convert STRING into a valid C macro name. m4_define([b4_tocpp], [m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))]) # b4_cpp_guard(FILE) # ------------------ # A valid C macro name to use as a CPP header guard for FILE. m4_define([b4_cpp_guard], [[YY_]b4_tocpp(m4_defn([b4_prefix])/[$1])[_INCLUDED]]) # b4_cpp_guard_open(FILE) # b4_cpp_guard_close(FILE) # ------------------------ # If FILE does not expand to nothing, open/close CPP inclusion guards for FILE. m4_define([b4_cpp_guard_open], [m4_ifval(m4_quote($1), [#ifndef b4_cpp_guard([$1]) # define b4_cpp_guard([$1])])]) m4_define([b4_cpp_guard_close], [m4_ifval(m4_quote($1), [#endif b4_comment([!b4_cpp_guard([$1])])])]) ## ---------------- ## ## Identification. ## ## ---------------- ## # b4_identification # ----------------- # Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or # b4_pull_flag if they use the values of the %define variables api.pure or # api.push-pull. m4_define([b4_identification], [[/* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ #define YYBISON_VERSION "]b4_version[" /* Skeleton name. */ #define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[ /* Pure parsers. */ #define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[ /* Push parsers. */ #define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[ /* Pull parsers. */ #define YYPULL ]b4_pull_flag])[ ]]) ## ---------------- ## ## Default values. ## ## ---------------- ## # b4_api_prefix, b4_api_PREFIX # ---------------------------- # Corresponds to %define api.prefix b4_percent_define_default([[api.prefix]], [[yy]]) m4_define([b4_api_prefix], [b4_percent_define_get([[api.prefix]])]) m4_define([b4_api_PREFIX], [m4_toupper(b4_api_prefix)]) # b4_prefix # --------- # If the %name-prefix is not given, it is api.prefix. m4_define_default([b4_prefix], [b4_api_prefix]) # If the %union is not named, its name is YYSTYPE. b4_percent_define_default([[api.value.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_args(b4_parse_param)])]) # b4_parse_param # -------------- # If defined, b4_parse_param arrives double quoted, but below we prefer # it to be single quoted. m4_define([b4_parse_param], b4_parse_param) # b4_parse_param_for(DECL, FORMAL, BODY) # --------------------------------------- # Iterate over the user parameters, binding the declaration to DECL, # the formal name to FORMAL, and evaluating the BODY. m4_define([b4_parse_param_for], [m4_foreach([$1_$2], m4_defn([b4_parse_param]), [m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl m4_pushdef([$2], m4_shift($1_$2))dnl $3[]dnl m4_popdef([$2])dnl m4_popdef([$1])dnl ])]) # b4_parse_param_use([VAL], [LOC]) # -------------------------------- # 'YYUSE' VAL, LOC if locations are enabled, and all the parse-params. m4_define([b4_parse_param_use], [m4_ifvaln([$1], [ YYUSE ([$1]);])dnl b4_locations_if([m4_ifvaln([$2], [ YYUSE ([$2]);])])dnl b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); ])dnl ]) ## ------------ ## ## Data Types. ## ## ------------ ## # b4_int_type(MIN, MAX) # --------------------- # Return the smallest int type able to handle numbers ranging from # MIN to MAX (included). m4_define([b4_int_type], [m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char], b4_ints_in($@, [-128], [127]), [1], [signed char], b4_ints_in($@, [0], [65535]), [1], [unsigned short int], b4_ints_in($@, [-32768], [32767]), [1], [short int], m4_eval([0 <= $1]), [1], [unsigned int], [int])]) # b4_int_type_for(NAME) # --------------------- # Return the smallest int type able to handle numbers ranging from # 'NAME_min' to 'NAME_max' (included). m4_define([b4_int_type_for], [b4_int_type($1_min, $1_max)]) # b4_table_value_equals(TABLE, VALUE, LITERAL) # -------------------------------------------- # 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. m4_define([b4_table_value_equals], [m4_if(m4_eval($3 < m4_indir([b4_]$1[_min]) || m4_indir([b4_]$1[_max]) < $3), [1], [[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. ## ## ---------## # b4_null_define # -------------- # Portability issues: define a YY_NULLPTR appropriate for the current # language (C, C++98, or C++11). m4_define([b4_null_define], [# ifndef YY_NULLPTR # if defined __cplusplus && 201103L <= __cplusplus # define YY_NULLPTR nullptr # else # define YY_NULLPTR 0 # endif # endif[]dnl ]) # b4_null # ------- # Return a null pointer constant. m4_define([b4_null], [YY_NULLPTR]) # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) # ------------------------------------------------------------- # Define "yy<TABLE-NAME>" 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-NUM) # -------------------------- # Output the definition of this token as #define. m4_define([b4_token_define], [b4_token_format([#define %s %s], [$1])]) # b4_token_defines # ---------------- # Output the definition of the tokens. m4_define([b4_token_defines], [b4_any_token_visible_if([/* Tokens. */ m4_join([ ], b4_symbol_map([b4_token_define])) ])]) # b4_token_enum(TOKEN-NUM) # ------------------------ # Output the definition of this token as an enum. m4_define([b4_token_enum], [b4_token_format([%s = %s], [$1])]) # b4_token_enums # -------------- # Output the definition of the tokens (if there are) as enums. m4_define([b4_token_enums], [b4_any_token_visible_if([[/* Token type. */ #ifndef ]b4_api_PREFIX[TOKENTYPE # define ]b4_api_PREFIX[TOKENTYPE enum ]b4_api_prefix[tokentype { ]m4_join([, ], b4_symbol_map([b4_token_enum]))[ }; #endif ]])]) # 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])]) ## ----------------- ## ## Semantic Values. ## ## ----------------- ## # 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]))]) ## ---------------------- ## ## Defining C functions. ## ## ---------------------- ## # b4_function_define(NAME, RETURN-VALUE, [DECL1, NAME1], ...) # ----------------------------------------------------------- # Declare the function NAME in C. m4_define([b4_function_define], [$2 $1 (b4_formals(m4_shift2($@)))[]dnl ]) # 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_formal], [, ], [$@])])]) m4_define([b4_formal], [$1]) ## ----------------------- ## ## Declaring C functions. ## ## ----------------------- ## # b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...) # ------------------------------------------------------------ # Declare the function NAME. m4_define([b4_function_declare], [$2 $1 (b4_formals(m4_shift2($@)));[]dnl ]) ## --------------------- ## ## Calling C functions. ## ## --------------------- ## # b4_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) # ----------------------------------------------------------- # Call the function NAME with arguments NAME1, NAME2 etc. m4_define([b4_function_call], [$1 (b4_args(m4_shift2($@)))[]dnl ]) # b4_args([DECL1, NAME1], ...) # ---------------------------- # Output the arguments NAME1, NAME2... m4_define([b4_args], [m4_map_sep([b4_arg], [, ], [$@])]) m4_define([b4_arg], [$2]) ## ----------- ## ## Synclines. ## ## ----------- ## # b4_sync_start(LINE, FILE) # ------------------------- m4_define([b4_sync_start], [[#]line $1 $2]) ## -------------- ## ## User actions. ## ## -------------- ## # b4_case(LABEL, STATEMENTS) # -------------------------- m4_define([b4_case], [ case $1: $2 b4_syncline([@oline@], [@ofile@]) break;]) # b4_predicate_case(LABEL, CONDITIONS) # ------------------------------------ m4_define([b4_predicate_case], [ case $1: if (! ($2)) YYERROR; b4_syncline([@oline@], [@ofile@]) break;]) # b4_yydestruct_define # -------------------- # Define the "yydestruct" function. m4_define_default([b4_yydestruct_define], [[/*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ ]b4_function_define([yydestruct], [static void], [[const char *yymsg], [yymsg]], [[int yytype], [yytype]], [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl m4_ifset([b4_parse_param], [, b4_parse_param]))[ { ]b4_parse_param_use([yyvaluep], [yylocationp])dnl [ if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN ]b4_symbol_actions([destructor])[ YY_IGNORE_MAYBE_UNINITIALIZED_END }]dnl ]) # b4_yy_symbol_print_define # ------------------------- # Define the "yy_symbol_print" function. m4_define_default([b4_yy_symbol_print_define], [[ /*----------------------------------------. | Print this symbol's value on YYOUTPUT. | `----------------------------------------*/ ]b4_function_define([yy_symbol_value_print], [static void], [[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; ]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); # endif ]])dnl b4_symbol_actions([printer])[ } /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ ]b4_function_define([yy_symbol_print], [static void], [[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]))[ { YYFPRINTF (yyoutput, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); ]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); YYFPRINTF (yyoutput, ": "); ])dnl [ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl b4_locations_if([, yylocationp])[]b4_user_args[); YYFPRINTF (yyoutput, ")"); }]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 (b4_union_members) 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_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 = variant. # # -------------------------- # # 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_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 ]b4_percent_define_get_syncline([[api.value.union.name]])[ union ]b4_percent_define_get([[api.value.union.name]])[ { ]b4_user_union_members[ }; ]b4_percent_define_get_syncline([[api.value.union.name]])[ typedef union ]b4_percent_define_get([[api.value.union.name]])[ ]b4_api_PREFIX[STYPE; # define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 # define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 #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 ]b4_api_PREFIX[LTYPE; struct ]b4_api_PREFIX[LTYPE { int first_line; int first_column; int last_line; int last_column; }; # define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 # define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 #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], [[/* Debug traces. */ ]m4_if(b4_api_prefix, [yy], [[#ifndef YYDEBUG # define YYDEBUG ]b4_parse_trace_if([1], [0])[ #endif]], [[#ifndef ]b4_api_PREFIX[DEBUG # if defined 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_parse_trace_if([1], [0])[ # endif /* ! defined YYDEBUG */ #endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl ]) # b4_declare_yydebug # ------------------ m4_define([b4_declare_yydebug], [b4_YYDEBUG_define[ #if ]b4_api_PREFIX[DEBUG extern int ]b4_prefix[debug; #endif][]dnl ]) # b4_yylloc_default_define # ------------------------ # Define YYLLOC_DEFAULT. m4_define([b4_yylloc_default_define], [[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ do \ if (N) \ { \ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ } \ else \ { \ (Current).first_line = (Current).last_line = \ YYRHSLOC (Rhs, 0).last_line; \ (Current).first_column = (Current).last_column = \ YYRHSLOC (Rhs, 0).last_column; \ } \ while (0) #endif ]]) # 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]), m4_defn([b4_location_initial_column]), m4_defn([b4_location_initial_line]), m4_defn([b4_location_initial_column]))[ } # endif ]])