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