ca5d180f194e4f44945785e99c9844c9832b23bf
[bison.git] / tests / java.at
1 # Java tests for simple calculator. -*- Autotest -*-
2
3 # Copyright (C) 2007 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 2, or (at your option)
8 # 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, write to the Free Software
17 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 # 02110-1301, USA.
19
20 AT_BANNER([[Java Calculator.]])
21
22
23 # ------------------------- #
24 # Helping Autotest macros. #
25 # ------------------------- #
26
27
28 # _AT_DATA_JAVA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
29 # ----------------------------------------------------------------------
30 # Produce `calc.y'. Don't call this macro directly, because it contains
31 # some occurrences of `$1' etc. which will be interpreted by m4. So
32 # you should call it with $1, $2, and $3 as arguments, which is what
33 # AT_DATA_JAVA_CALC_Y does.
34 m4_define([_AT_DATA_JAVA_CALC_Y],
35 [m4_if([$1$2$3], $[1]$[2]$[3], [],
36 [m4_fatal([$0: Invalid arguments: $@])])dnl
37 AT_DATA([Calc.y],
38 [[/* Infix notation calculator--calc */
39 %language "Java"
40 %name-prefix "Calc"
41 %define parser_class_name "Calc"
42 %define public
43
44 ]$4[
45
46 %code imports {
47 import java.io.StreamTokenizer;
48 import java.io.InputStream;
49 import java.io.InputStreamReader;
50 import java.io.Reader;
51 import java.io.IOException;
52 }
53
54 /* Bison Declarations */
55 %token <Integer> NUM "number"
56 %type <Integer> exp
57
58 %nonassoc '=' /* comparison */
59 %left '-' '+'
60 %left '*' '/'
61 %left NEG /* negation--unary minus */
62 %right '^' /* exponentiation */
63
64 /* Grammar follows */
65 %%
66 input:
67 line
68 | input line
69 ;
70
71 line:
72 '\n'
73 | exp '\n'
74 | error '\n'
75 ;
76
77 exp:
78 NUM { $$ = $1; }
79 | exp '=' exp
80 {
81 if ($1.intValue () != $3.intValue ())
82 yyerror ("calc: error: " + $1 + " != " + $3);
83 }
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 '/' exp { $$ = new Integer ($1.intValue () / $3.intValue ()); }
88 | '-' exp %prec NEG { $$ = new Integer (-$2.intValue ()); }
89 | exp '^' exp { $$ = new Integer ((int)
90 Math.pow ($1.intValue (),
91 $3.intValue ())); }
92 | '(' exp ')' { $$ = $2; }
93 | '(' error ')' { $$ = new Integer (1111); }
94 | '!' { $$ = new Integer (0); return YYERROR; }
95 | '-' error { $$ = new Integer (0); return YYERROR; }
96 ;
97
98 ]AT_LEXPARAM_IF([[
99 %code lexer {
100 ]],
101 [[
102 %%
103 class CalcLexer implements Calc.Lexer {
104 ]])[
105 StreamTokenizer st;
106
107 public ]AT_LEXPARAM_IF([[YYLexer]], [[CalcLexer]]) (InputStream is)
108 {
109 st = new StreamTokenizer (new InputStreamReader (is));
110 st.resetSyntax ();
111 st.eolIsSignificant (true);
112 st.whitespaceChars (9, 9);
113 st.whitespaceChars (32, 32);
114 st.wordChars (48, 57);
115 }
116
117 AT_LOCATION_IF([[
118 Position yystartpos;
119 Position yyendpos = new Position (1);
120
121 public Position getStartPos() {
122 return yystartpos;
123 }
124
125 public Position getEndPos() {
126 return yyendpos;
127 }
128
129 public void yyerror (Calc.Location l, String s)
130 {
131 if (l == null)
132 System.err.println (s);
133 else
134 System.err.println (l.begin + ": " + s);
135 }
136 ]], [[
137 public void yyerror (String s)
138 {
139 System.err.println (s);
140 }
141 ]])[
142
143 Integer yylval;
144
145 public Object getLVal() {
146 return yylval;
147 }
148
149 public int yylex () throws IOException {
150 int ttype = st.nextToken ();
151 ]AT_LOCATION_IF([[yystartpos = yyendpos;]])[
152 if (ttype == st.TT_EOF)
153 return Calc.EOF;
154
155 else if (ttype == st.TT_EOL)
156 {
157 ]AT_LOCATION_IF([[yyendpos = new Position (yyendpos.lineno () + 1);]])[
158 return (int) '\n';
159 }
160
161 else if (ttype == st.TT_WORD)
162 {
163 yylval = new Integer (st.sval);
164 return Calc.NUM;
165 }
166
167 else
168 return st.ttype;
169 }
170
171
172 ]AT_LEXPARAM_IF([[
173 };
174 %%]], [[
175 }]])
176
177 [
178 class Position {
179 public int line;
180
181 public Position ()
182 {
183 line = 0;
184 }
185
186 public Position (int l)
187 {
188 line = l;
189 }
190
191 public long getHashCode ()
192 {
193 return line;
194 }
195
196 public boolean equals (Position l)
197 {
198 return l.line == line;
199 }
200
201 public String toString ()
202 {
203 return Integer.toString (line);
204 }
205
206 public int lineno ()
207 {
208 return line;
209 }
210 }
211
212 ]])
213 ])# _AT_DATA_JAVA_CALC_Y
214
215
216 # AT_DATA_CALC_Y([BISON-OPTIONS])
217 # -------------------------------------------------
218 # Produce `calc.y'.
219 m4_define([AT_DATA_JAVA_CALC_Y],
220 [_AT_DATA_JAVA_CALC_Y($[1], $[2], $[3], [$1])
221 ])
222
223
224
225 # AT_JAVA_COMPILE(SOURCE)
226 # -----------------------
227 # Compile SOURCES into Java class files. Skip the test if java or javac is
228 # not installed.
229 m4_define([AT_JAVA_COMPILE],
230 [AT_CHECK([test -n "$CONF_JAVA" || exit 77
231 test -n "$CONF_JAVAC" || exit 77])
232 AT_CHECK([$SHELL ../../../javacomp.sh $1],
233 0, [ignore], [ignore])])
234
235
236 # AT_JAVA_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
237 # -----------------------------------------------------------------
238 m4_define([AT_JAVA_PARSER_CHECK],
239 [AT_CHECK([$5 $SHELL ../../../javaexec.sh $1], [$2], [$3], [$4])])
240
241
242 # _AT_CHECK_JAVA_CALC_ERROR(BISON-OPTIONS, INPUT,
243 # [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
244 # ---------------------------------------------------------
245 # Run `calc' on INPUT, and expect a `syntax error' message.
246 #
247 # If INPUT starts with a slash, it is used as absolute input file name,
248 # otherwise as contents.
249 #
250 # The VERBOSE-AND-LOCATED-ERROR-MESSAGE is stripped of locations
251 # and expected tokens if necessary, and compared with the output.
252 m4_define([_AT_CHECK_JAVA_CALC_ERROR],
253 [m4_bmatch([$2], [^/],
254 [AT_JAVA_PARSER_CHECK([Calc < $2], 0, [], [stderr])],
255 [AT_DATA([[input]],
256 [[$2
257 ]])
258 AT_JAVA_PARSER_CHECK([Calc < input], 0, [], [stderr])])
259
260 # Normalize the observed and expected error messages, depending upon the
261 # options.
262 # 1. Create the reference error message.
263 AT_DATA([[expout]],
264 [$3
265 ])
266 # 2. If locations are not used, remove them.
267 AT_YYERROR_SEES_LOC_IF([],
268 [[sed 's/^[-0-9.]*: //' expout >at-expout
269 mv at-expout expout]])
270 # 3. If error-verbose is not used, strip the`, unexpected....' part.
271 m4_bmatch([$1], [%error-verbose], [],
272 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
273 mv at-expout expout]])
274 # 4. Check
275 AT_CHECK([cat stderr], 0, [expout])
276 ])
277
278 # _AT_CHECK_JAVA_CALC([BISON-DIRECTIVES], [BISON-CODE])
279 # -----------------------------------------------------------------------
280 # Start a testing chunk which compiles `calc' grammar with
281 # BISON-DIRECTIVES, and performs several tests over the parser.
282 m4_define([_AT_CHECK_JAVA_CALC],
283 [# We use integers to avoid dependencies upon the precision of doubles.
284 AT_SETUP([Calculator $1])
285
286 AT_BISON_OPTION_PUSHDEFS([$1])
287
288 AT_DATA_JAVA_CALC_Y([$1
289 %code {
290 $2
291 }])
292
293 AT_CHECK([bison -o Calc.java Calc.y])
294 AT_JAVA_COMPILE([Calc.java])
295
296 # Test the priorities.
297 AT_DATA([[input]],
298 [[1 + 2 * 3 = 7
299 1 + 2 * -3 = -5
300
301 -1^2 = -1
302 (-1)^2 = 1
303
304 ---1 = -1
305
306 1 - 2 - 3 = -4
307 1 - (2 - 3) = 2
308
309 2^2^3 = 256
310 (2^2)^3 = 64
311 ]])
312 AT_JAVA_PARSER_CHECK([Calc < input], 0, [], [stderr])
313
314
315 # Some syntax errors.
316 _AT_CHECK_JAVA_CALC_ERROR([$1], [0 0],
317 [1: syntax error, unexpected number])
318 _AT_CHECK_JAVA_CALC_ERROR([$1], [1//2],
319 [1: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
320 _AT_CHECK_JAVA_CALC_ERROR([$1], [error],
321 [1: syntax error, unexpected $undefined])
322 _AT_CHECK_JAVA_CALC_ERROR([$1], [1 = 2 = 3],
323 [1: syntax error, unexpected '='])
324 _AT_CHECK_JAVA_CALC_ERROR([$1], [
325 +1],
326 [2: syntax error, unexpected '+'])
327 # Exercise error messages with EOF: work on an empty file.
328 _AT_CHECK_JAVA_CALC_ERROR([$1], [/dev/null],
329 [1: syntax error, unexpected end of input])
330
331 # Exercise the error token: without it, we die at the first error,
332 # hence be sure to
333 #
334 # - have several errors which exercise different shift/discardings
335 # - (): nothing to pop, nothing to discard
336 # - (1 + 1 + 1 +): a lot to pop, nothing to discard
337 # - (* * *): nothing to pop, a lot to discard
338 # - (1 + 2 * *): some to pop and discard
339 #
340 # - test the action associated to `error'
341 #
342 # - check the lookahead that triggers an error is not discarded
343 # when we enter error recovery. Below, the lookahead causing the
344 # first error is ")", which is needed to recover from the error and
345 # produce the "0" that triggers the "0 != 1" error.
346 #
347 _AT_CHECK_JAVA_CALC_ERROR([$1],
348 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
349 [1: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
350 1: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
351 1: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
352 1: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
353 calc: error: 4444 != 1])
354
355 # The same, but this time exercising explicitly triggered syntax errors.
356 # POSIX says the lookahead causing the error should not be discarded.
357 _AT_CHECK_JAVA_CALC_ERROR([$1], [(!) + (0 0) = 1],
358 [1: syntax error, unexpected number
359 calc: error: 2222 != 1])
360 _AT_CHECK_JAVA_CALC_ERROR([$1], [(- *) + (0 0) = 1],
361 [1: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
362 1: syntax error, unexpected number
363 calc: error: 2222 != 1])
364 AT_BISON_OPTION_POPDEFS
365
366 AT_CLEANUP
367 ])# _AT_CHECK_JAVA_CALC
368
369
370 # AT_CHECK_JAVA_CALC([BISON-DIRECTIVES])
371 # --------------------------------------------------------
372 # Start a testing chunk which compiles `calc' grammar with
373 # BISON-DIRECTIVES, and performs several tests over the parser.
374 # Run the test with and without %error-verbose.
375 m4_define([AT_CHECK_JAVA_CALC],
376 [_AT_CHECK_JAVA_CALC([$1], [$2])
377 _AT_CHECK_JAVA_CALC([%error-verbose $1], [$2])
378 _AT_CHECK_JAVA_CALC([%locations $1], [$2])
379 _AT_CHECK_JAVA_CALC([%error-verbose %locations $1], [$2])
380 ])# AT_CHECK_JAVA_CALC
381
382
383 # ------------------------ #
384 # Simple LALR Calculator. #
385 # ------------------------ #
386
387 AT_CHECK_JAVA_CALC([], [[
388 public static void main (String args[]) throws IOException
389 {
390 CalcLexer l = new CalcLexer (System.in);
391 Calc p = new Calc (l);
392 p.parse ();
393 }
394 ]])
395
396 AT_CHECK_JAVA_CALC([%lex-param { InputStream is } ], [[
397 public static void main (String args[]) throws IOException
398 {
399 new Calc (System.in).parse ();
400 }
401 ]])