]>
Commit | Line | Data |
---|---|---|
1 | -*- Autoconf -*- | |
2 | ||
3 | # Java language support for Bison | |
4 | ||
5 | # Copyright (C) 2007, 2008, 2009 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_comment(TEXT) | |
22 | # ---------------- | |
23 | m4_define([b4_comment], [/* m4_bpatsubst([$1], [ | |
24 | ], [ | |
25 | ]) */]) | |
26 | ||
27 | ||
28 | # b4_list2(LIST1, LIST2) | |
29 | # -------------------------- | |
30 | # Join two lists with a comma if necessary. | |
31 | m4_define([b4_list2], | |
32 | [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2]) | |
33 | ||
34 | ||
35 | # b4_percent_define_get3(DEF, PRE, POST, NOT) | |
36 | # ------------------------------------------- | |
37 | # Expand to the value of DEF surrounded by PRE and POST if it's %define'ed, | |
38 | # otherwise NOT. | |
39 | m4_define([b4_percent_define_get3], | |
40 | [m4_ifval(m4_quote(b4_percent_define_get([$1])), | |
41 | [$2[]b4_percent_define_get([$1])[]$3], [$4])]) | |
42 | ||
43 | ||
44 | ||
45 | # b4_flag_value(BOOLEAN-FLAG) | |
46 | # --------------------------- | |
47 | m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) | |
48 | ||
49 | ||
50 | # b4_public_if(TRUE, FALSE) | |
51 | # ------------------------- | |
52 | b4_percent_define_default([[public]], [[false]]) | |
53 | m4_define([b4_public_if], | |
54 | [b4_percent_define_flag_if([public], [$1], [$2])]) | |
55 | ||
56 | ||
57 | # b4_abstract_if(TRUE, FALSE) | |
58 | # --------------------------- | |
59 | b4_percent_define_default([[abstract]], [[false]]) | |
60 | m4_define([b4_abstract_if], | |
61 | [b4_percent_define_flag_if([abstract], [$1], [$2])]) | |
62 | ||
63 | ||
64 | # b4_final_if(TRUE, FALSE) | |
65 | # --------------------------- | |
66 | b4_percent_define_default([[final]], [[false]]) | |
67 | m4_define([b4_final_if], | |
68 | [b4_percent_define_flag_if([final], [$1], [$2])]) | |
69 | ||
70 | ||
71 | # b4_strictfp_if(TRUE, FALSE) | |
72 | # --------------------------- | |
73 | b4_percent_define_default([[strictfp]], [[false]]) | |
74 | m4_define([b4_strictfp_if], | |
75 | [b4_percent_define_flag_if([strictfp], [$1], [$2])]) | |
76 | ||
77 | ||
78 | # b4_lexer_if(TRUE, FALSE) | |
79 | # ------------------------ | |
80 | m4_define([b4_lexer_if], | |
81 | [b4_percent_code_ifdef([[lexer]], [$1], [$2])]) | |
82 | ||
83 | ||
84 | # b4_identification | |
85 | # ----------------- | |
86 | m4_define([b4_identification], | |
87 | [ /** Version number for the Bison executable that generated this parser. */ | |
88 | public static final String bisonVersion = "b4_version"; | |
89 | ||
90 | /** Name of the skeleton that generated this parser. */ | |
91 | public static final String bisonSkeleton = b4_skeleton; | |
92 | ]) | |
93 | ||
94 | ||
95 | ## ------------ ## | |
96 | ## Data types. ## | |
97 | ## ------------ ## | |
98 | ||
99 | # b4_int_type(MIN, MAX) | |
100 | # --------------------- | |
101 | # Return the smallest int type able to handle numbers ranging from | |
102 | # MIN to MAX (included). | |
103 | m4_define([b4_int_type], | |
104 | [m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], | |
105 | b4_ints_in($@, [-32768], [32767]), [1], [short], | |
106 | [int])]) | |
107 | ||
108 | # b4_int_type_for(NAME) | |
109 | # --------------------- | |
110 | # Return the smallest int type able to handle numbers ranging from | |
111 | # `NAME_min' to `NAME_max' (included). | |
112 | m4_define([b4_int_type_for], | |
113 | [b4_int_type($1_min, $1_max)]) | |
114 | ||
115 | # b4_null | |
116 | # ------- | |
117 | m4_define([b4_null], [null]) | |
118 | ||
119 | ||
120 | # b4_typed_parser_table_define(TYPE, NAME, DATA, COMMENT) | |
121 | # ------------------------------------------------------- | |
122 | m4_define([b4_typed_parser_table_define], | |
123 | [m4_ifval([$4], [b4_comment([$4]) | |
124 | ])dnl | |
125 | [private static final ]$1[ yy$2_[] = yy$2_init(); | |
126 | private static final ]$1[[] yy$2_init() | |
127 | { | |
128 | return new ]$1[[] | |
129 | { | |
130 | ]$3[ | |
131 | }; | |
132 | }]]) | |
133 | ||
134 | ||
135 | # b4_integral_parser_table_define(NAME, DATA, COMMENT) | |
136 | #----------------------------------------------------- | |
137 | m4_define([b4_integral_parser_table_define], | |
138 | [b4_typed_parser_table_define([b4_int_type_for([$2])], [$1], [$2], [$3])]) | |
139 | ||
140 | ||
141 | ## ------------------------- ## | |
142 | ## Assigning token numbers. ## | |
143 | ## ------------------------- ## | |
144 | ||
145 | # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) | |
146 | # --------------------------------------- | |
147 | # Output the definition of this token as an enum. | |
148 | m4_define([b4_token_enum], | |
149 | [ /** Token number, to be returned by the scanner. */ | |
150 | static final int b4_percent_define_get([token.prefix])$1 = $2; | |
151 | ]) | |
152 | ||
153 | ||
154 | # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) | |
155 | # ----------------------------------------------------- | |
156 | # Output the definition of the tokens (if there are) as enums. | |
157 | m4_define([b4_token_enums], | |
158 | [m4_if([$#$1], [1], [], | |
159 | [/* Tokens. */ | |
160 | m4_map([b4_token_enum], [$@])]) | |
161 | ]) | |
162 | ||
163 | # b4-case(ID, CODE) | |
164 | # ----------------- | |
165 | # We need to fool Java's stupid unreachable code detection. | |
166 | m4_define([b4_case], [ case $1: | |
167 | if (yyn == $1) | |
168 | $2; | |
169 | break; | |
170 | ]) | |
171 | ||
172 | ||
173 | ## ---------------- ## | |
174 | ## Default values. ## | |
175 | ## ---------------- ## | |
176 | ||
177 | m4_define([b4_yystype], [b4_percent_define_get([[stype]])]) | |
178 | b4_percent_define_default([[stype]], [[Object]]) | |
179 | ||
180 | # %name-prefix | |
181 | m4_define_default([b4_prefix], [[YY]]) | |
182 | ||
183 | b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser]) | |
184 | m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) | |
185 | ||
186 | b4_percent_define_default([[lex_throws]], [[java.io.IOException]]) | |
187 | m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])]) | |
188 | ||
189 | b4_percent_define_default([[throws]], []) | |
190 | m4_define([b4_throws], [b4_percent_define_get([[throws]])]) | |
191 | ||
192 | b4_percent_define_default([[init_throws]], []) | |
193 | m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])]) | |
194 | ||
195 | b4_percent_define_default([[location_type]], [Location]) | |
196 | m4_define([b4_location_type], [b4_percent_define_get([[location_type]])]) | |
197 | ||
198 | b4_percent_define_default([[position_type]], [Position]) | |
199 | m4_define([b4_position_type], [b4_percent_define_get([[position_type]])]) | |
200 | ||
201 | ||
202 | ## ----------------- ## | |
203 | ## Semantic Values. ## | |
204 | ## ----------------- ## | |
205 | ||
206 | ||
207 | # b4_lhs_value([TYPE]) | |
208 | # -------------------- | |
209 | # Expansion of $<TYPE>$. | |
210 | m4_define([b4_lhs_value], [yyval]) | |
211 | ||
212 | ||
213 | # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) | |
214 | # -------------------------------------- | |
215 | # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH | |
216 | # symbols on RHS. | |
217 | # | |
218 | # In this simple implementation, %token and %type have class names | |
219 | # between the angle brackets. | |
220 | m4_define([b4_rhs_value], | |
221 | [(m4_ifval($3, [($3)])[](yystack.valueAt ($1-($2))))]) | |
222 | ||
223 | # b4_lhs_location() | |
224 | # ----------------- | |
225 | # Expansion of @$. | |
226 | m4_define([b4_lhs_location], | |
227 | [(yyloc)]) | |
228 | ||
229 | ||
230 | # b4_rhs_location(RULE-LENGTH, NUM) | |
231 | # --------------------------------- | |
232 | # Expansion of @NUM, where the current rule has RULE-LENGTH symbols | |
233 | # on RHS. | |
234 | m4_define([b4_rhs_location], | |
235 | [yystack.locationAt ($1-($2))]) | |
236 | ||
237 | ||
238 | # b4_lex_param | |
239 | # b4_parse_param | |
240 | # -------------- | |
241 | # If defined, b4_lex_param arrives double quoted, but below we prefer | |
242 | # it to be single quoted. Same for b4_parse_param. | |
243 | ||
244 | # TODO: should be in bison.m4 | |
245 | m4_define_default([b4_lex_param], [[]]) | |
246 | m4_define([b4_lex_param], b4_lex_param) | |
247 | m4_define([b4_parse_param], b4_parse_param) | |
248 | ||
249 | # b4_lex_param_decl | |
250 | # ----------------- | |
251 | # Extra formal arguments of the constructor. | |
252 | m4_define([b4_lex_param_decl], | |
253 | [m4_ifset([b4_lex_param], | |
254 | [b4_remove_comma([$1], | |
255 | b4_param_decls(b4_lex_param))], | |
256 | [$1])]) | |
257 | ||
258 | m4_define([b4_param_decls], | |
259 | [m4_map([b4_param_decl], [$@])]) | |
260 | m4_define([b4_param_decl], [, $1]) | |
261 | ||
262 | m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)]) | |
263 | ||
264 | ||
265 | ||
266 | # b4_parse_param_decl | |
267 | # ------------------- | |
268 | # Extra formal arguments of the constructor. | |
269 | m4_define([b4_parse_param_decl], | |
270 | [m4_ifset([b4_parse_param], | |
271 | [b4_remove_comma([$1], | |
272 | b4_param_decls(b4_parse_param))], | |
273 | [$1])]) | |
274 | ||
275 | ||
276 | ||
277 | # b4_lex_param_call | |
278 | # ----------------- | |
279 | # Delegating the lexer parameters to the lexer constructor. | |
280 | m4_define([b4_lex_param_call], | |
281 | [m4_ifset([b4_lex_param], | |
282 | [b4_remove_comma([$1], | |
283 | b4_param_calls(b4_lex_param))], | |
284 | [$1])]) | |
285 | m4_define([b4_param_calls], | |
286 | [m4_map([b4_param_call], [$@])]) | |
287 | m4_define([b4_param_call], [, $2]) | |
288 | ||
289 | ||
290 | ||
291 | # b4_parse_param_cons | |
292 | # ------------------- | |
293 | # Extra initialisations of the constructor. | |
294 | m4_define([b4_parse_param_cons], | |
295 | [m4_ifset([b4_parse_param], | |
296 | [b4_constructor_calls(b4_parse_param)])]) | |
297 | ||
298 | m4_define([b4_constructor_calls], | |
299 | [m4_map([b4_constructor_call], [$@])]) | |
300 | m4_define([b4_constructor_call], | |
301 | [this.$2 = $2; | |
302 | ]) | |
303 | ||
304 | ||
305 | ||
306 | # b4_parse_param_vars | |
307 | # ------------------- | |
308 | # Extra instance variables. | |
309 | m4_define([b4_parse_param_vars], | |
310 | [m4_ifset([b4_parse_param], | |
311 | [ | |
312 | /* User arguments. */ | |
313 | b4_var_decls(b4_parse_param)])]) | |
314 | ||
315 | m4_define([b4_var_decls], | |
316 | [m4_map_sep([b4_var_decl], [ | |
317 | ], [$@])]) | |
318 | m4_define([b4_var_decl], | |
319 | [ protected final $1;]) | |
320 | ||
321 | ||
322 | ||
323 | # b4_maybe_throws(THROWS) | |
324 | # ----------------------- | |
325 | # Expand to either an empty string or "throws THROWS". | |
326 | m4_define([b4_maybe_throws], | |
327 | [m4_ifval($1, [throws $1])]) |