]>
Commit | Line | Data |
---|---|---|
7685e2f7 AR |
1 | # Named references test. -*- Autotest -*- |
2 | ||
6e30ede8 | 3 | # Copyright (C) 2009, 2010 Free Software Foundation, Inc. |
7685e2f7 AR |
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 3 of the License, or | |
8 | # (at your option) 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, see <http://www.gnu.org/licenses/>. | |
17 | ||
18 | AT_BANNER([[Named references tests.]]) | |
19 | ||
20 | AT_SETUP([Tutorial calculator]) | |
21 | ||
22 | AT_DATA_GRAMMAR([test.y], | |
23 | [[ | |
24 | %{ | |
25 | #include <stdio.h> | |
26 | #include <stdlib.h> | |
27 | #include <string.h> | |
28 | #include <ctype.h> | |
29 | typedef int semantic_value; | |
30 | FILE *input; | |
31 | static semantic_value global_result = 0; | |
32 | static int global_count = 0; | |
33 | static int power (int base, int exponent); | |
34 | static void yyerror (const char *s); | |
35 | int yylex (void); | |
36 | %} | |
37 | ||
38 | %union | |
39 | { | |
40 | semantic_value ival; | |
41 | }; | |
42 | ||
43 | %token CALC_EOF 0 "end of input" | |
44 | %token <ival> NUM "number" | |
45 | %type <ival> exp | |
46 | ||
47 | %nonassoc '=' /* comparison */ | |
48 | %left '-' '+' | |
49 | %left '*' '/' | |
50 | %left NEG /* negation--unary minus */ | |
51 | %right '^' /* exponentiation */ | |
52 | ||
53 | %% | |
54 | input: | |
55 | line | |
56 | | input line { } | |
57 | ; | |
58 | ||
59 | line: | |
60 | '\n' | |
61 | | exp '\n' { } | |
62 | ; | |
63 | ||
64 | exp: | |
65 | NUM { $$ = $NUM; } | |
66 | | exp[l] '=' exp[r] | |
67 | { | |
68 | if ($l != $r) | |
69 | fprintf (stderr, "calc: error: %d != %d\n", $l, $r); | |
70 | $$ = $l; | |
71 | } | |
72 | | exp[x] '+' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>l + $r; } | |
73 | | exp[l] '-' exp[r] { $$ = $l - $r; } | |
74 | | exp[l] '*' exp[r] { $$ = $l * $r; } | |
75 | | exp[l] '/' exp[r] { $$ = $l / $r; } | |
76 | | '-' exp %prec NEG { $$ = -$2; } | |
77 | | exp[l] '^' exp[r] { $$ = power ($l, $r); } | |
78 | | '(' exp[e] ')' { $$ = $e; } | |
79 | | '(' error ')' { $$ = 1111; yyerrok; } | |
80 | | '!' { $$ = 0; YYERROR; } | |
81 | | '-' error { $$ = 0; YYERROR; } | |
82 | ; | |
83 | %% | |
84 | ||
85 | static void yyerror (const char *s) | |
86 | { | |
87 | fprintf (stderr, "%s\n", s); | |
88 | } | |
89 | ||
90 | static int get_char (void) | |
91 | { | |
92 | int res = getc (input); | |
93 | return res; | |
94 | } | |
95 | ||
96 | static void unget_char (int c) | |
97 | { | |
98 | ungetc (c, input); | |
99 | } | |
100 | ||
101 | static int read_signed_integer (void) | |
102 | { | |
103 | int c = get_char (); | |
104 | int sign = 1; | |
105 | int n = 0; | |
106 | if (c == '-') | |
107 | { | |
108 | c = get_char (); | |
109 | sign = -1; | |
110 | } | |
111 | while (isdigit (c)) | |
112 | { | |
113 | n = 10 * n + (c - '0'); | |
114 | c = get_char (); | |
115 | } | |
116 | unget_char ( c); | |
117 | return sign * n; | |
118 | } | |
119 | ||
120 | int yylex (void) | |
121 | { | |
122 | int c; | |
123 | /* Skip white space. */ | |
124 | while ((c = get_char ()) == ' ' || c == '\t') {} | |
125 | ||
126 | /* process numbers */ | |
127 | if (c == '.' || isdigit (c)) | |
128 | { | |
129 | unget_char ( c); | |
130 | (yylval).ival = read_signed_integer (); | |
131 | return NUM; | |
132 | } | |
133 | ||
134 | /* Return end-of-file. */ | |
135 | if (c == EOF) | |
136 | return CALC_EOF; | |
137 | ||
138 | /* Return single chars. */ | |
139 | return c; | |
140 | } | |
141 | ||
142 | static int power (int base, int exponent) | |
143 | { | |
144 | int res = 1; | |
145 | if (exponent < 0) | |
146 | exit (3); | |
147 | for (/* Niente */; exponent; --exponent) | |
148 | res *= base; | |
149 | return res; | |
150 | } | |
151 | ||
152 | int main (int argc, const char **argv) | |
153 | { | |
154 | semantic_value result = 0; | |
155 | int count = 0; | |
156 | int status; | |
157 | if (argc == 2) | |
158 | input = fopen (argv[1], "r"); | |
159 | else | |
160 | input = stdin; | |
161 | if (!input) | |
162 | { | |
163 | perror (argv[1]); | |
164 | return 3; | |
165 | } | |
166 | status = yyparse (); | |
167 | fclose (input); | |
168 | if (global_result != result) | |
169 | abort (); | |
170 | if (global_count != count) | |
171 | abort (); | |
172 | return status; | |
173 | } | |
174 | ]]) | |
175 | ||
176 | AT_DATA([input.txt], | |
177 | [[ | |
178 | 1 + 2 * 3 = 7 | |
179 | 1 + 2 * -3 = -5 | |
180 | -1^2 = -1 | |
181 | (-1)^2 = 1 | |
182 | ---1 = -1 | |
183 | 1 - 2 - 3 = -4 | |
184 | 1 - (2 - 3) = 2 | |
185 | 2^2^3 = 256 | |
186 | (2^2)^3 = 64 | |
187 | ]]) | |
188 | ||
189 | AT_BISON_CHECK([-o test.c test.y]) | |
190 | AT_COMPILE([[test]]) | |
191 | AT_PARSER_CHECK([./test input.txt], 0, [], [stderr]) | |
192 | AT_CLEANUP | |
193 | ||
194 | ||
195 | ||
196 | ####################################################################### | |
197 | ||
198 | ||
199 | AT_SETUP([Undefined and ambiguous references]) | |
200 | ||
201 | AT_DATA_GRAMMAR([test.y], | |
202 | [[ | |
203 | %{ | |
204 | static int power (int base, int exponent); | |
205 | static void yyerror (const char *s); | |
206 | int yylex (void); | |
207 | %} | |
208 | ||
209 | %union | |
210 | { | |
211 | int ival; | |
212 | }; | |
213 | ||
214 | %token CALC_EOF 0 "end of input" | |
215 | %token <ival> NUM "number" | |
216 | %type <ival> exp | |
217 | ||
218 | %nonassoc '=' /* comparison */ | |
219 | %left '-' '+' | |
220 | %left '*' '/' | |
221 | %left NEG /* negation--unary minus */ | |
222 | %right '^' /* exponentiation */ | |
223 | ||
224 | %% | |
225 | input: | |
226 | line | |
227 | | input line { } | |
228 | ; | |
229 | ||
230 | line: | |
231 | '\n' | |
232 | | exp '\n' { } | |
233 | ; | |
234 | ||
235 | exp: | |
236 | NUM { $$ = $NUM; } | |
237 | | exp[l] '=' exp[r] | |
238 | { | |
239 | if ($l != $r) | |
240 | fprintf (stderr, "calc: error: %d != %d\n", $l, $r); | |
241 | $$ = $l; | |
242 | } | |
243 | | exp[x] '+' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>lo9 + $r; } | |
244 | | exp[x] '-' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>exp - $r; } | |
245 | | exp[x] '*' { $<ival>$ = $x; } [l] exp[r] { $$ = $l * $r; } | |
246 | | exp[l] '/' exp[r] { $$ = $l / $r; } | |
247 | | '-' exp %prec NEG { $$ = -$2; } | |
248 | | exp[l] '^' exp[r] { $$ = power ($l, $r12); } | |
249 | | '(' exp ')' { $$ = $expo; } | |
250 | | '(' error ')' { $$ = 1111; yyerrok; } | |
251 | | '!' { $$ = 0; YYERROR; } | |
252 | | '-' error { $$ = 0; YYERROR; } | |
253 | ; | |
254 | %% | |
255 | ]]) | |
256 | ||
257 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
4c56b131 | 258 | [[test.y:50.51-60: invalid reference: `$<ival>lo9' |
348f5608 | 259 | test.y:50.3-68: symbol not found in production: lo9 |
1a323c2f | 260 | test.y:51.51-60: warning: misleading reference: `$<ival>exp' |
348f5608 AR |
261 | test.y:42.1-3: warning: refers to: $exp at $$ |
262 | test.y:51.7: warning: possibly meant: $x, hiding $exp at $1 | |
263 | test.y:51.41: warning: possibly meant: $r, hiding $exp at $4 | |
7685e2f7 | 264 | test.y:52.51-52: $l of `exp' has no declared type |
4c56b131 | 265 | test.y:55.46-49: invalid reference: `$r12' |
348f5608 | 266 | test.y:55.3-53: symbol not found in production: r12 |
4c56b131 | 267 | test.y:56.29-33: invalid reference: `$expo' |
348f5608 | 268 | test.y:56.3-46: symbol not found in production: expo |
7685e2f7 AR |
269 | ]]) |
270 | AT_CLEANUP | |
271 | ||
272 | ####################################################################### | |
273 | ||
274 | AT_SETUP([Misleading references]) | |
275 | AT_DATA_GRAMMAR([test.y], | |
276 | [[ | |
277 | %% | |
278 | start: foo foo.bar { $foo.bar; } | |
279 | foo: '1' | |
280 | foo.bar: '2' | |
281 | ]]) | |
1a323c2f AR |
282 | AT_BISON_CHECK([-o test.c test.y], 0, [], |
283 | [[test.y:11.22-29: warning: misleading reference: `$foo.bar' | |
348f5608 AR |
284 | test.y:11.8-10: warning: refers to: $foo at $1 |
285 | test.y:11.12-18: warning: possibly meant: $[foo.bar] at $2 | |
7685e2f7 AR |
286 | ]]) |
287 | AT_CLEANUP | |
288 | ||
289 | ####################################################################### | |
290 | ||
291 | AT_SETUP([Many kinds of errors]) | |
292 | AT_DATA_GRAMMAR([test.y], | |
293 | [[ | |
294 | %token IDENT | |
295 | %token NUMBER | |
296 | %token ASSIGNOP | |
297 | %token IF | |
298 | %token IF1 | |
299 | %token THEN | |
300 | %token ELSE | |
301 | %token FI | |
302 | %token WHILE | |
303 | %token DO | |
304 | %token OD | |
305 | %start program | |
306 | %% | |
307 | if_stmt1: IF expr[cond] THEN stmt[then] ELSE stmt.list[else] FI | |
308 | { $if_stmt1 = new IfStmt($cond1, $then.f1, $else); }; | |
309 | if_stmt2: IF expr[cond] THEN stmt[then] FI | |
310 | { $if_stmt2 = new IfStmt($cond, $stmt.field, 0); }; | |
311 | if_stmt3: IF expr[cond] THEN stmt.list FI | |
312 | { $if_stmt3 = new IfStmt($cond, $stmt.list, 0); }; | |
313 | if_stmt4: IF expr[cond] THEN stmt[xyz] ELSE stmt[xyz] FI | |
314 | { $if_stmt4 = new IfStmt($cond, $xyz, $cond); }; | |
315 | if_stmt5: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
316 | { $if_stmt5 = new IfStmt($cond, $stmt.list, $else); }; | |
317 | if_stmt6: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
318 | { $if_stmt6 = new IfStmt($cond, $stmt.list.field, $else); }; | |
319 | if_stmt7: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
320 | { $if_stmt7 = new IfStmt($cond, $[stmt.list].field, $else); }; | |
321 | if_stmt8: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI | |
322 | { $if_stmt8 = new IfStmt($cond, $then.1, $else); }; | |
323 | if_stmt9: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI | |
324 | { $if_stmt9 = new IfStmt($cond, $then.1.field, $else); }; | |
325 | if_stmt10: IF expr[cond] THEN stmt[stmt.x] FI | |
326 | { $if_stmt10 = new IfStmt($cond, $stmt.x, 0); }; | |
327 | if-stmt-a: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
328 | { $if-stmt-a = new IfStmt($cond, $then, $else); }; | |
329 | if-stmt-b: IF expr[cond] THEN if-stmt-a[then-a] ELSE stmt.list[else] FI | |
330 | { $[if-stmt-b] = new IfStmt($cond, $then-a.f, $else); }; | |
331 | program: stmt.list; | |
332 | stmt.list: stmt ';' stmt.list { $3->insert($stmt); $$ = $3; } | |
333 | | stmt ';' { SL = new StmtList(); SL->insert($1); $$ = SL; } | |
334 | ; | |
335 | stmt: assign_stmt { $$ = $1; } | |
336 | | if_stmt { $$ = $1; } | |
337 | | if_stmt1 { $$ = $1; } | |
338 | | while_stmt { $$ = $1; } | |
339 | ; | |
340 | assign_stmt: IDENT ASSIGNOP expr | |
341 | { $$ = new AssignStmt(string($1),$3); }; | |
342 | if_stmt: IF expr[cond] THEN stmt.list FI | |
343 | { $if_stmt = new IfStmt($cond, $[stmt.list], 0); }; | |
344 | while_stmt[res]: WHILE expr DO stmt.list OD | |
345 | { $res = new WhileStmt($[expr], $[stmt.list]); }; | |
346 | expr: expr '+' term { $$ = new Plus($1,$3); } | |
347 | | expr '-' term { $$ = new Minus($1,$3); } | |
348 | | term { $$ = $1; } | |
349 | ; | |
350 | term: term '*' factor { $$ = new Times($1,$3); } | |
351 | | factor { $$ = $1; } | |
352 | ; | |
353 | factor: '(' expr ')' { $$ = $2; } | |
354 | | NUMBER { $$ = new Number($1); } | |
355 | | IDENT { $$ = new Ident(string($1)); } | |
356 | ; | |
357 | ]]) | |
358 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
4c56b131 | 359 | [[test.y:24.36-41: invalid reference: `$cond1' |
348f5608 | 360 | test.y:23.11-24.62: symbol not found in production: cond1 |
d5e8574b | 361 | test.y:26.43-53: invalid reference: `$stmt.field' |
348f5608 AR |
362 | test.y:25.11-26.60: symbol not found in production: stmt |
363 | test.y:25.35-38: possibly meant: $then.field, hiding $stmt.field at $4 | |
d5e8574b | 364 | test.y:28.43-52: invalid reference: `$stmt.list' |
348f5608 AR |
365 | test.y:27.11-28.59: symbol not found in production: stmt |
366 | test.y:27.30-38: possibly meant: $[stmt.list] at $4 | |
d5e8574b | 367 | test.y:30.43-46: ambiguous reference: `$xyz' |
348f5608 AR |
368 | test.y:29.35-37: refers to: $xyz at $4 |
369 | test.y:29.50-52: refers to: $xyz at $6 | |
d5e8574b | 370 | test.y:32.43-52: invalid reference: `$stmt.list' |
348f5608 AR |
371 | test.y:31.11-32.63: symbol not found in production: stmt |
372 | test.y:31.40-43: possibly meant: $then, hiding $[stmt.list] at $4 | |
373 | test.y:31.61-64: possibly meant: $else, hiding $[stmt.list] at $6 | |
d5e8574b | 374 | test.y:34.43-58: invalid reference: `$stmt.list.field' |
348f5608 AR |
375 | test.y:33.11-34.69: symbol not found in production: stmt |
376 | test.y:33.40-43: possibly meant: $then.field, hiding $[stmt.list].field at $4 | |
377 | test.y:33.61-64: possibly meant: $else.field, hiding $[stmt.list].field at $6 | |
d5e8574b | 378 | test.y:36.43-54: invalid reference: `$[stmt.list]' |
348f5608 AR |
379 | test.y:35.11-36.71: symbol not found in production: stmt.list |
380 | test.y:35.40-43: possibly meant: $then, hiding $[stmt.list] at $4 | |
381 | test.y:35.61-64: possibly meant: $else, hiding $[stmt.list] at $6 | |
d5e8574b | 382 | test.y:38.43-49: invalid reference: `$then.1' |
348f5608 AR |
383 | test.y:37.11-38.60: symbol not found in production: then |
384 | test.y:37.40-45: possibly meant: $[then.1] at $4 | |
d5e8574b | 385 | test.y:40.43-55: invalid reference: `$then.1.field' |
348f5608 AR |
386 | test.y:39.11-40.66: symbol not found in production: then |
387 | test.y:39.40-45: possibly meant: $[then.1].field at $4 | |
d5e8574b | 388 | test.y:42.44-50: invalid reference: `$stmt.x' |
348f5608 AR |
389 | test.y:41.12-42.57: symbol not found in production: stmt |
390 | test.y:41.36-41: possibly meant: $[stmt.x].x, hiding $stmt.x at $4 | |
391 | test.y:41.36-41: possibly meant: $[stmt.x] at $4 | |
d5e8574b | 392 | test.y:44.13-22: invalid reference: `$if-stmt-a' |
348f5608 AR |
393 | test.y:43.12-44.59: symbol not found in production: if |
394 | test.y:43.1-9: possibly meant: $[if-stmt-a] at $$ | |
d5e8574b | 395 | test.y:46.46-54: invalid reference: `$then-a.f' |
348f5608 AR |
396 | test.y:45.12-46.65: symbol not found in production: then |
397 | test.y:45.41-46: possibly meant: $[then-a].f at $4 | |
7685e2f7 AR |
398 | ]]) |
399 | AT_CLEANUP | |
400 | ||
401 | ####################################################################### | |
402 | ||
403 | AT_SETUP([Missing identifiers in brackets]) | |
404 | AT_DATA_GRAMMAR([test.y], | |
405 | [[ | |
406 | %% | |
407 | start: foo[] bar | |
408 | { s = $foo; } | |
409 | ]]) | |
410 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
d5e8574b | 411 | [[test.y:11.12: an identifier expected |
7685e2f7 AR |
412 | ]]) |
413 | AT_CLEANUP | |
414 | ||
415 | ####################################################################### | |
416 | ||
417 | AT_SETUP([Redundant words in brackets]) | |
418 | AT_DATA_GRAMMAR([test.y], | |
419 | [[ | |
420 | %% | |
421 | start: foo[ a d ] bar | |
422 | { s = $foo; } | |
423 | ]]) | |
424 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
d5e8574b | 425 | [[test.y:11.15: unexpected identifier in bracketed name: `d' |
7685e2f7 AR |
426 | ]]) |
427 | AT_CLEANUP | |
428 | ||
429 | ####################################################################### | |
430 | ||
431 | AT_SETUP([Comments in brackets]) | |
432 | AT_DATA_GRAMMAR([test.y], | |
433 | [[ | |
434 | %% | |
435 | start: foo[/* comment */] bar | |
436 | { s = $foo; } | |
437 | ]]) | |
438 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
d5e8574b | 439 | [[test.y:11.25: an identifier expected |
7685e2f7 AR |
440 | ]]) |
441 | AT_CLEANUP | |
442 | ||
443 | ####################################################################### | |
444 | ||
445 | AT_SETUP([Stray symbols in brackets]) | |
446 | AT_DATA_GRAMMAR([test.y], | |
447 | [[ | |
448 | %% | |
449 | start: foo[ /* aaa */ *&-+ ] bar | |
450 | { s = $foo; } | |
451 | ]]) | |
452 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
453 | [[test.y:11.23: invalid character in bracketed name: `*' | |
454 | test.y:11.24: invalid character in bracketed name: `&' | |
455 | test.y:11.26: invalid character in bracketed name: `+' | |
456 | ]]) | |
457 | AT_CLEANUP | |
458 | ||
459 | ####################################################################### | |
460 | ||
461 | AT_SETUP([Redundant words in LHS brackets]) | |
462 | AT_DATA_GRAMMAR([test.y], | |
463 | [[ | |
464 | %% | |
465 | start[a s]: foo | |
466 | ]]) | |
467 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
d5e8574b | 468 | [[test.y:11.9: unexpected identifier in bracketed name: `s' |
7685e2f7 AR |
469 | ]]) |
470 | AT_CLEANUP | |
14e568d7 AR |
471 | |
472 | ####################################################################### | |
473 | ||
474 | AT_SETUP([Unresolved references]) | |
475 | AT_DATA_GRAMMAR([test.y], | |
476 | [[ | |
477 | %% | |
478 | stat: | |
479 | sym_a sym_b | |
480 | { func($sym.field); } | |
481 | | | |
482 | sym_a sym_b | |
483 | { func($<aa>sym.field); } | |
484 | | | |
485 | sym_a sym_b | |
486 | { func($[sym.field]); } | |
487 | | | |
488 | sym_a sym_b | |
489 | { func($<aa>[sym.field]); } | |
490 | | | |
491 | sym_a sym_b | |
492 | { func($sym); } | |
493 | | | |
494 | sym_a sym_b | |
495 | { func($<aa>sym); } | |
496 | | | |
497 | sym_a sym_b | |
498 | { func($[sym]); } | |
499 | sym_a sym_b | |
500 | { func($<aa>[sym]); } | |
501 | ; | |
502 | stat1: | |
503 | sym_a sym_b | |
504 | { func($sym-field); } | |
505 | | | |
506 | sym_a sym_b | |
507 | { func($<aa>sym-field); } | |
508 | | | |
509 | sym_a sym_b | |
510 | { func($[sym-field]); } | |
511 | | | |
512 | sym_a sym_b | |
513 | { func($<aa>[sym-field]); } | |
514 | | | |
515 | sym_a sym_b | |
516 | { func($sym); } | |
517 | | | |
518 | sym_a sym_b | |
519 | { func($<aa>sym); } | |
520 | | | |
521 | sym_a sym_b | |
522 | { func($[sym]); } | |
523 | sym_a sym_b | |
524 | { func($<aa>[sym]); } | |
525 | ; | |
526 | sym_a : 'a'; | |
527 | sym_b : 'b'; | |
528 | ]]) | |
529 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
4c56b131 | 530 | [[test.y:13.8-17: invalid reference: `$sym.field' |
348f5608 | 531 | test.y:12.1-13.21: symbol not found in production: sym |
4c56b131 | 532 | test.y:16.8-21: invalid reference: `$<aa>sym.field' |
348f5608 | 533 | test.y:15.1-16.25: symbol not found in production: sym |
4c56b131 | 534 | test.y:19.8-19: invalid reference: `$[sym.field]' |
348f5608 | 535 | test.y:18.1-19.23: symbol not found in production: sym.field |
4c56b131 | 536 | test.y:22.8-23: invalid reference: `$<aa>[sym.field]' |
348f5608 | 537 | test.y:21.1-22.27: symbol not found in production: sym.field |
4c56b131 | 538 | test.y:25.8-11: invalid reference: `$sym' |
348f5608 | 539 | test.y:24.1-25.15: symbol not found in production: sym |
4c56b131 | 540 | test.y:28.8-15: invalid reference: `$<aa>sym' |
348f5608 | 541 | test.y:27.1-28.19: symbol not found in production: sym |
4c56b131 | 542 | test.y:31.8-13: invalid reference: `$[sym]' |
348f5608 | 543 | test.y:30.1-33.21: symbol not found in production before $3: sym |
4c56b131 | 544 | test.y:33.8-17: invalid reference: `$<aa>[sym]' |
348f5608 | 545 | test.y:30.1-33.21: symbol not found in production: sym |
4c56b131 | 546 | test.y:37.8-17: invalid reference: `$sym-field' |
348f5608 | 547 | test.y:36.1-37.21: symbol not found in production: sym |
4c56b131 | 548 | test.y:40.8-21: invalid reference: `$<aa>sym-field' |
348f5608 | 549 | test.y:39.1-40.25: symbol not found in production: sym |
4c56b131 | 550 | test.y:43.8-19: invalid reference: `$[sym-field]' |
348f5608 | 551 | test.y:42.1-43.23: symbol not found in production: sym-field |
4c56b131 | 552 | test.y:46.8-23: invalid reference: `$<aa>[sym-field]' |
348f5608 | 553 | test.y:45.1-46.27: symbol not found in production: sym-field |
4c56b131 | 554 | test.y:49.8-11: invalid reference: `$sym' |
348f5608 | 555 | test.y:48.1-49.15: symbol not found in production: sym |
4c56b131 | 556 | test.y:52.8-15: invalid reference: `$<aa>sym' |
348f5608 | 557 | test.y:51.1-52.19: symbol not found in production: sym |
4c56b131 | 558 | test.y:55.8-13: invalid reference: `$[sym]' |
348f5608 | 559 | test.y:54.1-57.21: symbol not found in production before $3: sym |
4c56b131 | 560 | test.y:57.8-17: invalid reference: `$<aa>[sym]' |
348f5608 | 561 | test.y:54.1-57.21: symbol not found in production: sym |
14e568d7 AR |
562 | ]]) |
563 | AT_CLEANUP |