]>
Commit | Line | Data |
---|---|---|
0049ec86 | 1 | # Java tests for simple calculator. -*- Autotest -*- |
8405b70c | 2 | |
34136e65 | 3 | # Copyright (C) 2007-2012 Free Software Foundation, Inc. |
8405b70c | 4 | |
f16b0819 | 5 | # This program is free software: you can redistribute it and/or modify |
8405b70c | 6 | # it under the terms of the GNU General Public License as published by |
f16b0819 PE |
7 | # the Free Software Foundation, either version 3 of the License, or |
8 | # (at your option) any later version. | |
9 | # | |
8405b70c PB |
10 | # This program is distributed in the hope that it will be useful, |
11 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | # GNU General Public License for more details. | |
f16b0819 | 14 | # |
8405b70c | 15 | # You should have received a copy of the GNU General Public License |
f16b0819 | 16 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
8405b70c PB |
17 | |
18 | AT_BANNER([[Java Calculator.]]) | |
19 | ||
20 | ||
21 | # ------------------------- # | |
22 | # Helping Autotest macros. # | |
23 | # ------------------------- # | |
24 | ||
25 | ||
01b477c6 | 26 | # _AT_DATA_JAVA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES]) |
417e31d2 | 27 | # ---------------------------------------------------- |
8405b70c PB |
28 | # Produce `calc.y'. Don't call this macro directly, because it contains |
29 | # some occurrences of `$1' etc. which will be interpreted by m4. So | |
30 | # you should call it with $1, $2, and $3 as arguments, which is what | |
31 | # AT_DATA_JAVA_CALC_Y does. | |
32 | m4_define([_AT_DATA_JAVA_CALC_Y], | |
33 | [m4_if([$1$2$3], $[1]$[2]$[3], [], | |
34 | [m4_fatal([$0: Invalid arguments: $@])])dnl | |
6d559547 | 35 | AT_BISON_OPTION_PUSHDEFS([%language "Java" $4]) |
8405b70c PB |
36 | AT_DATA([Calc.y], |
37 | [[/* Infix notation calculator--calc */ | |
38 | %language "Java" | |
01b477c6 | 39 | %name-prefix "Calc" |
8405b70c PB |
40 | %define parser_class_name "Calc" |
41 | %define public | |
42 | ||
01b477c6 PB |
43 | ]$4[ |
44 | ||
8405b70c PB |
45 | %code imports { |
46 | import java.io.StreamTokenizer; | |
47 | import java.io.InputStream; | |
48 | import java.io.InputStreamReader; | |
49 | import java.io.Reader; | |
50 | import java.io.IOException; | |
51 | } | |
52 | ||
53 | /* Bison Declarations */ | |
54 | %token <Integer> NUM "number" | |
55 | %type <Integer> exp | |
56 | ||
57 | %nonassoc '=' /* comparison */ | |
58 | %left '-' '+' | |
59 | %left '*' '/' | |
60 | %left NEG /* negation--unary minus */ | |
61 | %right '^' /* exponentiation */ | |
62 | ||
63 | /* Grammar follows */ | |
64 | %% | |
65 | input: | |
66 | line | |
67 | | input line | |
68 | ; | |
69 | ||
70 | line: | |
71 | '\n' | |
72 | | exp '\n' | |
73 | | error '\n' | |
74 | ; | |
75 | ||
76 | exp: | |
77 | NUM { $$ = $1; } | |
78 | | exp '=' exp | |
79 | { | |
80 | if ($1.intValue () != $3.intValue ()) | |
6771a463 | 81 | yyerror (]AT_LOCATION_IF([[@$,]])[ "calc: error: " + $1 + " != " + $3); |
8405b70c PB |
82 | } |
83 | | exp '+' exp { $$ = new Integer ($1.intValue () + $3.intValue ()); } | |
84 | | exp '-' exp { $$ = new Integer ($1.intValue () - $3.intValue ()); } | |
85 | | exp '*' exp { $$ = new Integer ($1.intValue () * $3.intValue ()); } | |
86 | | exp '/' exp { $$ = new Integer ($1.intValue () / $3.intValue ()); } | |
87 | | '-' exp %prec NEG { $$ = new Integer (-$2.intValue ()); } | |
88 | | exp '^' exp { $$ = new Integer ((int) | |
89 | Math.pow ($1.intValue (), | |
90 | $3.intValue ())); } | |
91 | | '(' exp ')' { $$ = $2; } | |
92 | | '(' error ')' { $$ = new Integer (1111); } | |
93 | | '!' { $$ = new Integer (0); return YYERROR; } | |
94 | | '-' error { $$ = new Integer (0); return YYERROR; } | |
95 | ; | |
01b477c6 PB |
96 | |
97 | ]AT_LEXPARAM_IF([[ | |
98 | %code lexer { | |
99 | ]], | |
100 | [[ | |
8405b70c | 101 | %% |
01b477c6 PB |
102 | class CalcLexer implements Calc.Lexer { |
103 | ]])[ | |
104 | StreamTokenizer st; | |
105 | ||
106 | public ]AT_LEXPARAM_IF([[YYLexer]], [[CalcLexer]]) (InputStream is) | |
107 | { | |
108 | st = new StreamTokenizer (new InputStreamReader (is)); | |
109 | st.resetSyntax (); | |
110 | st.eolIsSignificant (true); | |
111 | st.whitespaceChars (9, 9); | |
112 | st.whitespaceChars (32, 32); | |
113 | st.wordChars (48, 57); | |
114 | } | |
115 | ||
116 | AT_LOCATION_IF([[ | |
6771a463 | 117 | Position yypos = new Position (1, 0); |
8405b70c | 118 | |
01b477c6 | 119 | public Position getStartPos() { |
6771a463 | 120 | return yypos; |
8405b70c PB |
121 | } |
122 | ||
01b477c6 | 123 | public Position getEndPos() { |
6771a463 | 124 | return yypos; |
01b477c6 | 125 | } |
01b477c6 | 126 | ]])[ |
6d559547 | 127 | ]AT_YYERROR_DEFINE[ |
01b477c6 PB |
128 | |
129 | Integer yylval; | |
130 | ||
131 | public Object getLVal() { | |
132 | return yylval; | |
133 | } | |
134 | ||
135 | public int yylex () throws IOException { | |
136 | int ttype = st.nextToken (); | |
6771a463 JD |
137 | ]AT_LOCATION_IF([[yypos = new Position (yypos.lineno (), |
138 | yypos.token () + 1);]])[ | |
01b477c6 | 139 | if (ttype == st.TT_EOF) |
1979121c | 140 | return EOF; |
01b477c6 PB |
141 | |
142 | else if (ttype == st.TT_EOL) | |
143 | { | |
6771a463 | 144 | ]AT_LOCATION_IF([[yypos = new Position (yypos.lineno () + 1, 0);]])[ |
01b477c6 PB |
145 | return (int) '\n'; |
146 | } | |
147 | ||
148 | else if (ttype == st.TT_WORD) | |
149 | { | |
150 | yylval = new Integer (st.sval); | |
1979121c | 151 | return NUM; |
01b477c6 PB |
152 | } |
153 | ||
154 | else | |
155 | return st.ttype; | |
156 | } | |
157 | ||
158 | ||
159 | ]AT_LEXPARAM_IF([[ | |
160 | }; | |
161 | %%]], [[ | |
162 | }]]) | |
163 | ||
164 | [ | |
165 | class Position { | |
166 | public int line; | |
6771a463 | 167 | public int token; |
01b477c6 PB |
168 | |
169 | public Position () | |
170 | { | |
171 | line = 0; | |
6771a463 | 172 | token = 0; |
01b477c6 PB |
173 | } |
174 | ||
6771a463 | 175 | public Position (int l, int t) |
01b477c6 PB |
176 | { |
177 | line = l; | |
6771a463 | 178 | token = t; |
01b477c6 PB |
179 | } |
180 | ||
181 | public boolean equals (Position l) | |
182 | { | |
6771a463 | 183 | return l.line == line && l.token == token; |
01b477c6 PB |
184 | } |
185 | ||
186 | public String toString () | |
187 | { | |
6771a463 | 188 | return Integer.toString (line) + "." + Integer.toString(token); |
01b477c6 PB |
189 | } |
190 | ||
191 | public int lineno () | |
192 | { | |
193 | return line; | |
194 | } | |
6771a463 JD |
195 | |
196 | public int token () | |
197 | { | |
198 | return token; | |
199 | } | |
01b477c6 PB |
200 | } |
201 | ||
202 | ]]) | |
6d559547 | 203 | AT_BISON_OPTION_POPDEFS |
8405b70c PB |
204 | ])# _AT_DATA_JAVA_CALC_Y |
205 | ||
206 | ||
01b477c6 | 207 | # AT_DATA_CALC_Y([BISON-OPTIONS]) |
417e31d2 | 208 | # ------------------------------- |
8405b70c PB |
209 | # Produce `calc.y'. |
210 | m4_define([AT_DATA_JAVA_CALC_Y], | |
01b477c6 | 211 | [_AT_DATA_JAVA_CALC_Y($[1], $[2], $[3], [$1]) |
8405b70c PB |
212 | ]) |
213 | ||
214 | ||
8405b70c PB |
215 | # _AT_CHECK_JAVA_CALC_ERROR(BISON-OPTIONS, INPUT, |
216 | # [VERBOSE-AND-LOCATED-ERROR-MESSAGE]) | |
6d559547 | 217 | # -------------------------------------------------------------- |
8405b70c PB |
218 | # Run `calc' on INPUT, and expect a `syntax error' message. |
219 | # | |
220 | # If INPUT starts with a slash, it is used as absolute input file name, | |
221 | # otherwise as contents. | |
222 | # | |
223 | # The VERBOSE-AND-LOCATED-ERROR-MESSAGE is stripped of locations | |
224 | # and expected tokens if necessary, and compared with the output. | |
225 | m4_define([_AT_CHECK_JAVA_CALC_ERROR], | |
226 | [m4_bmatch([$2], [^/], | |
227 | [AT_JAVA_PARSER_CHECK([Calc < $2], 0, [], [stderr])], | |
228 | [AT_DATA([[input]], | |
229 | [[$2 | |
230 | ]]) | |
231 | AT_JAVA_PARSER_CHECK([Calc < input], 0, [], [stderr])]) | |
232 | ||
233 | # Normalize the observed and expected error messages, depending upon the | |
234 | # options. | |
235 | # 1. Create the reference error message. | |
236 | AT_DATA([[expout]], | |
237 | [$3 | |
238 | ]) | |
239 | # 2. If locations are not used, remove them. | |
240 | AT_YYERROR_SEES_LOC_IF([], | |
241 | [[sed 's/^[-0-9.]*: //' expout >at-expout | |
242 | mv at-expout expout]]) | |
243 | # 3. If error-verbose is not used, strip the`, unexpected....' part. | |
244 | m4_bmatch([$1], [%error-verbose], [], | |
245 | [[sed 's/syntax error, .*$/syntax error/' expout >at-expout | |
246 | mv at-expout expout]]) | |
247 | # 4. Check | |
248 | AT_CHECK([cat stderr], 0, [expout]) | |
249 | ]) | |
250 | ||
01b477c6 | 251 | # _AT_CHECK_JAVA_CALC([BISON-DIRECTIVES], [BISON-CODE]) |
417e31d2 | 252 | # ----------------------------------------------------- |
8405b70c PB |
253 | # Start a testing chunk which compiles `calc' grammar with |
254 | # BISON-DIRECTIVES, and performs several tests over the parser. | |
255 | m4_define([_AT_CHECK_JAVA_CALC], | |
256 | [# We use integers to avoid dependencies upon the precision of doubles. | |
257 | AT_SETUP([Calculator $1]) | |
258 | ||
259 | AT_BISON_OPTION_PUSHDEFS([$1]) | |
260 | ||
261 | AT_DATA_JAVA_CALC_Y([$1 | |
262 | %code { | |
263 | $2 | |
01b477c6 | 264 | }]) |
8405b70c | 265 | |
da730230 | 266 | AT_BISON_CHECK([-o Calc.java Calc.y]) |
8405b70c PB |
267 | AT_JAVA_COMPILE([Calc.java]) |
268 | ||
269 | # Test the priorities. | |
270 | AT_DATA([[input]], | |
271 | [[1 + 2 * 3 = 7 | |
272 | 1 + 2 * -3 = -5 | |
273 | ||
274 | -1^2 = -1 | |
275 | (-1)^2 = 1 | |
276 | ||
277 | ---1 = -1 | |
278 | ||
279 | 1 - 2 - 3 = -4 | |
280 | 1 - (2 - 3) = 2 | |
281 | ||
282 | 2^2^3 = 256 | |
283 | (2^2)^3 = 64 | |
284 | ]]) | |
285 | AT_JAVA_PARSER_CHECK([Calc < input], 0, [], [stderr]) | |
286 | ||
287 | ||
288 | # Some syntax errors. | |
289 | _AT_CHECK_JAVA_CALC_ERROR([$1], [0 0], | |
6771a463 | 290 | [1.2: syntax error, unexpected number]) |
8405b70c | 291 | _AT_CHECK_JAVA_CALC_ERROR([$1], [1//2], |
6771a463 | 292 | [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!']) |
8405b70c | 293 | _AT_CHECK_JAVA_CALC_ERROR([$1], [error], |
6771a463 | 294 | [1.1: syntax error, unexpected $undefined]) |
8405b70c | 295 | _AT_CHECK_JAVA_CALC_ERROR([$1], [1 = 2 = 3], |
6771a463 | 296 | [1.4: syntax error, unexpected '=']) |
8405b70c PB |
297 | _AT_CHECK_JAVA_CALC_ERROR([$1], [ |
298 | +1], | |
6771a463 | 299 | [2.1: syntax error, unexpected '+']) |
8405b70c PB |
300 | # Exercise error messages with EOF: work on an empty file. |
301 | _AT_CHECK_JAVA_CALC_ERROR([$1], [/dev/null], | |
6771a463 | 302 | [1.1: syntax error, unexpected end of input]) |
8405b70c PB |
303 | |
304 | # Exercise the error token: without it, we die at the first error, | |
305 | # hence be sure to | |
306 | # | |
307 | # - have several errors which exercise different shift/discardings | |
308 | # - (): nothing to pop, nothing to discard | |
309 | # - (1 + 1 + 1 +): a lot to pop, nothing to discard | |
310 | # - (* * *): nothing to pop, a lot to discard | |
311 | # - (1 + 2 * *): some to pop and discard | |
312 | # | |
313 | # - test the action associated to `error' | |
314 | # | |
315 | # - check the lookahead that triggers an error is not discarded | |
316 | # when we enter error recovery. Below, the lookahead causing the | |
317 | # first error is ")", which is needed to recover from the error and | |
318 | # produce the "0" that triggers the "0 != 1" error. | |
319 | # | |
11707b2b | 320 | _AT_CHECK_JAVA_CALC_ERROR([$1], |
8405b70c | 321 | [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1], |
6771a463 JD |
322 | [1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!' |
323 | 1.11: syntax error, unexpected ')', expecting number or '-' or '(' or '!' | |
324 | 1.14: syntax error, unexpected '*', expecting number or '-' or '(' or '!' | |
325 | 1.24: syntax error, unexpected '*', expecting number or '-' or '(' or '!' | |
326 | 1.1-1.27: calc: error: 4444 != 1]) | |
8405b70c PB |
327 | |
328 | # The same, but this time exercising explicitly triggered syntax errors. | |
329 | # POSIX says the lookahead causing the error should not be discarded. | |
330 | _AT_CHECK_JAVA_CALC_ERROR([$1], [(!) + (0 0) = 1], | |
6771a463 JD |
331 | [1.7: syntax error, unexpected number |
332 | 1.1-1.10: calc: error: 2222 != 1]) | |
8405b70c | 333 | _AT_CHECK_JAVA_CALC_ERROR([$1], [(- *) + (0 0) = 1], |
6771a463 JD |
334 | [1.3: syntax error, unexpected '*', expecting number or '-' or '(' or '!' |
335 | 1.8: syntax error, unexpected number | |
336 | 1.1-1.11: calc: error: 2222 != 1]) | |
8405b70c PB |
337 | AT_BISON_OPTION_POPDEFS |
338 | ||
339 | AT_CLEANUP | |
340 | ])# _AT_CHECK_JAVA_CALC | |
341 | ||
342 | ||
01b477c6 | 343 | # AT_CHECK_JAVA_CALC([BISON-DIRECTIVES]) |
417e31d2 | 344 | # -------------------------------------- |
8405b70c PB |
345 | # Start a testing chunk which compiles `calc' grammar with |
346 | # BISON-DIRECTIVES, and performs several tests over the parser. | |
347 | # Run the test with and without %error-verbose. | |
348 | m4_define([AT_CHECK_JAVA_CALC], | |
01b477c6 PB |
349 | [_AT_CHECK_JAVA_CALC([$1], [$2]) |
350 | _AT_CHECK_JAVA_CALC([%error-verbose $1], [$2]) | |
351 | _AT_CHECK_JAVA_CALC([%locations $1], [$2]) | |
352 | _AT_CHECK_JAVA_CALC([%error-verbose %locations $1], [$2]) | |
8405b70c PB |
353 | ])# AT_CHECK_JAVA_CALC |
354 | ||
355 | ||
356 | # ------------------------ # | |
357 | # Simple LALR Calculator. # | |
358 | # ------------------------ # | |
359 | ||
01b477c6 | 360 | AT_CHECK_JAVA_CALC([], [[ |
8405b70c PB |
361 | public static void main (String args[]) throws IOException |
362 | { | |
363 | CalcLexer l = new CalcLexer (System.in); | |
364 | Calc p = new Calc (l); | |
365 | p.parse (); | |
366 | } | |
01b477c6 | 367 | ]]) |
8405b70c | 368 | |
01b477c6 PB |
369 | AT_CHECK_JAVA_CALC([%lex-param { InputStream is } ], [[ |
370 | public static void main (String args[]) throws IOException | |
8405b70c | 371 | { |
01b477c6 | 372 | new Calc (System.in).parse (); |
8405b70c | 373 | } |
8405b70c | 374 | ]]) |
e254a580 DJ |
375 | |
376 | ||
377 | ||
378 | # -----------------# | |
379 | # Java Directives. # | |
380 | # -----------------# | |
381 | ||
382 | AT_BANNER([Java Parameters.]) | |
383 | ||
384 | ||
385 | # AT_CHECK_JAVA_MINIMAL([DIRECTIVES], [PARSER_ACTION], [POSITION_CLASS]) | |
386 | # ---------------------------------------------------------------------- | |
387 | # Check that a mininal parser with DIRECTIVES compiles in Java. | |
388 | # Put the Java code in YYParser.java. | |
389 | m4_define([AT_CHECK_JAVA_MINIMAL], | |
390 | [ | |
391 | AT_DATA([[YYParser.y]], [ | |
392 | %language "Java" | |
393 | %locations | |
394 | %debug | |
395 | %error-verbose | |
396 | %token-table | |
417e31d2 | 397 | %token END "end" |
e254a580 DJ |
398 | $1 |
399 | %% | |
417e31d2 | 400 | start: END {$2}; |
e254a580 DJ |
401 | %% |
402 | class m4_default([$3], [Position]) {} | |
403 | ]) | |
404 | AT_BISON_CHECK([[YYParser.y]]) | |
74553c98 | 405 | AT_CHECK([[grep '[mb]4_' YYParser.y]], [1], [ignore]) |
e254a580 DJ |
406 | AT_JAVA_COMPILE([[YYParser.java]]) |
407 | ]) | |
408 | ||
409 | ||
410 | # AT_CHECK_JAVA_MINIMAL_W_LEXER([1:DIRECTIVES], [2:LEX_THROWS], | |
e9690142 JD |
411 | # [3:YYLEX_ACTION], [4:LEXER_BODY], [5:PARSER_ACTION], [6:STYPE], |
412 | # [7:POSITION_TYPE], [8:LOCATION_TYPE]) | |
e254a580 DJ |
413 | # --------------------------------------------------------------------- |
414 | # Check that a mininal parser with DIRECTIVES and a "%code lexer". | |
415 | # YYLEX is the body of yylex () which throws LEX_THROW. | |
416 | # compiles in Java. | |
417 | m4_define([AT_CHECK_JAVA_MINIMAL_W_LEXER], | |
418 | [AT_CHECK_JAVA_MINIMAL([$1 | |
419 | ||
420 | %code lexer | |
421 | { | |
422 | m4_default([$6], [Object]) yylval; | |
423 | public m4_default([$6], [Object]) getLVal() { return yylval; } | |
424 | ||
425 | public m4_default([$7], [Position]) getStartPos() { return null; } | |
426 | public m4_default([$7], [Position]) getEndPos() { return null; } | |
427 | ||
428 | public void yyerror (m4_default([$8], [Location]) loc, String s) | |
429 | { | |
430 | System.err.println (loc + ": " + s); | |
431 | } | |
432 | ||
433 | public int yylex ()$2 | |
434 | { | |
435 | $3 | |
436 | } | |
11707b2b | 437 | |
e254a580 DJ |
438 | $4 |
439 | }], [$5], [$7])]) | |
440 | ||
441 | ||
442 | # AT_CHECK_JAVA_GREP([LINE], [COUNT=1]) | |
443 | # ------------------------------------- | |
444 | # Check that YYParser.java contains exactly COUNT lines matching ^LINE$ | |
445 | # with grep. | |
446 | m4_define([AT_CHECK_JAVA_GREP], | |
e9690142 | 447 | [AT_CHECK([grep -c '^$1$' YYParser.java], [], [m4_default([$2], [1]) |
e254a580 DJ |
448 | ]) |
449 | ]) | |
450 | ||
451 | ||
417e31d2 AD |
452 | # ------------------------------------- # |
453 | # Java parser class and package names. # | |
454 | # ------------------------------------- # | |
e254a580 DJ |
455 | |
456 | AT_SETUP([Java parser class and package names]) | |
457 | ||
458 | AT_CHECK_JAVA_MINIMAL([]) | |
459 | AT_CHECK_JAVA_GREP([[class YYParser]]) | |
460 | ||
461 | AT_CHECK_JAVA_MINIMAL([[%name-prefix "Prefix"]]) | |
462 | AT_CHECK_JAVA_GREP([[class PrefixParser]]) | |
463 | ||
2a6b66c5 | 464 | AT_CHECK_JAVA_MINIMAL([[%define api.token.prefix "TOK_"]]) |
417e31d2 AD |
465 | AT_CHECK_JAVA_GREP([[.*TOK_END.*]]) |
466 | ||
e254a580 DJ |
467 | AT_CHECK_JAVA_MINIMAL([[%define parser_class_name "ParserClassName"]]) |
468 | AT_CHECK_JAVA_GREP([[class ParserClassName]]) | |
469 | ||
470 | AT_CHECK_JAVA_MINIMAL([[%define package "user_java_package"]]) | |
471 | AT_CHECK_JAVA_GREP([[package user_java_package;]]) | |
472 | ||
473 | AT_CLEANUP | |
474 | ||
475 | ||
417e31d2 AD |
476 | # ----------------------------- # |
477 | # Java parser class modifiers. # | |
478 | # ----------------------------- # | |
e254a580 DJ |
479 | |
480 | AT_SETUP([Java parser class modifiers]) | |
481 | ||
482 | AT_CHECK_JAVA_MINIMAL([[%define abstract]]) | |
483 | AT_CHECK_JAVA_GREP([[abstract class YYParser]]) | |
484 | ||
485 | AT_CHECK_JAVA_MINIMAL([[%define final]]) | |
486 | AT_CHECK_JAVA_GREP([[final class YYParser]]) | |
487 | ||
488 | AT_CHECK_JAVA_MINIMAL([[%define strictfp]]) | |
489 | AT_CHECK_JAVA_GREP([[strictfp class YYParser]]) | |
490 | ||
491 | AT_CHECK_JAVA_MINIMAL([[ | |
492 | %define abstract | |
493 | %define strictfp]]) | |
494 | AT_CHECK_JAVA_GREP([[abstract strictfp class YYParser]]) | |
495 | ||
496 | AT_CHECK_JAVA_MINIMAL([[ | |
497 | %define final | |
498 | %define strictfp]]) | |
499 | AT_CHECK_JAVA_GREP([[final strictfp class YYParser]]) | |
500 | ||
501 | AT_CHECK_JAVA_MINIMAL([[%define public]]) | |
502 | AT_CHECK_JAVA_GREP([[public class YYParser]]) | |
503 | ||
504 | AT_CHECK_JAVA_MINIMAL([[ | |
505 | %define public | |
506 | %define abstract]]) | |
507 | AT_CHECK_JAVA_GREP([[public abstract class YYParser]]) | |
508 | ||
509 | AT_CHECK_JAVA_MINIMAL([[ | |
510 | %define public | |
511 | %define final]]) | |
512 | AT_CHECK_JAVA_GREP([[public final class YYParser]]) | |
513 | ||
514 | AT_CHECK_JAVA_MINIMAL([[ | |
515 | %define public | |
516 | %define strictfp]]) | |
517 | AT_CHECK_JAVA_GREP([[public strictfp class YYParser]]) | |
518 | ||
519 | AT_CHECK_JAVA_MINIMAL([[ | |
520 | %define public | |
521 | %define abstract | |
522 | %define strictfp]]) | |
523 | AT_CHECK_JAVA_GREP([[public abstract strictfp class YYParser]]) | |
524 | ||
525 | AT_CHECK_JAVA_MINIMAL([[ | |
526 | %define public | |
527 | %define final | |
528 | %define strictfp]]) | |
529 | AT_CHECK_JAVA_GREP([[public final strictfp class YYParser]]) | |
530 | ||
1979121c DJ |
531 | # FIXME: Can't do a Java compile because javacomp.sh is configured for 1.3 |
532 | AT_CHECK_JAVA_MINIMAL([[ | |
533 | %define annotations "/*@Deprecated @SupressWarnings(\"unchecked\") @SupressWarnings({\"unchecked\", \"deprecation\"}) @SupressWarnings(value={\"unchecked\", \"deprecation\"})*/" | |
534 | %define public]]) | |
535 | AT_CHECK_JAVA_GREP([[/\*@Deprecated @SupressWarnings("unchecked") @SupressWarnings({"unchecked", "deprecation"}) @SupressWarnings(value={"unchecked", "deprecation"})\*/ public class YYParser]]) | |
536 | ||
e254a580 DJ |
537 | AT_CLEANUP |
538 | ||
539 | ||
540 | # ---------------------------------------- # | |
541 | # Java parser class extends and implements # | |
542 | # ---------------------------------------- # | |
543 | ||
544 | AT_SETUP([Java parser class extends and implements]) | |
545 | ||
546 | AT_CHECK_JAVA_MINIMAL([[%define extends "Thread"]]) | |
547 | AT_CHECK_JAVA_GREP([[class YYParser extends Thread]]) | |
548 | ||
549 | AT_CHECK_JAVA_MINIMAL([[%define implements "Cloneable"]]) | |
550 | AT_CHECK_JAVA_GREP([[class YYParser implements Cloneable]]) | |
551 | ||
552 | AT_CHECK_JAVA_MINIMAL([[ | |
553 | %define extends "Thread" | |
554 | %define implements "Cloneable"]]) | |
555 | AT_CHECK_JAVA_GREP([[class YYParser extends Thread implements Cloneable]]) | |
556 | ||
557 | AT_CLEANUP | |
558 | ||
559 | ||
560 | # -------------------------------- # | |
561 | # Java %parse-param and %lex-param # | |
562 | # -------------------------------- # | |
563 | ||
564 | AT_SETUP([Java %parse-param and %lex-param]) | |
565 | ||
566 | AT_CHECK_JAVA_MINIMAL([]) | |
1979121c | 567 | AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer) *]]) |
e254a580 DJ |
568 | |
569 | AT_CHECK_JAVA_MINIMAL([[%parse-param {int parse_param1}]]) | |
570 | AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) | |
1979121c | 571 | AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer, *int parse_param1) *]]) |
11707b2b | 572 | AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]]) |
e254a580 DJ |
573 | |
574 | AT_CHECK_JAVA_MINIMAL([[ | |
575 | %parse-param {int parse_param1} | |
576 | %parse-param {long parse_param2}]]) | |
577 | AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) | |
578 | AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]]) | |
1979121c | 579 | AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]]) |
11707b2b AD |
580 | AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]]) |
581 | AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]]) | |
e254a580 DJ |
582 | |
583 | AT_CHECK_JAVA_MINIMAL_W_LEXER([], [], [[return EOF;]]) | |
1979121c DJ |
584 | AT_CHECK_JAVA_GREP([[ *public YYParser () *]]) |
585 | AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer) *]]) | |
e254a580 DJ |
586 | |
587 | AT_CHECK_JAVA_MINIMAL_W_LEXER([[%parse-param {int parse_param1}]], | |
1979121c | 588 | [], [[return EOF;]]) |
e254a580 | 589 | AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) |
1979121c DJ |
590 | AT_CHECK_JAVA_GREP([[ *public YYParser (int parse_param1) *]]) |
591 | AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1) *]]) | |
11707b2b | 592 | AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2]) |
e254a580 DJ |
593 | |
594 | AT_CHECK_JAVA_MINIMAL_W_LEXER([[ | |
595 | %parse-param {int parse_param1} | |
596 | %parse-param {long parse_param2}]], | |
1979121c | 597 | [], [[return EOF;]]) |
e254a580 DJ |
598 | AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) |
599 | AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]]) | |
1979121c DJ |
600 | AT_CHECK_JAVA_GREP([[ *public YYParser (int parse_param1, *long parse_param2) *]]) |
601 | AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]]) | |
11707b2b AD |
602 | AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2]) |
603 | AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2]) | |
e254a580 DJ |
604 | |
605 | AT_CHECK_JAVA_MINIMAL_W_LEXER([[%lex-param {char lex_param1}]], | |
1979121c DJ |
606 | [], [[return EOF;]], [[YYLexer (char lex_param1) {}]]) |
607 | AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1) *]]) | |
e254a580 DJ |
608 | AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1);]]) |
609 | ||
610 | AT_CHECK_JAVA_MINIMAL_W_LEXER([[ | |
611 | %lex-param {char lex_param1} | |
612 | %lex-param {short lex_param2}]], | |
1979121c DJ |
613 | [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]]) |
614 | AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1, *short lex_param2) *]]) | |
e254a580 DJ |
615 | AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]]) |
616 | ||
617 | AT_CHECK_JAVA_MINIMAL_W_LEXER([[ | |
618 | %parse-param {int parse_param1} | |
619 | %parse-param {long parse_param2} | |
620 | %lex-param {char lex_param1} | |
621 | %lex-param {short lex_param2}]], | |
1979121c | 622 | [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]]) |
e254a580 DJ |
623 | AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) |
624 | AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]]) | |
1979121c | 625 | AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1, *short lex_param2, *int parse_param1, *long parse_param2) *]]) |
e254a580 | 626 | AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]]) |
1979121c | 627 | AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]]) |
11707b2b AD |
628 | AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2]) |
629 | AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2]) | |
e254a580 DJ |
630 | |
631 | AT_CLEANUP | |
632 | ||
633 | ||
634 | # ------------------------- # | |
635 | # Java throw specifications # | |
636 | # ------------------------- # | |
637 | ||
638 | AT_SETUP([Java throws specifications]) | |
639 | ||
e9690142 JD |
640 | # %define throws - 0 1 2 |
641 | # %define lex-throws - 0 1 2 | |
642 | # %code lexer 0 1 | |
e254a580 DJ |
643 | |
644 | m4_define([AT_JT_lex_throws_define], [m4_case(AT_JT_lex_throws, | |
e9690142 JD |
645 | -1, [], |
646 | 0, [[%define lex_throws ""]], | |
647 | 1, [[%define lex_throws "InterruptedException"]], | |
648 | 2, [[%define lex_throws "InterruptedException, IllegalAccessException"]])]) | |
e254a580 DJ |
649 | |
650 | m4_define([AT_JT_yylex_throws], [m4_case(AT_JT_lex_throws, | |
e9690142 JD |
651 | -1, [[ throws java.io.IOException]], |
652 | 0, [], | |
653 | 1, [[ throws InterruptedException]], | |
654 | 2, [[ throws InterruptedException, IllegalAccessException]])]) | |
e254a580 DJ |
655 | |
656 | m4_define([AT_JT_yylex_action], [m4_case(AT_JT_lex_throws, | |
e9690142 JD |
657 | -1, [[throw new java.io.IOException();]], |
658 | 0, [[return EOF;]], | |
659 | 1, [[throw new InterruptedException();]], | |
660 | 2, [[throw new IllegalAccessException();]])]) | |
e254a580 DJ |
661 | |
662 | ||
663 | m4_define([AT_JT_throws_define], [m4_case(AT_JT_throws, | |
e9690142 JD |
664 | -1, [], |
665 | 0, [[%define throws ""]], | |
666 | 1, [[%define throws "ClassNotFoundException"]], | |
667 | 2, [[%define throws "ClassNotFoundException, InstantiationException"]])]) | |
e254a580 DJ |
668 | |
669 | m4_define([AT_JT_yyaction_throws], [m4_case(AT_JT_throws, | |
e9690142 JD |
670 | -1, [], |
671 | 0, [], | |
672 | 1, [[ throws ClassNotFoundException]], | |
673 | 2, [[ throws ClassNotFoundException, InstantiationException]])]) | |
e254a580 DJ |
674 | |
675 | m4_define([AT_JT_parse_throws_2], [m4_case(AT_JT_throws, | |
e9690142 JD |
676 | -1, [], |
677 | 0, [], | |
678 | 1, [[, ClassNotFoundException]], | |
679 | 2, [[, ClassNotFoundException, InstantiationException]])]) | |
e254a580 DJ |
680 | |
681 | m4_define([AT_JT_parse_throws], | |
e9690142 JD |
682 | [m4_if(m4_quote(AT_JT_yylex_throws), [], |
683 | [AT_JT_yyaction_throws], | |
684 | [AT_JT_yylex_throws[]AT_JT_parse_throws_2])]) | |
e254a580 DJ |
685 | |
686 | m4_define([AT_JT_initial_action], [m4_case(AT_JT_throws, | |
e9690142 JD |
687 | -1, [], |
688 | 0, [], | |
689 | 1, [[%initial-action {if (true) throw new ClassNotFoundException();}]], | |
690 | 2, [[%initial-action {if (true) throw new InstantiationException();}]])]) | |
e254a580 DJ |
691 | |
692 | m4_define([AT_JT_parse_action], [m4_case(AT_JT_throws, | |
e9690142 JD |
693 | -1, [], |
694 | 0, [], | |
695 | 1, [[throw new ClassNotFoundException();]], | |
696 | 2, [[throw new ClassNotFoundException();]])]) | |
e254a580 DJ |
697 | |
698 | m4_for([AT_JT_lexer], 0, 1, 1, | |
699 | [m4_for([AT_JT_lex_throws], -1, 2, 1, | |
700 | [m4_for([AT_JT_throws], -1, 2, 1, | |
701 | [m4_if(AT_JT_lexer, 0, | |
e9690142 | 702 | [AT_CHECK_JAVA_MINIMAL([ |
e254a580 DJ |
703 | AT_JT_throws_define |
704 | AT_JT_lex_throws_define | |
705 | AT_JT_initial_action], | |
706 | [AT_JT_parse_action])], | |
e9690142 | 707 | [AT_CHECK_JAVA_MINIMAL_W_LEXER([ |
e254a580 DJ |
708 | AT_JT_throws_define |
709 | AT_JT_lex_throws_define | |
710 | AT_JT_initial_action], | |
711 | [AT_JT_yylex_throws], | |
712 | [AT_JT_yylex_action], | |
713 | [], | |
714 | [AT_JT_parse_action])]) | |
715 | AT_CHECK_JAVA_GREP([[ *int yylex ()]AT_JT_yylex_throws *[;]]) | |
716 | AT_CHECK_JAVA_GREP([[ *private int yyaction ([^)]*)]AT_JT_yyaction_throws[ *]]) | |
717 | AT_CHECK_JAVA_GREP([[ *public boolean parse ()]AT_JT_parse_throws[ *]]) | |
718 | ])])]) | |
719 | ||
720 | AT_CLEANUP | |
721 | ||
722 | ||
1979121c DJ |
723 | # ------------------------------------- # |
724 | # Java constructor init and init_throws # | |
725 | # ------------------------------------- # | |
726 | ||
727 | AT_SETUP([Java constructor init and init_throws]) | |
728 | ||
729 | AT_CHECK_JAVA_MINIMAL([[ | |
730 | %define extends "Thread" | |
731 | %code init { super("Test Thread"); if (true) throw new InterruptedException(); } | |
732 | %define init_throws "InterruptedException" | |
733 | %lex-param {int lex_param}]]) | |
734 | AT_CHECK([[grep -q 'super("Test Thread"); if (true) throw new InterruptedException();' YYParser.java]]) | |
735 | ||
736 | AT_CHECK_JAVA_MINIMAL_W_LEXER([[ | |
737 | %define extends "Thread" | |
738 | %code init { super("Test Thread"); if (true) throw new InterruptedException(); } | |
739 | %define init_throws "InterruptedException"]], [], [[return EOF;]]) | |
740 | AT_CHECK([[grep -q 'super("Test Thread"); if (true) throw new InterruptedException();' YYParser.java]]) | |
741 | ||
742 | AT_CLEANUP | |
743 | ||
744 | ||
e254a580 DJ |
745 | # --------------------------------------------- # |
746 | # Java stype, position_class and location_class # | |
747 | # --------------------------------------------- # | |
748 | ||
749 | AT_SETUP([Java stype, position_class and location_class]) | |
750 | ||
751 | AT_CHECK_JAVA_MINIMAL([[ | |
752 | %define stype "java.awt.Color" | |
753 | %type<java.awt.Color> start; | |
f6b561d9 | 754 | %define api.location.type "MyLoc" |
7287be84 | 755 | %define api.position.type "MyPos" |
e254a580 | 756 | %code { class MyPos {} }]], [[$$ = $<java.awt.Color>1;]], [[MyPos]]) |
74553c98 AD |
757 | AT_CHECK([[grep 'java.awt.Color' YYParser.java]], [0], [ignore]) |
758 | AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Position']], [1], [ignore]) | |
759 | AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Location']], [1], [ignore]) | |
e254a580 DJ |
760 | |
761 | AT_CHECK_JAVA_MINIMAL_W_LEXER([[ | |
762 | %define stype "java.awt.Color" | |
763 | %type<java.awt.Color> start; | |
f6b561d9 | 764 | %define api.location.type "MyLoc" |
7287be84 | 765 | %define api.position.type "MyPos" |
e254a580 DJ |
766 | %code { class MyPos {} }]], [], [[return EOF;]], [], |
767 | [[$$ = $<java.awt.Color>1;]], | |
768 | [[java.awt.Color]], [[MyPos]], [[MyLoc]]) | |
74553c98 AD |
769 | AT_CHECK([[grep 'java.awt.Color' YYParser.java]], [0], [ignore]) |
770 | AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Position']], [1], [ignore]) | |
771 | AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Location']], [1], [ignore]) | |
e254a580 DJ |
772 | |
773 | AT_CLEANUP | |
e34e97bc TL |
774 | |
775 | ||
776 | # ----------------------------------------------- # | |
777 | # Java syntax error handling without error token. # | |
778 | # ----------------------------------------------- # | |
779 | ||
780 | AT_SETUP([Java syntax error handling without error token]) | |
781 | ||
782 | AT_DATA([[YYParser.y]], [[%language "Java" | |
783 | ||
784 | %lex-param { String s } | |
785 | ||
786 | %code imports { | |
787 | import java.io.IOException; | |
788 | } | |
789 | ||
790 | %code lexer { | |
791 | String Input; | |
792 | int Position; | |
793 | ||
794 | public YYLexer (String s) | |
795 | { | |
796 | Input = s; | |
797 | Position = 0; | |
798 | } | |
799 | ||
800 | public void yyerror (String s) | |
801 | { | |
802 | System.err.println (s); | |
803 | } | |
804 | ||
805 | public Object getLVal () | |
806 | { | |
807 | return null; | |
808 | } | |
809 | ||
810 | public int yylex () throws IOException | |
811 | { | |
812 | if (Position >= Input.length ()) | |
813 | return EOF; | |
814 | else | |
815 | return Input.charAt (Position++); | |
816 | } | |
817 | } | |
818 | ||
819 | %code { | |
820 | public static void main (String args []) throws IOException | |
821 | { | |
822 | YYParser p = new YYParser (args [0]); | |
823 | p.parse (); | |
824 | } | |
825 | } | |
826 | %% | |
827 | input: | |
828 | 'a' 'a' | |
829 | ; | |
830 | ]]) | |
831 | AT_BISON_CHECK([[YYParser.y]]) | |
832 | AT_JAVA_COMPILE([[YYParser.java]]) | |
833 | AT_JAVA_PARSER_CHECK([[YYParser aa]], [[0]], [[]], [[]]) | |
834 | AT_JAVA_PARSER_CHECK([[YYParser ab]], [[0]], [[]], [[syntax error | |
835 | ]]) | |
836 | AT_JAVA_PARSER_CHECK([[YYParser ba]], [[0]], [[]], [[syntax error | |
837 | ]]) | |
838 | ||
839 | AT_CLEANUP |