X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/694af10cb7670fcbe198685d13d5db7f87a9b083..60aa04a236004d3d03f00aeaf07b643a52ef0760:/data/c.m4 diff --git a/data/c.m4 b/data/c.m4 index 1f266a47..adf5d4f1 100644 --- a/data/c.m4 +++ b/data/c.m4 @@ -48,11 +48,34 @@ m4_define([b4_cpp_guard_close], ## Identification. ## ## ---------------- ## -# b4_comment(TEXT) -# ---------------- -m4_define([b4_comment], [/* m4_bpatsubst([$1], [ -], [ - ]) */]) +# b4_comment_(TEXT, OPEN, CONTINUE, END) +# ------------------------------------- +# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. +# Avoid adding indentation to the first line, as the indentation comes +# from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]). +# +# Prefix all the output lines with PREFIX. +m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [ +\(.\)], [ +$3\1])$4]) + + +# b4_c_comment(TEXT, [PREFIX]) +# ---------------------------- +# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. +# Avoid adding indentation to the first line, as the indentation comes +# from "/*". That's why we don't patsubst([$1], [^\(.\)], [ \1]). +# +# Prefix all the output lines with PREFIX. +m4_define([b4_c_comment], +[b4_comment_([$1], [$2/* ], [$2 ], [$2 */])]) + + +# b4_comment(TEXT, [PREFIX]) +# -------------------------- +# By default, C comments. +m4_define([b4_comment], [b4_c_comment($@)]) + # b4_identification # ----------------- @@ -84,11 +107,24 @@ m4_define([b4_identification], ## 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. -m4_define_default([b4_union_name], [YYSTYPE]) +m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE]) -# If the %name-prefix is not given, it is yy. -m4_define_default([b4_prefix], [yy]) ## ------------------------ ## ## Pure/impure interfaces. ## @@ -121,11 +157,13 @@ m4_popdef([$2])dnl m4_popdef([$1])dnl ])]) -# b4_parse_param_use -# ------------------ -# `YYUSE' all the parse-params. +# b4_parse_param_use([VAL], [LOC]) +# -------------------------------- +# `YYUSE' VAL, LOC if locations are enabled, and all the parse-params. m4_define([b4_parse_param_use], -[b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); +[m4_ifvaln([$1], [ YYUSE([$1]);])dnl +b4_locations_if([m4_ifvaln([$2], [ YYUSE ([$2]);])])dnl +b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); ])dnl ]) @@ -147,7 +185,7 @@ m4_define([b4_int_type], m4_eval([0 <= $1]), [1], [unsigned int], - [int])]) + [int])]) # b4_int_type_for(NAME) @@ -196,6 +234,16 @@ m4_define([b4_null_define], # Return a null pointer constant. m4_define([b4_null], [YY_NULL]) +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "yy" which contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_c_comment([$3], [ ])])dnl +static const b4_int_type_for([$2]) yy$1[[]] = +{ + $2 +};dnl +]) ## ------------------------- ## @@ -206,7 +254,7 @@ m4_define([b4_null], [YY_NULL]) # ----------------------------------------- # Output the definition of this token as #define. m4_define([b4_token_define], -[#define $1 $2 +[#define b4_percent_define_get([api.tokens.prefix])$1 $2 ]) @@ -224,7 +272,7 @@ m4_map([b4_token_define], [$@])]) # --------------------------------------- # Output the definition of this token as an enum. m4_define([b4_token_enum], -[$1 = $2]) +[b4_percent_define_get([api.tokens.prefix])$1 = $2]) # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) @@ -232,18 +280,18 @@ m4_define([b4_token_enum], # Output the definition of the tokens (if there are) as enums. m4_define([b4_token_enums], [m4_if([$#$1], [1], [], -[/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE +[[/* Tokens. */ +#ifndef ]b4_api_PREFIX[TOKENTYPE +# define ]b4_api_PREFIX[TOKENTYPE /* Put the tokens into the symbol table, so that GDB and other debuggers know about them. */ - enum yytokentype { -m4_map_sep([ b4_token_enum], [, + enum ]b4_api_prefix[tokentype { +]m4_map_sep([ b4_token_enum], [, ], - [$@]) - }; + [$@]) + };[ #endif -])]) +]])]) # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) @@ -255,6 +303,21 @@ m4_define([b4_token_enums_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 in both K&R and ANSI-C. ## @@ -304,7 +367,7 @@ $1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl m4_define([b4_c_ansi_formals], [m4_if([$#], [0], [void], [$#$1], [1], [void], - [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) + [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) m4_define([b4_c_ansi_formal], [$1]) @@ -325,9 +388,9 @@ m4_define([b4_c_knr_formal_name], # Output the K&R argument declarations. m4_define([b4_c_knr_formal_decls], [m4_map_sep([b4_c_knr_formal_decl], - [ + [ ], - [$@])]) + [$@])]) m4_define([b4_c_knr_formal_decl], [ $1;]) @@ -343,7 +406,7 @@ m4_define([b4_c_knr_formal_decl], # ----------------------------------------------------------- # Declare the function NAME. m4_define([b4_c_function_decl], -[#if defined __STDC__ || defined __cplusplus +[#if b4_c_modern b4_c_ansi_function_decl($@) #else $2 $1 (); @@ -402,24 +465,17 @@ m4_define([b4_sync_start], [[#]line $1 $2]) m4_define([b4_case], [ case $1: $2 +b4_syncline([@oline@], [@ofile@]) break;]) -# b4_symbol_actions(FILENAME, LINENO, -# SYMBOL-TAG, SYMBOL-NUM, -# SYMBOL-ACTION, SYMBOL-TYPENAME) -# ------------------------------------------------- -m4_define([b4_symbol_actions], -[m4_pushdef([b4_dollar_dollar], - [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl -m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl - case $4: /* $3 */ -b4_syncline([$2], [$1]) - $5; + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], +[ case $1: + if (! ($2)) YYERROR; b4_syncline([@oline@], [@ofile@]) - break; -m4_popdef([b4_at_dollar])dnl -m4_popdef([b4_dollar_dollar])dnl -]) + break;]) # b4_yydestruct_generate(FUNCTION-DECLARATOR) @@ -441,20 +497,16 @@ m4_define_default([b4_yydestruct_generate], b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl m4_ifset([b4_parse_param], [, b4_parse_param]))[ { - YYUSE (yyvaluep); -]b4_locations_if([ YYUSE (yylocationp); -])dnl -b4_parse_param_use[]dnl -[ - if (!yymsg) +]b4_parse_param_use([yyvaluep], [yylocationp])dnl +[ if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); switch (yytype) { -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ - default: - break; +]b4_symbol_foreach([b4_symbol_destructor])dnl +[ default: + break; } }]dnl ]) @@ -474,30 +526,28 @@ m4_define_default([b4_yy_symbol_print_generate], /*ARGSUSED*/ ]$1([yy_symbol_value_print], [static void], - [[FILE *yyoutput], [yyoutput]], - [[int yytype], [yytype]], - [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl + [[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; - YYUSE (yyo); - if (!yyvaluep) - return; -]b4_locations_if([ YYUSE (yylocationp); -])dnl -b4_parse_param_use[]dnl -[# ifdef YYPRINT +]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); -# else - YYUSE (yyoutput); # endif - switch (yytype) +]])dnl +[ switch (yytype) { -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl +]b4_symbol_foreach([b4_symbol_printer])dnl [ default: - break; + break; } } @@ -508,9 +558,9 @@ b4_parse_param_use[]dnl ]$1([yy_symbol_print], [static void], - [[FILE *yyoutput], [yyoutput]], - [[int yytype], [yytype]], - [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl + [[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]))[ { @@ -533,49 +583,96 @@ b4_locations_if([, yylocationp])[]b4_user_args[); ## -------------- ## # 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], -[[#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED ]m4_ifdef([b4_stype], [[typedef union ]b4_union_name[ { ]b4_user_stype[ -} YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]], +} ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]], [m4_if(b4_tag_seen_flag, 0, -[[typedef int YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]])])[ -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 +[[typedef int ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]])])[ +# define ]b4_api_prefix[stype ]b4_api_PREFIX[STYPE /* obsolescent; will be withdrawn */ +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 #endif]b4_locations_if([[ -#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED -typedef struct YYLTYPE +#if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED +typedef struct ]b4_api_PREFIX[LTYPE { int first_line; int first_column; int last_line; int last_column; -} YYLTYPE; -# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ -# define YYLTYPE_IS_DECLARED 1 -# define YYLTYPE_IS_TRIVIAL 1 +} ]b4_api_PREFIX[LTYPE; +# define ]b4_api_prefix[ltype ]b4_api_PREFIX[LTYPE /* obsolescent; will be withdrawn */ +# define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 +# define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 #endif]]) -b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval; -]b4_locations_if([[extern YYLTYPE ]b4_prefix[lloc;]])])[]dnl +b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval; +]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl ]) -# b4_declare_yydebug +# b4_YYDEBUG_define # ------------------ -m4_define([b4_declare_yydebug], +m4_define([b4_YYDEBUG_define], [[/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ -#endif +]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 ]b4_api_PREFIX[DEBUG */ +#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 (YYID (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 (YYID (0)) +#endif +]])