X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/c1d19e10c32844d17122b473840752003521d21b..1c72905811fa75e0715eb5ec1066dfcae520d070:/data/java.m4 diff --git a/data/java.m4 b/data/java.m4 index 38820f0d..6636bd69 100644 --- a/data/java.m4 +++ b/data/java.m4 @@ -2,22 +2,20 @@ # Java language support for Bison -# Copyright (C) 2007 Free Software Foundation, Inc. +# Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. -# This program is free software; you can redistribute it and/or modify +# 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 2 of the License, or +# 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, write to the Free Software -# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -# 02110-1301 USA +# along with this program. If not, see . # b4_comment(TEXT) @@ -27,6 +25,23 @@ m4_define([b4_comment], [/* m4_bpatsubst([$1], [ ]) */]) +# b4_list2(LIST1, LIST2) +# -------------------------- +# Join two lists with a comma if necessary. +m4_define([b4_list2], + [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2]) + + +# b4_percent_define_get3(DEF, PRE, POST, NOT) +# ------------------------------------------- +# Expand to the value of DEF surrounded by PRE and POST if it's %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_get3], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$2[]b4_percent_define_get([$1])[]$3], [$4])]) + + + # b4_flag_value(BOOLEAN-FLAG) # --------------------------- m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) @@ -38,26 +53,38 @@ b4_percent_define_default([[public]], [[false]]) m4_define([b4_public_if], [b4_percent_define_flag_if([public], [$1], [$2])]) -# b4_single_class_if(TRUE, FALSE) -# ------------------------------- -b4_percent_define_default([[single_class]], [[false]]) -m4_define([b4_single_class_if], -[b4_percent_define_flag_if([single_class], [$1], [$2])]) - # b4_abstract_if(TRUE, FALSE) # --------------------------- +b4_percent_define_default([[abstract]], [[false]]) m4_define([b4_abstract_if], -[b4_pure_if([$2], [b4_single_class_if([$2], [$1])])]) +[b4_percent_define_flag_if([abstract], [$1], [$2])]) + + +# b4_final_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[final]], [[false]]) +m4_define([b4_final_if], +[b4_percent_define_flag_if([final], [$1], [$2])]) + + +# b4_strictfp_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[strictfp]], [[false]]) +m4_define([b4_strictfp_if], +[b4_percent_define_flag_if([strictfp], [$1], [$2])]) + + +# b4_lexer_if(TRUE, FALSE) +# ------------------------ +m4_define([b4_lexer_if], +[b4_percent_code_ifdef([[lexer]], [$1], [$2])]) # b4_identification # ----------------- m4_define([b4_identification], -[/** Always true, identifies Bison output. */ - public static final boolean bison = true; - - /** Version number for the Bison executable that generated this parser. */ +[ /** Version number for the Bison executable that generated this parser. */ public static final String bisonVersion = "b4_version"; /** Name of the skeleton that generated this parser. */ @@ -76,7 +103,7 @@ m4_define([b4_identification], m4_define([b4_int_type], [m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], b4_ints_in($@, [-32768], [32767]), [1], [short], - [int])]) + [int])]) # b4_int_type_for(NAME) # --------------------- @@ -90,6 +117,27 @@ m4_define([b4_int_type_for], m4_define([b4_null], [null]) +# b4_typed_parser_table_define(TYPE, NAME, DATA, COMMENT) +# ------------------------------------------------------- +m4_define([b4_typed_parser_table_define], +[m4_ifval([$4], [b4_comment([$4]) + ])dnl +[private static final ]$1[ yy$2_[] = yy$2_init(); + private static final ]$1[[] yy$2_init() + { + return new ]$1[[] + { + ]$3[ + }; + }]]) + + +# b4_integral_parser_table_define(NAME, DATA, COMMENT) +#----------------------------------------------------- +m4_define([b4_integral_parser_table_define], +[b4_typed_parser_table_define([b4_int_type_for([$2])], [$1], [$2], [$3])]) + + ## ------------------------- ## ## Assigning token numbers. ## ## ------------------------- ## @@ -98,8 +146,8 @@ m4_define([b4_null], [null]) # --------------------------------------- # Output the definition of this token as an enum. m4_define([b4_token_enum], -[ /** Token number, to be returned by the scanner. */ - public static final int $1 = $2; +[ /** Token number, to be returned by the scanner. */ + static final int b4_percent_define_get([token.prefix])$1 = $2; ]) @@ -107,7 +155,7 @@ m4_define([b4_token_enum], # ----------------------------------------------------- # Output the definition of the tokens (if there are) as enums. m4_define([b4_token_enums], -[m4_if([$@], [[]], [], +[m4_if([$#$1], [1], [], [/* Tokens. */ m4_map([b4_token_enum], [$@])]) ]) @@ -126,23 +174,28 @@ m4_define([b4_case], [ case $1: ## Default values. ## ## ---------------- ## -m4_define([b4_union_name], [b4_percent_define_get([[union_name]])]) -b4_percent_define_default([[union_name]], [[Object]])]) +m4_define([b4_yystype], [b4_percent_define_get([[stype]])]) +b4_percent_define_default([[stype]], [[Object]]) -m4_define_default([[b4_prefix]], [[YY]])]) -b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser])]) +# %name-prefix +m4_define_default([b4_prefix], [[YY]]) + +b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser]) m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) -b4_percent_define_default([[lex_throws]], [[java.io.IOException]])]) +b4_percent_define_default([[lex_throws]], [[java.io.IOException]]) m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])]) -b4_percent_define_default([[throws]], [b4_lex_throws])]) +b4_percent_define_default([[throws]], []) m4_define([b4_throws], [b4_percent_define_get([[throws]])]) -b4_percent_define_default([[location_type]], [Location])]) +b4_percent_define_default([[init_throws]], []) +m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])]) + +b4_percent_define_default([[location_type]], [Location]) m4_define([b4_location_type], [b4_percent_define_get([[location_type]])]) -b4_percent_define_default([[position_type]], [Position])]) +b4_percent_define_default([[position_type]], [Position]) m4_define([b4_position_type], [b4_percent_define_get([[position_type]])]) @@ -165,7 +218,7 @@ m4_define([b4_lhs_value], [yyval]) # In this simple implementation, %token and %type have class names # between the angle brackets. m4_define([b4_rhs_value], -[(m4_ifval([$3], [($3)])[](yystack.valueAt ($1-($2))))]) +[(m4_ifval($3, [($3)])[](yystack.valueAt ($1-($2))))]) # b4_lhs_location() # ----------------- @@ -189,35 +242,24 @@ m4_define([b4_rhs_location], # it to be single quoted. Same for b4_parse_param. # TODO: should be in bison.m4 -m4_define_default([b4_lex_param], [[]])) -m4_define([b4_lex_param], b4_lex_param)) -m4_define([b4_parse_param], b4_parse_param)) +m4_define_default([b4_lex_param], [[]]) +m4_define([b4_lex_param], b4_lex_param) +m4_define([b4_parse_param], b4_parse_param) # b4_lex_param_decl -# ------------------- +# ----------------- # Extra formal arguments of the constructor. m4_define([b4_lex_param_decl], [m4_ifset([b4_lex_param], [b4_remove_comma([$1], - [m4_map([b4_lex_param_decl_1], [b4_lex_param])])], - [$1])]) - -m4_define([b4_lex_param_decl_1], [, $1]) -m4_define([b4_remove_comma], [m4_ifval([$1], [$1, ], [])m4_cdr([m4_cdr($@)])]) - + b4_param_decls(b4_lex_param))], + [$1])]) +m4_define([b4_param_decls], + [m4_map([b4_param_decl], [$@])]) +m4_define([b4_param_decl], [, $1]) -# b4_lex_param_call -# ------------------- -# Extra initialisations of the constructor. -m4_define([b4_lex_param_call], - [m4_ifset([b4_lex_param], - [b4_remove_comma([$1], - [b4_lex_param_calls(b4_lex_param)])], - [$1])]) -m4_define([b4_lex_param_calls], - [m4_map([b4_lex_param_call_1], [$@])]) -m4_define([b4_lex_param_call_1], [, $2]) +m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)]) @@ -227,11 +269,22 @@ m4_define([b4_lex_param_call_1], [, $2]) m4_define([b4_parse_param_decl], [m4_ifset([b4_parse_param], [b4_remove_comma([$1], - [m4_map([b4_parse_param_decl_1], - [b4_parse_param])])], - [$1])]) + b4_param_decls(b4_parse_param))], + [$1])]) -m4_define([b4_parse_param_decl_1], [, $1]) + + +# b4_lex_param_call +# ----------------- +# Delegating the lexer parameters to the lexer constructor. +m4_define([b4_lex_param_call], + [m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_calls(b4_lex_param))], + [$1])]) +m4_define([b4_param_calls], + [m4_map([b4_param_call], [$@])]) +m4_define([b4_param_call], [, $2]) @@ -240,29 +293,35 @@ m4_define([b4_parse_param_decl_1], [, $1]) # Extra initialisations of the constructor. m4_define([b4_parse_param_cons], [m4_ifset([b4_parse_param], - [b4_constructor_calls(b4_parse_param)])]) + [b4_constructor_calls(b4_parse_param)])]) + m4_define([b4_constructor_calls], - [m4_map([b4_constructor_call], [$@])]) + [m4_map([b4_constructor_call], [$@])]) m4_define([b4_constructor_call], - [this.$2 = $2; - ]) + [this.$2 = $2; + ]) + + # b4_parse_param_vars # ------------------- # Extra instance variables. m4_define([b4_parse_param_vars], [m4_ifset([b4_parse_param], - [ + [ /* User arguments. */ b4_var_decls(b4_parse_param)])]) + m4_define([b4_var_decls], - [m4_map_sep([b4_var_decl], [ + [m4_map_sep([b4_var_decl], [ ], [$@])]) m4_define([b4_var_decl], - [ protected final $1;]) + [ protected final $1;]) + + # b4_maybe_throws(THROWS) # ----------------------- # Expand to either an empty string or "throws THROWS". m4_define([b4_maybe_throws], - [m4_ifval([$1], [throws $1])]) + [m4_ifval($1, [throws $1])])