X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/da730230ce159265f4380daa456e3e3c5f9422f4..fc28638e1c4ef0c41ad52b832b547305ea8c1784:/tests/java.at diff --git a/tests/java.at b/tests/java.at index 0dbaebc7..db3f5000 100644 --- a/tests/java.at +++ b/tests/java.at @@ -1,6 +1,6 @@ # Java tests for simple calculator. -*- Autotest -*- -# Copyright (C) 2007 Free Software Foundation, Inc. +# Copyright (C) 2007-2012 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 @@ -32,6 +32,7 @@ AT_BANNER([[Java Calculator.]]) m4_define([_AT_DATA_JAVA_CALC_Y], [m4_if([$1$2$3], $[1]$[2]$[3], [], [m4_fatal([$0: Invalid arguments: $@])])dnl +AT_BISON_OPTION_PUSHDEFS([%language "Java" $4]) AT_DATA([Calc.y], [[/* Infix notation calculator--calc */ %language "Java" @@ -77,7 +78,7 @@ exp: | exp '=' exp { if ($1.intValue () != $3.intValue ()) - yyerror ("calc: error: " + $1 + " != " + $3); + yyerror (]AT_LOCATION_IF([[@$,]])[ "calc: error: " + $1 + " != " + $3); } | exp '+' exp { $$ = new Integer ($1.intValue () + $3.intValue ()); } | exp '-' exp { $$ = new Integer ($1.intValue () - $3.intValue ()); } @@ -113,30 +114,17 @@ class CalcLexer implements Calc.Lexer { } AT_LOCATION_IF([[ - Position yystartpos; - Position yyendpos = new Position (1); + Position yypos = new Position (1, 0); public Position getStartPos() { - return yystartpos; + return yypos; } 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); + return yypos; } ]])[ + ]AT_YYERROR_DEFINE[ Integer yylval; @@ -146,13 +134,14 @@ AT_LOCATION_IF([[ public int yylex () throws IOException { int ttype = st.nextToken (); - ]AT_LOCATION_IF([[yystartpos = yyendpos;]])[ + ]AT_LOCATION_IF([[yypos = new Position (yypos.lineno (), + yypos.token () + 1);]])[ if (ttype == st.TT_EOF) return Calc.EOF; else if (ttype == st.TT_EOL) { - ]AT_LOCATION_IF([[yyendpos = new Position (yyendpos.lineno () + 1);]])[ + ]AT_LOCATION_IF([[yypos = new Position (yypos.lineno () + 1, 0);]])[ return (int) '\n'; } @@ -175,71 +164,57 @@ AT_LOCATION_IF([[ [ class Position { public int line; + public int token; public Position () { line = 0; + token = 0; } - public Position (int l) + public Position (int l, int t) { line = l; - } - - public long getHashCode () - { - return line; + token = t; } public boolean equals (Position l) { - return l.line == line; + return l.line == line && l.token == token; } public String toString () { - return Integer.toString (line); + return Integer.toString (line) + "." + Integer.toString(token); } public int lineno () { return line; } + + public int token () + { + return token; + } } ]]) +AT_BISON_OPTION_POPDEFS ])# _AT_DATA_JAVA_CALC_Y # 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]) ]) - -# AT_JAVA_COMPILE(SOURCE) -# ----------------------- -# 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 -test -n "$CONF_JAVAC" || exit 77]) -AT_CHECK([$SHELL ../../../javacomp.sh $1], - 0, [ignore], [ignore])]) - - -# AT_JAVA_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE]) -# ----------------------------------------------------------------- -m4_define([AT_JAVA_PARSER_CHECK], -[AT_CHECK([$5 $SHELL ../../../javaexec.sh $1], [$2], [$3], [$4])]) - - # _AT_CHECK_JAVA_CALC_ERROR(BISON-OPTIONS, INPUT, # [VERBOSE-AND-LOCATED-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, @@ -312,19 +287,19 @@ AT_JAVA_PARSER_CHECK([Calc < input], 0, [], [stderr]) # Some syntax errors. _AT_CHECK_JAVA_CALC_ERROR([$1], [0 0], - [1: syntax error, unexpected number]) + [1.2: syntax error, unexpected number]) _AT_CHECK_JAVA_CALC_ERROR([$1], [1//2], - [1: syntax error, unexpected '/', expecting number or '-' or '(' or '!']) + [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!']) _AT_CHECK_JAVA_CALC_ERROR([$1], [error], - [1: syntax error, unexpected $undefined]) + [1.1: syntax error, unexpected $undefined]) _AT_CHECK_JAVA_CALC_ERROR([$1], [1 = 2 = 3], - [1: syntax error, unexpected '=']) + [1.4: syntax error, unexpected '=']) _AT_CHECK_JAVA_CALC_ERROR([$1], [ +1], - [2: syntax error, unexpected '+']) + [2.1: syntax error, unexpected '+']) # Exercise error messages with EOF: work on an empty file. _AT_CHECK_JAVA_CALC_ERROR([$1], [/dev/null], - [1: syntax error, unexpected end of input]) + [1.1: syntax error, unexpected end of input]) # Exercise the error token: without it, we die at the first error, # hence be sure to @@ -342,23 +317,23 @@ _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 '!' -1: syntax error, unexpected '*', expecting number or '-' or '(' or '!' -1: syntax error, unexpected '*', expecting number or '-' or '(' or '!' -calc: error: 4444 != 1]) +[1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!' +1.11: syntax error, unexpected ')', expecting number or '-' or '(' or '!' +1.14: syntax error, unexpected '*', expecting number or '-' or '(' or '!' +1.24: syntax error, unexpected '*', expecting number or '-' or '(' or '!' +1.1-1.27: calc: error: 4444 != 1]) # The same, but this time exercising explicitly triggered syntax errors. # POSIX says the lookahead causing the error should not be discarded. _AT_CHECK_JAVA_CALC_ERROR([$1], [(!) + (0 0) = 1], -[1: syntax error, unexpected number -calc: error: 2222 != 1]) +[1.7: syntax error, unexpected number +1.1-1.10: calc: error: 2222 != 1]) _AT_CHECK_JAVA_CALC_ERROR([$1], [(- *) + (0 0) = 1], -[1: syntax error, unexpected '*', expecting number or '-' or '(' or '!' -1: syntax error, unexpected number -calc: error: 2222 != 1]) +[1.3: syntax error, unexpected '*', expecting number or '-' or '(' or '!' +1.8: syntax error, unexpected number +1.1-1.11: calc: error: 2222 != 1]) AT_BISON_OPTION_POPDEFS AT_CLEANUP @@ -397,3 +372,436 @@ AT_CHECK_JAVA_CALC([%lex-param { InputStream is } ], [[ new Calc (System.in).parse (); } ]]) + + + +# -----------------# +# Java Directives. # +# -----------------# + +AT_BANNER([Java Parameters.]) + + +# 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 +$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_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) + { + System.err.println (loc + ": " + s); + } + + public int yylex ()$2 + { + $3 + } + + $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 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]]) + +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 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 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" +%type start; +%define api.location.type "MyLoc" +%define api.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 + + +# ----------------------------------------------- # +# Java syntax error handling without error token. # +# ----------------------------------------------- # + +AT_SETUP([Java syntax error handling without error token]) + +AT_DATA([[YYParser.y]], [[%language "Java" + +%lex-param { String s } + +%code imports { + import java.io.IOException; +} + +%code lexer { + String Input; + int Position; + + public YYLexer (String s) + { + Input = s; + Position = 0; + } + + public void yyerror (String s) + { + System.err.println (s); + } + + public Object getLVal () + { + return null; + } + + public int yylex () throws IOException + { + if (Position >= Input.length ()) + return EOF; + else + return Input.charAt (Position++); + } +} + +%code { + public static void main (String args []) throws IOException + { + YYParser p = new YYParser (args [0]); + p.parse (); + } +} +%% +input: + 'a' 'a' +; +]]) +AT_BISON_CHECK([[YYParser.y]]) +AT_JAVA_COMPILE([[YYParser.java]]) +AT_JAVA_PARSER_CHECK([[YYParser aa]], [[0]], [[]], [[]]) +AT_JAVA_PARSER_CHECK([[YYParser ab]], [[0]], [[]], [[syntax error +]]) +AT_JAVA_PARSER_CHECK([[YYParser ba]], [[0]], [[]], [[syntax error +]]) + +AT_CLEANUP