X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/0049ec8628e5a320d055a0cea8676a58cec60986..d1cc31c5f04b81a3620fa291020ce23490f3f9e7:/tests/java.at diff --git a/tests/java.at b/tests/java.at index b3316492..fa96558c 100644 --- a/tests/java.at +++ b/tests/java.at @@ -1,21 +1,19 @@ # Java tests for simple calculator. -*- Autotest -*- -# Copyright (C) 2007 Free Software Foundation, Inc. +# Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. -# This program is free software; you can redistribute it and/or modify +# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2, or (at your option) -# any later version. - +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. - +# # You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -# 02110-1301, USA. +# along with this program. If not, see . AT_BANNER([[Java Calculator.]]) @@ -25,8 +23,8 @@ AT_BANNER([[Java Calculator.]]) # ------------------------- # -# _AT_DATA_JAVA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES], [BISON-EPILOGUE]) -# ---------------------------------------------------------------------- +# _AT_DATA_JAVA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES]) +# ---------------------------------------------------- # Produce `calc.y'. Don't call this macro directly, because it contains # some occurrences of `$1' etc. which will be interpreted by m4. So # you should call it with $1, $2, and $3 as arguments, which is what @@ -37,11 +35,12 @@ m4_define([_AT_DATA_JAVA_CALC_Y], AT_DATA([Calc.y], [[/* Infix notation calculator--calc */ %language "Java" -%name-prefix "Calc"] +%name-prefix "Calc" %define parser_class_name "Calc" %define public -$4[ +]$4[ + %code imports { import java.io.StreamTokenizer; import java.io.InputStream; @@ -93,52 +92,130 @@ exp: | '!' { $$ = new Integer (0); return YYERROR; } | '-' error { $$ = new Integer (0); return YYERROR; } ; + +]AT_LEXPARAM_IF([[ +%code lexer { +]], +[[ %% +class CalcLexer implements Calc.Lexer { +]])[ + StreamTokenizer st; - class Position { - public int line; - - public Position () - { - line = 0; - } - - public Position (int l) - { - line = l; - } - - public long getHashCode () - { - return line; - } - - public boolean equals (Position l) - { - return l.line == line; - } - - public String toString () - { - return Integer.toString (line); - } - - public int lineno () - { - return line; - } + public ]AT_LEXPARAM_IF([[YYLexer]], [[CalcLexer]]) (InputStream is) + { + st = new StreamTokenizer (new InputStreamReader (is)); + st.resetSyntax (); + st.eolIsSignificant (true); + st.whitespaceChars (9, 9); + st.whitespaceChars (32, 32); + st.wordChars (48, 57); } -]$5 -]) +AT_LOCATION_IF([[ + Position yystartpos; + Position yyendpos = new Position (1); + + public Position getStartPos() { + return yystartpos; + } + + public Position getEndPos() { + return yyendpos; + } + + public void yyerror (Calc.Location l, String s) + { + if (l == null) + System.err.println (s); + else + System.err.println (l.begin + ": " + s); + } +]], [[ + public void yyerror (String s) + { + System.err.println (s); + } +]])[ + + Integer yylval; + + public Object getLVal() { + return yylval; + } + + public int yylex () throws IOException { + int ttype = st.nextToken (); + ]AT_LOCATION_IF([[yystartpos = yyendpos;]])[ + if (ttype == st.TT_EOF) + return EOF; + + else if (ttype == st.TT_EOL) + { + ]AT_LOCATION_IF([[yyendpos = new Position (yyendpos.lineno () + 1);]])[ + return (int) '\n'; + } + + else if (ttype == st.TT_WORD) + { + yylval = new Integer (st.sval); + return NUM; + } + + else + return st.ttype; + } + + +]AT_LEXPARAM_IF([[ +}; +%%]], [[ +}]]) + +[ +class Position { + public int line; + + public Position () + { + line = 0; + } + + public Position (int l) + { + line = l; + } + + public long getHashCode () + { + return line; + } + + public boolean equals (Position l) + { + return l.line == line; + } + + public String toString () + { + return Integer.toString (line); + } + + public int lineno () + { + return line; + } +} + +]]) ])# _AT_DATA_JAVA_CALC_Y -# AT_DATA_CALC_Y([BISON-OPTIONS], [BISON-EPILOGUE]) -# ------------------------------------------------- +# AT_DATA_CALC_Y([BISON-OPTIONS]) +# ------------------------------- # Produce `calc.y'. m4_define([AT_DATA_JAVA_CALC_Y], -[_AT_DATA_JAVA_CALC_Y($[1], $[2], $[3], [$1], [$2]) +[_AT_DATA_JAVA_CALC_Y($[1], $[2], $[3], [$1]) ]) @@ -148,7 +225,8 @@ m4_define([AT_DATA_JAVA_CALC_Y], # Compile SOURCES into Java class files. Skip the test if java or javac is # not installed. m4_define([AT_JAVA_COMPILE], -[AT_CHECK([test -n "$CONF_JAVA" || exit 77 +[AT_KEYWORDS(java) +AT_CHECK([test -n "$CONF_JAVA" || exit 77 test -n "$CONF_JAVAC" || exit 77]) AT_CHECK([$SHELL ../../../javacomp.sh $1], 0, [ignore], [ignore])]) @@ -196,8 +274,8 @@ mv at-expout expout]]) AT_CHECK([cat stderr], 0, [expout]) ]) -# _AT_CHECK_JAVA_CALC([BISON-DIRECTIVES], [BISON-CODE], [BISON-EPILOGUE]) -# ----------------------------------------------------------------------- +# _AT_CHECK_JAVA_CALC([BISON-DIRECTIVES], [BISON-CODE]) +# ----------------------------------------------------- # Start a testing chunk which compiles `calc' grammar with # BISON-DIRECTIVES, and performs several tests over the parser. m4_define([_AT_CHECK_JAVA_CALC], @@ -209,9 +287,9 @@ AT_BISON_OPTION_PUSHDEFS([$1]) AT_DATA_JAVA_CALC_Y([$1 %code { $2 -}], [$3]) +}]) -AT_CHECK([bison -o Calc.java Calc.y]) +AT_BISON_CHECK([-o Calc.java Calc.y]) AT_JAVA_COMPILE([Calc.java]) # Test the priorities. @@ -265,7 +343,7 @@ _AT_CHECK_JAVA_CALC_ERROR([$1], [/dev/null], # first error is ")", which is needed to recover from the error and # produce the "0" that triggers the "0 != 1" error. # -_AT_CHECK_JAVA_CALC_ERROR([$1], +_AT_CHECK_JAVA_CALC_ERROR([$1], [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1], [1: syntax error, unexpected ')', expecting number or '-' or '(' or '!' 1: syntax error, unexpected ')', expecting number or '-' or '(' or '!' @@ -288,14 +366,16 @@ AT_CLEANUP ])# _AT_CHECK_JAVA_CALC -# AT_CHECK_JAVA_CALC([BISON-DIRECTIVES], [BISON-EPILOGUE]) -# -------------------------------------------------------- +# AT_CHECK_JAVA_CALC([BISON-DIRECTIVES]) +# -------------------------------------- # Start a testing chunk which compiles `calc' grammar with # BISON-DIRECTIVES, and performs several tests over the parser. # Run the test with and without %error-verbose. m4_define([AT_CHECK_JAVA_CALC], -[_AT_CHECK_JAVA_CALC([$1], [$2], [$3]) -_AT_CHECK_JAVA_CALC([%error-verbose $1], [$2], [$3]) +[_AT_CHECK_JAVA_CALC([$1], [$2]) +_AT_CHECK_JAVA_CALC([%error-verbose $1], [$2]) +_AT_CHECK_JAVA_CALC([%locations $1], [$2]) +_AT_CHECK_JAVA_CALC([%error-verbose %locations $1], [$2]) ])# AT_CHECK_JAVA_CALC @@ -303,113 +383,417 @@ _AT_CHECK_JAVA_CALC([%error-verbose $1], [$2], [$3]) # Simple LALR Calculator. # # ------------------------ # -dnl AT_CHECK_JAVA_CALC([], []) - -AT_CHECK_JAVA_CALC([%define single_class %locations], [[ - StreamTokenizer st; - - public Calc (InputStream is) +AT_CHECK_JAVA_CALC([], [[ + public static void main (String args[]) throws IOException { - Reader r = new InputStreamReader (is); - st = new StreamTokenizer(r); - st.resetSyntax (); - st.eolIsSignificant (true); - st.whitespaceChars (9, 9); - st.whitespaceChars (32, 32); - st.wordChars (48, 57); + CalcLexer l = new CalcLexer (System.in); + Calc p = new Calc (l); + p.parse (); + } +]]) - yyendpos = new Position (1); +AT_CHECK_JAVA_CALC([%lex-param { InputStream is } ], [[ + public static void main (String args[]) throws IOException + { + new Calc (System.in).parse (); } +]]) - public int yylex () throws IOException { - int ttype = st.nextToken (); - yystartpos = yyendpos; - if (ttype == st.TT_EOF) - return EOF; - else if (ttype == st.TT_EOL) - { - yyendpos = new Position (yyendpos.lineno () + 1); - return (int) '\n'; - } - else if (ttype == st.TT_WORD) - { - yylval = new Integer (st.sval); - return NUM; - } +# -----------------# +# Java Directives. # +# -----------------# - else - return st.ttype; - } +AT_BANNER([Java Parameters.]) - public void yyerror (Location l, String s) - { - if (l == null) - System.err.println (s); - else - System.err.println (l.begin + ": " + s); - } - public static void main (String args[]) throws IOException - { - new Calc (System.in).parse (); - } -]]) +# AT_CHECK_JAVA_MINIMAL([DIRECTIVES], [PARSER_ACTION], [POSITION_CLASS]) +# ---------------------------------------------------------------------- +# Check that a mininal parser with DIRECTIVES compiles in Java. +# Put the Java code in YYParser.java. +m4_define([AT_CHECK_JAVA_MINIMAL], +[ +AT_DATA([[YYParser.y]], [ +%language "Java" +%locations +%debug +%error-verbose +%token-table +%token END "end" +$1 +%% +start: END {$2}; +%% +class m4_default([$3], [Position]) {} +]) +AT_BISON_CHECK([[YYParser.y]]) +AT_CHECK([[grep '[mb]4_' YYParser.y]], [1], [ignore]) +AT_JAVA_COMPILE([[YYParser.java]]) +]) -AT_CHECK_JAVA_CALC([%pure-parser], [[ - public static void main (String args[]) throws IOException - { - CalcLexer l = new CalcLexer (System.in); - Calc p = new Calc (l); - p.parse (); - } -]], [[ -class CalcLexer implements Calc.Lexer { - Integer yylval; - StreamTokenizer st; - - public Object getLVal () - { - return yylval; - } - - public CalcLexer (InputStream is) +# AT_CHECK_JAVA_MINIMAL_W_LEXER([1:DIRECTIVES], [2:LEX_THROWS], +# [3:YYLEX_ACTION], [4:LEXER_BODY], [5:PARSER_ACTION], [6:STYPE], +# [7:POSITION_TYPE], [8:LOCATION_TYPE]) +# --------------------------------------------------------------------- +# Check that a mininal parser with DIRECTIVES and a "%code lexer". +# YYLEX is the body of yylex () which throws LEX_THROW. +# compiles in Java. +m4_define([AT_CHECK_JAVA_MINIMAL_W_LEXER], +[AT_CHECK_JAVA_MINIMAL([$1 + +%code lexer +{ + m4_default([$6], [Object]) yylval; + public m4_default([$6], [Object]) getLVal() { return yylval; } + + public m4_default([$7], [Position]) getStartPos() { return null; } + public m4_default([$7], [Position]) getEndPos() { return null; } + + public void yyerror (m4_default([$8], [Location]) loc, String s) { - Reader r = new InputStreamReader (is); - st = new StreamTokenizer(r); - st.resetSyntax (); - st.eolIsSignificant (true); - st.whitespaceChars (9, 9); - st.whitespaceChars (32, 32); - st.wordChars (48, 57); - } - - public int yylex () throws IOException { - int ttype = st.nextToken (); - if (ttype == st.TT_EOF) - return Calc.EOF; - - else if (ttype == st.TT_EOL) - return (int) '\n'; - - else if (ttype == st.TT_WORD) - { - yylval = new Integer (st.sval); - return Calc.NUM; - } - - else - return st.ttype; + System.err.println (loc + ": " + s); } - - public void yyerror (String s) + public int yylex ()$2 { - System.err.println (s); + $3 } -} -]]) -dnl AT_CHECK_JAVA_CALC([%pure-parser %locations], []) + $4 +}], [$5], [$7])]) + + +# AT_CHECK_JAVA_GREP([LINE], [COUNT=1]) +# ------------------------------------- +# Check that YYParser.java contains exactly COUNT lines matching ^LINE$ +# with grep. +m4_define([AT_CHECK_JAVA_GREP], + [AT_CHECK([grep -c '^$1$' YYParser.java], [], [m4_default([$2], [1]) +]) +]) + + +# ------------------------------------- # +# Java parser class and package names. # +# ------------------------------------- # + +AT_SETUP([Java parser class and package names]) + +AT_CHECK_JAVA_MINIMAL([]) +AT_CHECK_JAVA_GREP([[class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[%name-prefix "Prefix"]]) +AT_CHECK_JAVA_GREP([[class PrefixParser]]) + +AT_CHECK_JAVA_MINIMAL([[%define api.tokens.prefix "TOK_"]]) +AT_CHECK_JAVA_GREP([[.*TOK_END.*]]) + +AT_CHECK_JAVA_MINIMAL([[%define parser_class_name "ParserClassName"]]) +AT_CHECK_JAVA_GREP([[class ParserClassName]]) + +AT_CHECK_JAVA_MINIMAL([[%define package "user_java_package"]]) +AT_CHECK_JAVA_GREP([[package user_java_package;]]) + +AT_CLEANUP + + +# ----------------------------- # +# Java parser class modifiers. # +# ----------------------------- # + +AT_SETUP([Java parser class modifiers]) + +AT_CHECK_JAVA_MINIMAL([[%define abstract]]) +AT_CHECK_JAVA_GREP([[abstract class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[%define final]]) +AT_CHECK_JAVA_GREP([[final class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[%define strictfp]]) +AT_CHECK_JAVA_GREP([[strictfp class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define abstract +%define strictfp]]) +AT_CHECK_JAVA_GREP([[abstract strictfp class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define final +%define strictfp]]) +AT_CHECK_JAVA_GREP([[final strictfp class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[%define public]]) +AT_CHECK_JAVA_GREP([[public class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define public +%define abstract]]) +AT_CHECK_JAVA_GREP([[public abstract class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define public +%define final]]) +AT_CHECK_JAVA_GREP([[public final class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define public +%define strictfp]]) +AT_CHECK_JAVA_GREP([[public strictfp class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define public +%define abstract +%define strictfp]]) +AT_CHECK_JAVA_GREP([[public abstract strictfp class YYParser]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define public +%define final +%define strictfp]]) +AT_CHECK_JAVA_GREP([[public final strictfp class YYParser]]) + +# FIXME: Can't do a Java compile because javacomp.sh is configured for 1.3 +AT_CHECK_JAVA_MINIMAL([[ +%define annotations "/*@Deprecated @SupressWarnings(\"unchecked\") @SupressWarnings({\"unchecked\", \"deprecation\"}) @SupressWarnings(value={\"unchecked\", \"deprecation\"})*/" +%define public]]) +AT_CHECK_JAVA_GREP([[/\*@Deprecated @SupressWarnings("unchecked") @SupressWarnings({"unchecked", "deprecation"}) @SupressWarnings(value={"unchecked", "deprecation"})\*/ public class YYParser]]) + +AT_CLEANUP + + +# ---------------------------------------- # +# Java parser class extends and implements # +# ---------------------------------------- # + +AT_SETUP([Java parser class extends and implements]) + +AT_CHECK_JAVA_MINIMAL([[%define extends "Thread"]]) +AT_CHECK_JAVA_GREP([[class YYParser extends Thread]]) + +AT_CHECK_JAVA_MINIMAL([[%define implements "Cloneable"]]) +AT_CHECK_JAVA_GREP([[class YYParser implements Cloneable]]) + +AT_CHECK_JAVA_MINIMAL([[ +%define extends "Thread" +%define implements "Cloneable"]]) +AT_CHECK_JAVA_GREP([[class YYParser extends Thread implements Cloneable]]) + +AT_CLEANUP + + +# -------------------------------- # +# Java %parse-param and %lex-param # +# -------------------------------- # + +AT_SETUP([Java %parse-param and %lex-param]) + +AT_CHECK_JAVA_MINIMAL([]) +AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer) *]]) + +AT_CHECK_JAVA_MINIMAL([[%parse-param {int parse_param1}]]) +AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) +AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer, *int parse_param1) *]]) +AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]]) + +AT_CHECK_JAVA_MINIMAL([[ +%parse-param {int parse_param1} +%parse-param {long parse_param2}]]) +AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) +AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]]) +AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]]) +AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]]) +AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([], [], [[return EOF;]]) +AT_CHECK_JAVA_GREP([[ *public YYParser () *]]) +AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer) *]]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([[%parse-param {int parse_param1}]], + [], [[return EOF;]]) +AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) +AT_CHECK_JAVA_GREP([[ *public YYParser (int parse_param1) *]]) +AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1) *]]) +AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([[ +%parse-param {int parse_param1} +%parse-param {long parse_param2}]], + [], [[return EOF;]]) +AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) +AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]]) +AT_CHECK_JAVA_GREP([[ *public YYParser (int parse_param1, *long parse_param2) *]]) +AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]]) +AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2]) +AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([[%lex-param {char lex_param1}]], + [], [[return EOF;]], [[YYLexer (char lex_param1) {}]]) +AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1) *]]) +AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1);]]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([[ +%lex-param {char lex_param1} +%lex-param {short lex_param2}]], + [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]]) +AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1, *short lex_param2) *]]) +AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([[ +%parse-param {int parse_param1} +%parse-param {long parse_param2} +%lex-param {char lex_param1} +%lex-param {short lex_param2}]], + [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]]) +AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]]) +AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]]) +AT_CHECK_JAVA_GREP([[ *public YYParser (char lex_param1, *short lex_param2, *int parse_param1, *long parse_param2) *]]) +AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]]) +AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer, *int parse_param1, *long parse_param2) *]]) +AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2]) +AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2]) + +AT_CLEANUP + + +# ------------------------- # +# Java throw specifications # +# ------------------------- # + +AT_SETUP([Java throws specifications]) + +# %define throws - 0 1 2 +# %define lex-throws - 0 1 2 +# %code lexer 0 1 + +m4_define([AT_JT_lex_throws_define], [m4_case(AT_JT_lex_throws, + -1, [], + 0, [[%define lex_throws ""]], + 1, [[%define lex_throws "InterruptedException"]], + 2, [[%define lex_throws "InterruptedException, IllegalAccessException"]])]) + +m4_define([AT_JT_yylex_throws], [m4_case(AT_JT_lex_throws, + -1, [[ throws java.io.IOException]], + 0, [], + 1, [[ throws InterruptedException]], + 2, [[ throws InterruptedException, IllegalAccessException]])]) + +m4_define([AT_JT_yylex_action], [m4_case(AT_JT_lex_throws, + -1, [[throw new java.io.IOException();]], + 0, [[return EOF;]], + 1, [[throw new InterruptedException();]], + 2, [[throw new IllegalAccessException();]])]) + + +m4_define([AT_JT_throws_define], [m4_case(AT_JT_throws, + -1, [], + 0, [[%define throws ""]], + 1, [[%define throws "ClassNotFoundException"]], + 2, [[%define throws "ClassNotFoundException, InstantiationException"]])]) + +m4_define([AT_JT_yyaction_throws], [m4_case(AT_JT_throws, + -1, [], + 0, [], + 1, [[ throws ClassNotFoundException]], + 2, [[ throws ClassNotFoundException, InstantiationException]])]) + +m4_define([AT_JT_parse_throws_2], [m4_case(AT_JT_throws, + -1, [], + 0, [], + 1, [[, ClassNotFoundException]], + 2, [[, ClassNotFoundException, InstantiationException]])]) + +m4_define([AT_JT_parse_throws], + [m4_if(m4_quote(AT_JT_yylex_throws), [], + [AT_JT_yyaction_throws], + [AT_JT_yylex_throws[]AT_JT_parse_throws_2])]) + +m4_define([AT_JT_initial_action], [m4_case(AT_JT_throws, + -1, [], + 0, [], + 1, [[%initial-action {if (true) throw new ClassNotFoundException();}]], + 2, [[%initial-action {if (true) throw new InstantiationException();}]])]) + +m4_define([AT_JT_parse_action], [m4_case(AT_JT_throws, + -1, [], + 0, [], + 1, [[throw new ClassNotFoundException();]], + 2, [[throw new ClassNotFoundException();]])]) + +m4_for([AT_JT_lexer], 0, 1, 1, + [m4_for([AT_JT_lex_throws], -1, 2, 1, + [m4_for([AT_JT_throws], -1, 2, 1, + [m4_if(AT_JT_lexer, 0, + [AT_CHECK_JAVA_MINIMAL([ +AT_JT_throws_define +AT_JT_lex_throws_define +AT_JT_initial_action], +[AT_JT_parse_action])], + [AT_CHECK_JAVA_MINIMAL_W_LEXER([ +AT_JT_throws_define +AT_JT_lex_throws_define +AT_JT_initial_action], +[AT_JT_yylex_throws], +[AT_JT_yylex_action], +[], +[AT_JT_parse_action])]) +AT_CHECK_JAVA_GREP([[ *int yylex ()]AT_JT_yylex_throws *[;]]) +AT_CHECK_JAVA_GREP([[ *private int yyaction ([^)]*)]AT_JT_yyaction_throws[ *]]) +AT_CHECK_JAVA_GREP([[ *public boolean parse ()]AT_JT_parse_throws[ *]]) +])])]) + +AT_CLEANUP + + +# ------------------------------------- # +# Java constructor init and init_throws # +# ------------------------------------- # + +AT_SETUP([Java constructor init and init_throws]) + +AT_CHECK_JAVA_MINIMAL([[ +%define extends "Thread" +%code init { super("Test Thread"); if (true) throw new InterruptedException(); } +%define init_throws "InterruptedException" +%lex-param {int lex_param}]]) +AT_CHECK([[grep -q 'super("Test Thread"); if (true) throw new InterruptedException();' YYParser.java]]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([[ +%define extends "Thread" +%code init { super("Test Thread"); if (true) throw new InterruptedException(); } +%define init_throws "InterruptedException"]], [], [[return EOF;]]) +AT_CHECK([[grep -q 'super("Test Thread"); if (true) throw new InterruptedException();' YYParser.java]]) + +AT_CLEANUP + + +# --------------------------------------------- # +# Java stype, position_class and location_class # +# --------------------------------------------- # + +AT_SETUP([Java stype, position_class and location_class]) + +AT_CHECK_JAVA_MINIMAL([[ +%define stype "java.awt.Color" +%type start; +%define location_type "MyLoc" +%define position_type "MyPos" +%code { class MyPos {} }]], [[$$ = $1;]], [[MyPos]]) +AT_CHECK([[grep 'java.awt.Color' YYParser.java]], [0], [ignore]) +AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Position']], [1], [ignore]) +AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Location']], [1], [ignore]) + +AT_CHECK_JAVA_MINIMAL_W_LEXER([[ +%define stype "java.awt.Color" +%type start; +%define location_type "MyLoc" +%define position_type "MyPos" +%code { class MyPos {} }]], [], [[return EOF;]], [], +[[$$ = $1;]], +[[java.awt.Color]], [[MyPos]], [[MyLoc]]) +AT_CHECK([[grep 'java.awt.Color' YYParser.java]], [0], [ignore]) +AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Position']], [1], [ignore]) +AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Location']], [1], [ignore]) + +AT_CLEANUP