1 # Java tests for simple calculator. -*- Autotest -*-
3 # Copyright (C) 2007-2013 Free Software Foundation, Inc.
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.
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.
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/>.
18 AT_BANNER([[Java Calculator.]])
21 # ------------------------- #
22 # Helping Autotest macros. #
23 # ------------------------- #
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_BISON_OPTION_PUSHDEFS([%language "Java" $4])
37 [[/* Infix notation calculator--calc */
40 %define parser_class_name "Calc"
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;
53 /* Bison Declarations */
54 %token <Integer> NUM "number"
57 %nonassoc '=' /* comparison */
60 %precedence NEG /* negation--unary minus */
61 %right '^' /* exponentiation */
80 if ($1.intValue () != $3.intValue ())
81 yyerror (]AT_LOCATION_IF([[@$,]])[ "calc: error: " + $1 + " != " + $3);
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 (),
91 | '(' exp ')' { $$ = $2; }
92 | '(' error ')' { $$ = new Integer (1111); }
93 | '!' { $$ = new Integer (0); return YYERROR; }
94 | '-' error { $$ = new Integer (0); return YYERROR; }
102 class CalcLexer implements Calc.Lexer {
106 public ]AT_LEXPARAM_IF([[YYLexer]], [[CalcLexer]]) (InputStream is)
108 st = new StreamTokenizer (new InputStreamReader (is));
110 st.eolIsSignificant (true);
111 st.whitespaceChars (9, 9);
112 st.whitespaceChars (32, 32);
113 st.wordChars (48, 57);
117 Position yypos = new Position (1, 0);
119 public Position getStartPos() {
123 public Position getEndPos() {
131 public Object getLVal() {
135 public int yylex () throws IOException {
136 int ttype = st.nextToken ();
137 ]AT_LOCATION_IF([[yypos = new Position (yypos.lineno (),
138 yypos.token () + 1);]])[
139 if (ttype == st.TT_EOF)
142 else if (ttype == st.TT_EOL)
144 ]AT_LOCATION_IF([[yypos = new Position (yypos.lineno () + 1, 0);]])[
148 else if (ttype == st.TT_WORD)
150 yylval = new Integer (st.sval);
175 public Position (int l, int t)
181 public boolean equals (Position l)
183 return l.line == line && l.token == token;
186 public String toString ()
188 return Integer.toString (line) + "." + Integer.toString(token);
203 AT_BISON_OPTION_POPDEFS
204 ])# _AT_DATA_JAVA_CALC_Y
207 # AT_DATA_CALC_Y([BISON-OPTIONS])
208 # -------------------------------
210 m4_define([AT_DATA_JAVA_CALC_Y],
211 [_AT_DATA_JAVA_CALC_Y($[1], $[2], $[3], [$1])
215 # _AT_CHECK_JAVA_CALC_ERROR(BISON-OPTIONS, INPUT,
216 # [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
217 # --------------------------------------------------------------
218 # Run 'calc' on INPUT, and expect a 'syntax error' message.
220 # If INPUT starts with a slash, it is used as absolute input file name,
221 # otherwise as contents.
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])],
231 AT_JAVA_PARSER_CHECK([Calc < input], 0, [], [stderr])])
233 # Normalize the observed and expected error messages, depending upon the
235 # 1. Create the reference error message.
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]])
248 AT_CHECK([cat stderr], 0, [expout])
251 # _AT_CHECK_JAVA_CALC([BISON-DIRECTIVES], [BISON-CODE])
252 # -----------------------------------------------------
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])
259 AT_BISON_OPTION_PUSHDEFS([$1])
261 AT_DATA_JAVA_CALC_Y([$1
266 AT_BISON_CHECK([-o Calc.java Calc.y])
267 AT_JAVA_COMPILE([Calc.java])
269 # Test the priorities.
285 AT_JAVA_PARSER_CHECK([Calc < input], 0, [], [stderr])
288 # Some syntax errors.
289 _AT_CHECK_JAVA_CALC_ERROR([$1], [0 0],
290 [1.2: syntax error, unexpected number])
291 _AT_CHECK_JAVA_CALC_ERROR([$1], [1//2],
292 [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
293 _AT_CHECK_JAVA_CALC_ERROR([$1], [error],
294 [1.1: syntax error, unexpected $undefined])
295 _AT_CHECK_JAVA_CALC_ERROR([$1], [1 = 2 = 3],
296 [1.4: syntax error, unexpected '='])
297 _AT_CHECK_JAVA_CALC_ERROR([$1], [
299 [2.1: syntax error, unexpected '+'])
300 # Exercise error messages with EOF: work on an empty file.
301 _AT_CHECK_JAVA_CALC_ERROR([$1], [/dev/null],
302 [1.1: syntax error, unexpected end of input])
304 # Exercise the error token: without it, we die at the first error,
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
313 # - test the action associated to 'error'
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.
320 _AT_CHECK_JAVA_CALC_ERROR([$1],
321 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
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])
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],
331 [1.7: syntax error, unexpected number
332 1.1-1.10: calc: error: 2222 != 1])
333 _AT_CHECK_JAVA_CALC_ERROR([$1], [(- *) + (0 0) = 1],
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])
337 AT_BISON_OPTION_POPDEFS
340 ])# _AT_CHECK_JAVA_CALC
343 # AT_CHECK_JAVA_CALC([BISON-DIRECTIVES])
344 # --------------------------------------
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],
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])
353 ])# AT_CHECK_JAVA_CALC
356 # ------------------------ #
357 # Simple LALR Calculator. #
358 # ------------------------ #
360 AT_CHECK_JAVA_CALC([], [[
361 public static void main (String args[]) throws IOException
363 CalcLexer l = new CalcLexer (System.in);
364 Calc p = new Calc (l);
369 AT_CHECK_JAVA_CALC([%lex-param { InputStream is } ], [[
370 public static void main (String args[]) throws IOException
372 new Calc (System.in).parse ();
382 AT_BANNER([Java Parameters.])
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],
391 AT_DATA([[YYParser.y]], [
402 class m4_default([$3], [Position]) {}
404 AT_BISON_CHECK([[YYParser.y]])
405 AT_CHECK([[grep '[mb]4_' YYParser.y]], [1], [ignore])
406 AT_JAVA_COMPILE([[YYParser.java]])
410 # AT_CHECK_JAVA_MINIMAL_W_LEXER([1:DIRECTIVES], [2:LEX_THROWS],
411 # [3:YYLEX_ACTION], [4:LEXER_BODY], [5:PARSER_ACTION], [6:VALUE_TYPE],
412 # [7:POSITION_TYPE], [8:LOCATION_TYPE])
413 # ---------------------------------------------------------------------
414 # Check that a mininal parser with DIRECTIVES and a "%code lexer".
415 # YYLEX is the body of yylex () which throws LEX_THROW.
417 m4_define([AT_CHECK_JAVA_MINIMAL_W_LEXER],
418 [AT_CHECK_JAVA_MINIMAL([$1
422 m4_default([$6], [Object]) yylval;
423 public m4_default([$6], [Object]) getLVal() { return yylval; }
425 public m4_default([$7], [Position]) getStartPos() { return null; }
426 public m4_default([$7], [Position]) getEndPos() { return null; }
428 public void yyerror (m4_default([$8], [Location]) loc, String s)
430 System.err.println (loc + ": " + s);
433 public int yylex ()$2
442 # AT_CHECK_JAVA_GREP([LINE], [COUNT=1])
443 # -------------------------------------
444 # Check that YYParser.java contains exactly COUNT lines matching ^LINE$
446 m4_define([AT_CHECK_JAVA_GREP],
447 [AT_CHECK([grep -c '^$1$' YYParser.java], [], [m4_default([$2], [1])
452 # ------------------------------------- #
453 # Java parser class and package names. #
454 # ------------------------------------- #
456 AT_SETUP([Java parser class and package names])
458 AT_CHECK_JAVA_MINIMAL([])
459 AT_CHECK_JAVA_GREP([[class YYParser]])
461 AT_CHECK_JAVA_MINIMAL([[%name-prefix "Prefix"]])
462 AT_CHECK_JAVA_GREP([[class PrefixParser]])
464 AT_CHECK_JAVA_MINIMAL([[%define api.token.prefix {TOK_}]])
465 AT_CHECK_JAVA_GREP([[.*TOK_END.*]])
467 AT_CHECK_JAVA_MINIMAL([[%define parser_class_name "ParserClassName"]])
468 AT_CHECK_JAVA_GREP([[class ParserClassName]])
470 AT_CHECK_JAVA_MINIMAL([[%define package "user_java_package"]])
471 AT_CHECK_JAVA_GREP([[package user_java_package;]])
476 # ----------------------------- #
477 # Java parser class modifiers. #
478 # ----------------------------- #
480 AT_SETUP([Java parser class modifiers])
482 AT_CHECK_JAVA_MINIMAL([[%define abstract]])
483 AT_CHECK_JAVA_GREP([[abstract class YYParser]])
485 AT_CHECK_JAVA_MINIMAL([[%define final]])
486 AT_CHECK_JAVA_GREP([[final class YYParser]])
488 AT_CHECK_JAVA_MINIMAL([[%define strictfp]])
489 AT_CHECK_JAVA_GREP([[strictfp class YYParser]])
491 AT_CHECK_JAVA_MINIMAL([[
494 AT_CHECK_JAVA_GREP([[abstract strictfp class YYParser]])
496 AT_CHECK_JAVA_MINIMAL([[
499 AT_CHECK_JAVA_GREP([[final strictfp class YYParser]])
501 AT_CHECK_JAVA_MINIMAL([[%define public]])
502 AT_CHECK_JAVA_GREP([[public class YYParser]])
504 AT_CHECK_JAVA_MINIMAL([[
507 AT_CHECK_JAVA_GREP([[public abstract class YYParser]])
509 AT_CHECK_JAVA_MINIMAL([[
512 AT_CHECK_JAVA_GREP([[public final class YYParser]])
514 AT_CHECK_JAVA_MINIMAL([[
517 AT_CHECK_JAVA_GREP([[public strictfp class YYParser]])
519 AT_CHECK_JAVA_MINIMAL([[
523 AT_CHECK_JAVA_GREP([[public abstract strictfp class YYParser]])
525 AT_CHECK_JAVA_MINIMAL([[
529 AT_CHECK_JAVA_GREP([[public final strictfp class YYParser]])
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\"})*/"
535 AT_CHECK_JAVA_GREP([[/\*@Deprecated @SupressWarnings("unchecked") @SupressWarnings({"unchecked", "deprecation"}) @SupressWarnings(value={"unchecked", "deprecation"})\*/ public class YYParser]])
540 # ---------------------------------------- #
541 # Java parser class extends and implements #
542 # ---------------------------------------- #
544 AT_SETUP([Java parser class extends and implements])
546 AT_CHECK_JAVA_MINIMAL([[%define extends "Thread"]])
547 AT_CHECK_JAVA_GREP([[class YYParser extends Thread]])
549 AT_CHECK_JAVA_MINIMAL([[%define implements "Cloneable"]])
550 AT_CHECK_JAVA_GREP([[class YYParser implements Cloneable]])
552 AT_CHECK_JAVA_MINIMAL([[
553 %define extends "Thread"
554 %define implements "Cloneable"]])
555 AT_CHECK_JAVA_GREP([[class YYParser extends Thread implements Cloneable]])
560 # -------------------------------- #
561 # Java %parse-param and %lex-param #
562 # -------------------------------- #
564 AT_SETUP([Java %parse-param and %lex-param])
566 AT_CHECK_JAVA_MINIMAL([])
567 AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer) *]])
569 AT_CHECK_JAVA_MINIMAL([[%parse-param {int parse_param1}]])
570 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
571 AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer, *int parse_param1) *]])
572 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]])
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;]])
579 AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]])
580 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]])
581 AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]])
583 AT_CHECK_JAVA_MINIMAL_W_LEXER([], [], [[return EOF;]])
584 AT_CHECK_JAVA_GREP([[ *public YYParser () *]])
585 AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer) *]])
587 AT_CHECK_JAVA_MINIMAL_W_LEXER([[%parse-param {int parse_param1}]],
589 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
590 AT_CHECK_JAVA_GREP([[ *public YYParser (int parse_param1) *]])
591 AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1) *]])
592 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2])
594 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
595 %parse-param {int parse_param1}
596 %parse-param {long parse_param2}]],
598 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
599 AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]])
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) *]])
602 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2])
603 AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2])
605 AT_CHECK_JAVA_MINIMAL_W_LEXER([[%lex-param {char lex_param1}]],
606 [], [[return EOF;]], [[YYLexer (char lex_param1) {}]])
607 AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1) *]])
608 AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1);]])
610 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
611 %lex-param {char lex_param1}
612 %lex-param {short lex_param2}]],
613 [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]])
614 AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1, *short lex_param2) *]])
615 AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]])
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}]],
622 [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]])
623 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
624 AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]])
625 AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1, *short lex_param2, *int parse_param1, *long parse_param2) *]])
626 AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]])
627 AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]])
628 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2])
629 AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2])
634 # ------------------------- #
635 # Java throw specifications #
636 # ------------------------- #
638 AT_SETUP([Java throws specifications])
640 # %define throws - 0 1 2
641 # %define lex-throws - 0 1 2
644 m4_define([AT_JT_lex_throws_define], [m4_case(AT_JT_lex_throws,
646 0, [[%define lex_throws ""]],
647 1, [[%define lex_throws "InterruptedException"]],
648 2, [[%define lex_throws "InterruptedException, IllegalAccessException"]])])
650 m4_define([AT_JT_yylex_throws], [m4_case(AT_JT_lex_throws,
651 -1, [[ throws java.io.IOException]],
653 1, [[ throws InterruptedException]],
654 2, [[ throws InterruptedException, IllegalAccessException]])])
656 m4_define([AT_JT_yylex_action], [m4_case(AT_JT_lex_throws,
657 -1, [[throw new java.io.IOException();]],
659 1, [[throw new InterruptedException();]],
660 2, [[throw new IllegalAccessException();]])])
663 m4_define([AT_JT_throws_define], [m4_case(AT_JT_throws,
665 0, [[%define throws ""]],
666 1, [[%define throws "ClassNotFoundException"]],
667 2, [[%define throws "ClassNotFoundException, InstantiationException"]])])
669 m4_define([AT_JT_yyaction_throws], [m4_case(AT_JT_throws,
672 1, [[ throws ClassNotFoundException]],
673 2, [[ throws ClassNotFoundException, InstantiationException]])])
675 m4_define([AT_JT_parse_throws_2], [m4_case(AT_JT_throws,
678 1, [[, ClassNotFoundException]],
679 2, [[, ClassNotFoundException, InstantiationException]])])
681 m4_define([AT_JT_parse_throws],
682 [m4_if(m4_quote(AT_JT_yylex_throws), [],
683 [AT_JT_yyaction_throws],
684 [AT_JT_yylex_throws[]AT_JT_parse_throws_2])])
686 m4_define([AT_JT_initial_action], [m4_case(AT_JT_throws,
689 1, [[%initial-action {if (true) throw new ClassNotFoundException();}]],
690 2, [[%initial-action {if (true) throw new InstantiationException();}]])])
692 m4_define([AT_JT_parse_action], [m4_case(AT_JT_throws,
695 1, [[throw new ClassNotFoundException();]],
696 2, [[throw new ClassNotFoundException();]])])
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,
702 [AT_CHECK_JAVA_MINIMAL([
704 AT_JT_lex_throws_define
705 AT_JT_initial_action],
706 [AT_JT_parse_action])],
707 [AT_CHECK_JAVA_MINIMAL_W_LEXER([
709 AT_JT_lex_throws_define
710 AT_JT_initial_action],
711 [AT_JT_yylex_throws],
712 [AT_JT_yylex_action],
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[ *]])
723 # ------------------------------------- #
724 # Java constructor init and init_throws #
725 # ------------------------------------- #
727 AT_SETUP([Java constructor init and init_throws])
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]])
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]])
745 # ------------------------------------------ #
746 # Java value, position, and location types. #
747 # ------------------------------------------ #
749 AT_SETUP([Java value, position, and location types])
751 AT_CHECK_JAVA_MINIMAL([[
752 %define api.value.type "java.awt.Color"
753 %type<java.awt.Color> start;
754 %define api.location.type "MyLoc"
755 %define api.position.type "MyPos"
756 %code { class MyPos {} }]], [[$$ = $<java.awt.Color>1;]], [[MyPos]])
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])
761 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
762 %define api.value.type "java.awt.Color"
763 %type<java.awt.Color> start;
764 %define api.location.type "MyLoc"
765 %define api.position.type "MyPos"
766 %code { class MyPos {} }]], [], [[return EOF;]], [],
767 [[$$ = $<java.awt.Color>1;]],
768 [[java.awt.Color]], [[MyPos]], [[MyLoc]])
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])
776 # ----------------------------------------------- #
777 # Java syntax error handling without error token. #
778 # ----------------------------------------------- #
780 AT_SETUP([Java syntax error handling without error token])
782 AT_DATA([[YYParser.y]], [[%language "Java"
784 %lex-param { String s }
787 import java.io.IOException;
794 public YYLexer (String s)
800 public void yyerror (String s)
802 System.err.println (s);
805 public Object getLVal ()
810 public int yylex () throws IOException
812 if (Position >= Input.length ())
815 return Input.charAt (Position++);
820 public static void main (String args []) throws IOException
822 YYParser p = new YYParser (args [0]);
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
836 AT_JAVA_PARSER_CHECK([[YYParser ba]], [[0]], [[]], [[syntax error