X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/6d55954743c7243ba46680f368c76ee70b1112f8..ee616bdc62db15f2f9bdad42bdf8699d9c374c8c:/tests/java.at diff --git a/tests/java.at b/tests/java.at index f822ec6e..3f729260 100644 --- a/tests/java.at +++ b/tests/java.at @@ -1,6 +1,6 @@ # Java tests for simple calculator. -*- Autotest -*- -# Copyright (C) 2007-2012 Free Software Foundation, Inc. +# Copyright (C) 2007-2013 Free Software Foundation, Inc. # 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 @@ -24,9 +24,9 @@ AT_BANNER([[Java Calculator.]]) # _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 +# ---------------------------------------------------- +# 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 # AT_DATA_JAVA_CALC_Y does. m4_define([_AT_DATA_JAVA_CALC_Y], @@ -54,11 +54,11 @@ AT_DATA([Calc.y], %token NUM "number" %type exp -%nonassoc '=' /* comparison */ +%nonassoc '=' /* comparison */ %left '-' '+' %left '*' '/' -%left NEG /* negation--unary minus */ -%right '^' /* exponentiation */ +%precedence NEG /* negation--unary minus */ +%right '^' /* exponentiation */ /* Grammar follows */ %% @@ -137,7 +137,7 @@ AT_LOCATION_IF([[ ]AT_LOCATION_IF([[yypos = new Position (yypos.lineno (), yypos.token () + 1);]])[ if (ttype == st.TT_EOF) - return Calc.EOF; + return EOF; else if (ttype == st.TT_EOL) { @@ -148,7 +148,7 @@ AT_LOCATION_IF([[ else if (ttype == st.TT_WORD) { yylval = new Integer (st.sval); - return Calc.NUM; + return NUM; } else @@ -206,7 +206,7 @@ AT_BISON_OPTION_POPDEFS # AT_DATA_CALC_Y([BISON-OPTIONS]) # ------------------------------- -# Produce `calc.y'. +# Produce 'calc.y'. m4_define([AT_DATA_JAVA_CALC_Y], [_AT_DATA_JAVA_CALC_Y($[1], $[2], $[3], [$1]) ]) @@ -215,7 +215,7 @@ m4_define([AT_DATA_JAVA_CALC_Y], # _AT_CHECK_JAVA_CALC_ERROR(BISON-OPTIONS, INPUT, # [VERBOSE-AND-LOCATED-ERROR-MESSAGE]) # -------------------------------------------------------------- -# Run `calc' on INPUT, and expect a `syntax error' message. +# Run 'calc' on INPUT, and expect a 'syntax error' message. # # If INPUT starts with a slash, it is used as absolute input file name, # otherwise as contents. @@ -240,7 +240,7 @@ AT_DATA([[expout]], AT_YYERROR_SEES_LOC_IF([], [[sed 's/^[-0-9.]*: //' expout >at-expout mv at-expout expout]]) -# 3. If error-verbose is not used, strip the`, unexpected....' part. +# 3. If error-verbose is not used, strip the', unexpected....' part. m4_bmatch([$1], [%error-verbose], [], [[sed 's/syntax error, .*$/syntax error/' expout >at-expout mv at-expout expout]]) @@ -249,8 +249,8 @@ AT_CHECK([cat stderr], 0, [expout]) ]) # _AT_CHECK_JAVA_CALC([BISON-DIRECTIVES], [BISON-CODE]) -# ----------------------------------------------------------------------- -# Start a testing chunk which compiles `calc' grammar with +# ----------------------------------------------------- +# Start a testing chunk which compiles 'calc' grammar with # BISON-DIRECTIVES, and performs several tests over the parser. m4_define([_AT_CHECK_JAVA_CALC], [# We use integers to avoid dependencies upon the precision of doubles. @@ -310,7 +310,7 @@ _AT_CHECK_JAVA_CALC_ERROR([$1], [/dev/null], # - (* * *): nothing to pop, a lot to discard # - (1 + 2 * *): some to pop and discard # -# - test the action associated to `error' +# - test the action associated to 'error' # # - check the lookahead that triggers an error is not discarded # when we enter error recovery. Below, the lookahead causing the @@ -341,8 +341,8 @@ AT_CLEANUP # AT_CHECK_JAVA_CALC([BISON-DIRECTIVES]) -# -------------------------------------------------------- -# Start a testing chunk which compiles `calc' grammar with +# -------------------------------------- +# 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], @@ -394,9 +394,10 @@ AT_DATA([[YYParser.y]], [ %debug %error-verbose %token-table +%token END "end" $1 %% -start: "end" {$2}; +start: END {$2}; %% class m4_default([$3], [Position]) {} ]) @@ -407,7 +408,7 @@ AT_JAVA_COMPILE([[YYParser.java]]) # AT_CHECK_JAVA_MINIMAL_W_LEXER([1:DIRECTIVES], [2:LEX_THROWS], -# [3:YYLEX_ACTION], [4:LEXER_BODY], [5:PARSER_ACTION], [6:STYPE], +# [3:YYLEX_ACTION], [4:LEXER_BODY], [5:PARSER_ACTION], [6:VALUE_TYPE], # [7:POSITION_TYPE], [8:LOCATION_TYPE]) # --------------------------------------------------------------------- # Check that a mininal parser with DIRECTIVES and a "%code lexer". @@ -443,14 +444,14 @@ m4_define([AT_CHECK_JAVA_MINIMAL_W_LEXER], # 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]) + [AT_CHECK([grep -c '^$1$' YYParser.java], [], [m4_default([$2], [1]) ]) ]) -# ----------------------------------- # -# Java parser class and package names # -# ----------------------------------- # +# ------------------------------------- # +# Java parser class and package names. # +# ------------------------------------- # AT_SETUP([Java parser class and package names]) @@ -460,6 +461,9 @@ 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.token.prefix {TOK_}]]) +AT_CHECK_JAVA_GREP([[.*TOK_END.*]]) + AT_CHECK_JAVA_MINIMAL([[%define parser_class_name "ParserClassName"]]) AT_CHECK_JAVA_GREP([[class ParserClassName]]) @@ -469,9 +473,9 @@ AT_CHECK_JAVA_GREP([[package user_java_package;]]) AT_CLEANUP -# --------------------------- # -# Java parser class modifiers # -# --------------------------- # +# ----------------------------- # +# Java parser class modifiers. # +# ----------------------------- # AT_SETUP([Java parser class modifiers]) @@ -524,6 +528,12 @@ AT_CHECK_JAVA_MINIMAL([[ %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 @@ -554,54 +564,54 @@ AT_CLEANUP AT_SETUP([Java %parse-param and %lex-param]) AT_CHECK_JAVA_MINIMAL([]) -AT_CHECK_JAVA_GREP([[ *public YYParser (Lexer yylexer) {]]) +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_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_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_GREP([[ *public YYParser () *]]) +AT_CHECK_JAVA_GREP([[ *protected YYParser (Lexer yylexer) *]]) AT_CHECK_JAVA_MINIMAL_W_LEXER([[%parse-param {int parse_param1}]], - [], [[return EOF;]]) + [], [[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_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;]]) + [], [[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_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) {]]) + [], [[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) {]]) + [], [[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([[ @@ -609,14 +619,14 @@ AT_CHECK_JAVA_MINIMAL_W_LEXER([[ %parse-param {long parse_param2} %lex-param {char lex_param1} %lex-param {short lex_param2}]], - [], [[return EOF;]], [[YYLexer (char lex_param1, 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([[ *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_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 @@ -627,74 +637,74 @@ AT_CLEANUP AT_SETUP([Java throws specifications]) -# %define throws - 0 1 2 -# %define lex-throws - 0 1 2 -# %code lexer 0 1 +# %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"]])]) + -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]])]) + -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();]])]) + -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"]])]) + -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]])]) + -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]])]) + -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_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();}]])]) + -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();]])]) + -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_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_CHECK_JAVA_MINIMAL_W_LEXER([ AT_JT_throws_define AT_JT_lex_throws_define AT_JT_initial_action], @@ -710,27 +720,49 @@ AT_CHECK_JAVA_GREP([[ *public boolean parse ()]AT_JT_parse_throws[ *]]) AT_CLEANUP -# --------------------------------------------- # -# Java stype, position_class and location_class # -# --------------------------------------------- # +# ------------------------------------- # +# 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 value, position, and location types. # +# ------------------------------------------ # -AT_SETUP([Java stype, position_class and location_class]) +AT_SETUP([Java value, position, and location types]) AT_CHECK_JAVA_MINIMAL([[ -%define stype "java.awt.Color" +%define api.value.type "java.awt.Color" %type start; -%define location_type "MyLoc" -%define position_type "MyPos" +%define api.location.type "MyLoc" +%define api.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" +%define api.value.type "java.awt.Color" %type start; -%define location_type "MyLoc" -%define position_type "MyPos" +%define api.location.type "MyLoc" +%define api.position.type "MyPos" %code { class MyPos {} }]], [], [[return EOF;]], [], [[$$ = $1;]], [[java.awt.Color]], [[MyPos]], [[MyLoc]])