projects / bison.git / blame
| Commit | Line | Data |
|---|---|---|
| b9f1d9a4 AR |
1 | # Named references test. -*- Autotest -*- |
| 2 | ||
| 3 | # Copyright (C) 2009 Free Software | |
| 4 | # Foundation, Inc. | |
| 5 | ||
| 6 | # This program is free software: you can redistribute it and/or modify | |
| 7 | # it under the terms of the GNU General Public License as published by | |
| 8 | # the Free Software Foundation, either version 3 of the License, or | |
| 9 | # (at your option) any later version. | |
| 10 | # | |
| 11 | # This program is distributed in the hope that it will be useful, | |
| 12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 14 | # GNU General Public License for more details. | |
| 15 | # | |
| 16 | # You should have received a copy of the GNU General Public License | |
| 17 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 18 | ||
| 19 | AT_BANNER([[Named references tests.]]) | |
| 20 | ||
| 21 | AT_SETUP([Tutorial calculator]) | |
| 22 | ||
| 23 | AT_DATA_GRAMMAR([test.y], | |
| 24 | [[ | |
| 25 | %{ | |
| 26 | #include <stdio.h> | |
| 27 | #include <stdlib.h> | |
| 28 | #include <string.h> | |
| 29 | #include <ctype.h> | |
| 30 | typedef int semantic_value; | |
| 31 | FILE *input; | |
| 32 | static semantic_value global_result = 0; | |
| 33 | static int global_count = 0; | |
| 34 | static int power (int base, int exponent); | |
| 35 | static void yyerror (const char *s); | |
| 36 | int yylex (void); | |
| 37 | %} | |
| 38 | ||
| 39 | %union | |
| 40 | { | |
| 41 | semantic_value ival; | |
| 42 | }; | |
| 43 | ||
| 44 | %token CALC_EOF 0 "end of input" | |
| 45 | %token <ival> NUM "number" | |
| 46 | %type <ival> exp | |
| 47 | ||
| 48 | %nonassoc '=' /* comparison */ | |
| 49 | %left '-' '+' | |
| 50 | %left '*' '/' | |
| 51 | %precedence NEG /* negation--unary minus */ | |
| 52 | %right '^' /* exponentiation */ | |
| 53 | ||
| 54 | %% | |
| 55 | input: | |
| 56 | line | |
| 57 | | input line { } | |
| 58 | ; | |
| 59 | ||
| 60 | line: | |
| 61 | '\n' | |
| 62 | | exp '\n' { } | |
| 63 | ; | |
| 64 | ||
| 65 | exp: | |
| 66 | NUM { $$ = $NUM; } | |
| 67 | | exp[l] '=' exp[r] | |
| 68 | { | |
| 69 | if ($l != $r) | |
| 70 | fprintf (stderr, "calc: error: %d != %d\n", $l, $r); | |
| 71 | $$ = $l; | |
| 72 | } | |
| 73 | | exp[x] '+' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>l + $r; } | |
| 74 | | exp[l] '-' exp[r] { $$ = $l - $r; } | |
| 75 | | exp[l] '*' exp[r] { $$ = $l * $r; } | |
| 76 | | exp[l] '/' exp[r] { $$ = $l / $r; } | |
| 77 | | '-' exp %prec NEG { $$ = -$2; } | |
| 78 | | exp[l] '^' exp[r] { $$ = power ($l, $r); } | |
| 79 | | '(' exp[e] ')' { $$ = $e; } | |
| 80 | | '(' error ')' { $$ = 1111; yyerrok; } | |
| 81 | | '!' { $$ = 0; YYERROR; } | |
| 82 | | '-' error { $$ = 0; YYERROR; } | |
| 83 | ; | |
| 84 | %% | |
| 85 | ||
| 86 | static void yyerror (const char *s) | |
| 87 | { | |
| 88 | fprintf (stderr, "%s\n", s); | |
| 89 | } | |
| 90 | ||
| 91 | static int get_char (void) | |
| 92 | { | |
| 93 | int res = getc (input); | |
| 94 | return res; | |
| 95 | } | |
| 96 | ||
| 97 | static void unget_char (int c) | |
| 98 | { | |
| 99 | ungetc (c, input); | |
| 100 | } | |
| 101 | ||
| 102 | static int read_signed_integer (void) | |
| 103 | { | |
| 104 | int c = get_char (); | |
| 105 | int sign = 1; | |
| 106 | int n = 0; | |
| 107 | if (c == '-') | |
| 108 | { | |
| 109 | c = get_char (); | |
| 110 | sign = -1; | |
| 111 | } | |
| 112 | while (isdigit (c)) | |
| 113 | { | |
| 114 | n = 10 * n + (c - '0'); | |
| 115 | c = get_char (); | |
| 116 | } | |
| 117 | unget_char ( c); | |
| 118 | return sign * n; | |
| 119 | } | |
| 120 | ||
| 121 | int yylex (void) | |
| 122 | { | |
| 123 | int c; | |
| 124 | /* Skip white space. */ | |
| 125 | while ((c = get_char ()) == ' ' || c == '\t') {} | |
| 126 | ||
| 127 | /* process numbers */ | |
| 128 | if (c == '.' || isdigit (c)) | |
| 129 | { | |
| 130 | unget_char ( c); | |
| 131 | (yylval).ival = read_signed_integer (); | |
| 132 | return NUM; | |
| 133 | } | |
| 134 | ||
| 135 | /* Return end-of-file. */ | |
| 136 | if (c == EOF) | |
| 137 | return CALC_EOF; | |
| 138 | ||
| 139 | /* Return single chars. */ | |
| 140 | return c; | |
| 141 | } | |
| 142 | ||
| 143 | static int power (int base, int exponent) | |
| 144 | { | |
| 145 | int res = 1; | |
| 146 | if (exponent < 0) | |
| 147 | exit (3); | |
| 148 | for (/* Niente */; exponent; --exponent) | |
| 149 | res *= base; | |
| 150 | return res; | |
| 151 | } | |
| 152 | ||
| 153 | int main (int argc, const char **argv) | |
| 154 | { | |
| 155 | semantic_value result = 0; | |
| 156 | int count = 0; | |
| 157 | int status; | |
| 158 | if (argc == 2) | |
| 159 | input = fopen (argv[1], "r"); | |
| 160 | else | |
| 161 | input = stdin; | |
| 162 | if (!input) | |
| 163 | { | |
| 164 | perror (argv[1]); | |
| 165 | return 3; | |
| 166 | } | |
| 167 | status = yyparse (); | |
| 168 | fclose (input); | |
| 169 | if (global_result != result) | |
| 170 | abort (); | |
| 171 | if (global_count != count) | |
| 172 | abort (); | |
| 173 | return status; | |
| 174 | } | |
| 175 | ]]) | |
| 176 | ||
| 177 | AT_DATA([input.txt], | |
| 178 | [[ | |
| 179 | 1 + 2 * 3 = 7 | |
| 180 | 1 + 2 * -3 = -5 | |
| 181 | -1^2 = -1 | |
| 182 | (-1)^2 = 1 | |
| 183 | ---1 = -1 | |
| 184 | 1 - 2 - 3 = -4 | |
| 185 | 1 - (2 - 3) = 2 | |
| 186 | 2^2^3 = 256 | |
| 187 | (2^2)^3 = 64 | |
| 188 | ]]) | |
| 189 | ||
| 190 | AT_BISON_CHECK([-o test.c test.y]) | |
| 191 | AT_COMPILE([[test]]) | |
| 192 | AT_PARSER_CHECK([./test input.txt], 0, [], [stderr]) | |
| 193 | AT_CLEANUP | |
| 194 | ||
| 195 | ||
| 196 | ||
| 197 | ####################################################################### | |
| 198 | ||
| 199 | ||
| 200 | AT_SETUP([Undefined and ambiguous references]) | |
| 201 | ||
| 202 | AT_DATA_GRAMMAR([test.y], | |
| 203 | [[ | |
| 204 | %{ | |
| 205 | static int power (int base, int exponent); | |
| 206 | static void yyerror (const char *s); | |
| 207 | int yylex (void); | |
| 208 | %} | |
| 209 | ||
| 210 | %union | |
| 211 | { | |
| 212 | int ival; | |
| 213 | }; | |
| 214 | ||
| 215 | %token CALC_EOF 0 "end of input" | |
| 216 | %token <ival> NUM "number" | |
| 217 | %type <ival> exp | |
| 218 | ||
| 219 | %nonassoc '=' /* comparison */ | |
| 220 | %left '-' '+' | |
| 221 | %left '*' '/' | |
| 222 | %precedence NEG /* negation--unary minus */ | |
| 223 | %right '^' /* exponentiation */ | |
| 224 | ||
| 225 | %% | |
| 226 | input: | |
| 227 | line | |
| 228 | | input line { } | |
| 229 | ; | |
| 230 | ||
| 231 | line: | |
| 232 | '\n' | |
| 233 | | exp '\n' { } | |
| 234 | ; | |
| 235 | ||
| 236 | exp: | |
| 237 | NUM { $$ = $NUM; } | |
| 238 | | exp[l] '=' exp[r] | |
| 239 | { | |
| 240 | if ($l != $r) | |
| 241 | fprintf (stderr, "calc: error: %d != %d\n", $l, $r); | |
| 242 | $$ = $l; | |
| 243 | } | |
| 244 | | exp[x] '+' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>lo9 + $r; } | |
| 245 | | exp[x] '-' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>exp - $r; } | |
| 246 | | exp[x] '*' { $<ival>$ = $x; } [l] exp[r] { $$ = $l * $r; } | |
| 247 | | exp[l] '/' exp[r] { $$ = $l / $r; } | |
| 248 | | '-' exp %prec NEG { $$ = -$2; } | |
| 249 | | exp[l] '^' exp[r] { $$ = power ($l, $r12); } | |
| 250 | | '(' exp ')' { $$ = $expo; } | |
| 251 | | '(' error ')' { $$ = 1111; yyerrok; } | |
| 252 | | '!' { $$ = 0; YYERROR; } | |
| 253 | | '-' error { $$ = 0; YYERROR; } | |
| 254 | ; | |
| 255 | %% | |
| 256 | ]]) | |
| 257 | ||
| 258 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 259 | [[test.y:50.51-60: reference is invalid: `$<ival>lo9', symbol not found | |
| 260 | test.y:51.51-60: reference is misleading: `$<ival>exp' | |
| 261 | test.y:42.1-3: refers to: $exp at $$ | |
| 262 | test.y:51.7: possibly meant: $x, hiding $exp at $1 | |
| 263 | test.y:51.41: possibly meant: $r, hiding $exp at $4 | |
| 264 | test.y:52.51-52: $l of `exp' has no declared type | |
| 265 | test.y:55.46-49: reference is invalid: `$r12', symbol not found | |
| 266 | test.y:56.29-33: reference is invalid: `$expo', symbol not found | |
| 267 | ]]) | |
| 268 | AT_CLEANUP | |
| 269 | ||
| 270 | ####################################################################### | |
| 271 | ||
| 272 | AT_SETUP([Misleading references]) | |
| 273 | AT_DATA_GRAMMAR([test.y], | |
| 274 | [[ | |
| 275 | %% | |
| 276 | start: foo foo.bar { $foo.bar; } | |
| 277 | foo: '1' | |
| 278 | foo.bar: '2' | |
| 279 | ]]) | |
| 280 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 281 | [[test.y:11.22-29: reference is misleading: `$foo.bar' | |
| 282 | test.y:11.8-10: refers to: $foo at $1 | |
| 283 | test.y:11.12-18: possibly meant: $[foo.bar] at $2 | |
| 284 | ]]) | |
| 285 | AT_CLEANUP | |
| 286 | ||
| 287 | ####################################################################### | |
| 288 | ||
| 289 | AT_SETUP([Many kinds of errors]) | |
| 290 | AT_DATA_GRAMMAR([test.y], | |
| 291 | [[ | |
| 292 | %token IDENT | |
| 293 | %token NUMBER | |
| 294 | %token ASSIGNOP | |
| 295 | %token IF | |
| 296 | %token IF1 | |
| 297 | %token THEN | |
| 298 | %token ELSE | |
| 299 | %token FI | |
| 300 | %token WHILE | |
| 301 | %token DO | |
| 302 | %token OD | |
| 303 | %start program | |
| 304 | %% | |
| 305 | if_stmt1: IF expr[cond] THEN stmt[then] ELSE stmt.list[else] FI | |
| 306 | { $if_stmt1 = new IfStmt($cond1, $then.f1, $else); }; | |
| 307 | if_stmt2: IF expr[cond] THEN stmt[then] FI | |
| 308 | { $if_stmt2 = new IfStmt($cond, $stmt.field, 0); }; | |
| 309 | if_stmt3: IF expr[cond] THEN stmt.list FI | |
| 310 | { $if_stmt3 = new IfStmt($cond, $stmt.list, 0); }; | |
| 311 | if_stmt4: IF expr[cond] THEN stmt[xyz] ELSE stmt[xyz] FI | |
| 312 | { $if_stmt4 = new IfStmt($cond, $xyz, $cond); }; | |
| 313 | if_stmt5: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
| 314 | { $if_stmt5 = new IfStmt($cond, $stmt.list, $else); }; | |
| 315 | if_stmt6: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
| 316 | { $if_stmt6 = new IfStmt($cond, $stmt.list.field, $else); }; | |
| 317 | if_stmt7: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
| 318 | { $if_stmt7 = new IfStmt($cond, $[stmt.list].field, $else); }; | |
| 319 | if_stmt8: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI | |
| 320 | { $if_stmt8 = new IfStmt($cond, $then.1, $else); }; | |
| 321 | if_stmt9: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI | |
| 322 | { $if_stmt9 = new IfStmt($cond, $then.1.field, $else); }; | |
| 323 | if_stmt10: IF expr[cond] THEN stmt[stmt.x] FI | |
| 324 | { $if_stmt10 = new IfStmt($cond, $stmt.x, 0); }; | |
| 325 | if-stmt-a: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI | |
| 326 | { $if-stmt-a = new IfStmt($cond, $then, $else); }; | |
| 327 | if-stmt-b: IF expr[cond] THEN if-stmt-a[then-a] ELSE stmt.list[else] FI | |
| 328 | { $[if-stmt-b] = new IfStmt($cond, $then-a.f, $else); }; | |
| 329 | program: stmt.list; | |
| 330 | stmt.list: stmt ';' stmt.list { $3->insert($stmt); $$ = $3; } | |
| 331 | | stmt ';' { SL = new StmtList(); SL->insert($1); $$ = SL; } | |
| 332 | ; | |
| 333 | stmt: assign_stmt { $$ = $1; } | |
| 334 | | if_stmt { $$ = $1; } | |
| 335 | | if_stmt1 { $$ = $1; } | |
| 336 | | while_stmt { $$ = $1; } | |
| 337 | ; | |
| 338 | assign_stmt: IDENT ASSIGNOP expr | |
| 339 | { $$ = new AssignStmt(string($1),$3); }; | |
| 340 | if_stmt: IF expr[cond] THEN stmt.list FI | |
| 341 | { $if_stmt = new IfStmt($cond, $[stmt.list], 0); }; | |
| 342 | while_stmt[res]: WHILE expr DO stmt.list OD | |
| 343 | { $res = new WhileStmt($[expr], $[stmt.list]); }; | |
| 344 | expr: expr '+' term { $$ = new Plus($1,$3); } | |
| 345 | | expr '-' term { $$ = new Minus($1,$3); } | |
| 346 | | term { $$ = $1; } | |
| 347 | ; | |
| 348 | term: term '*' factor { $$ = new Times($1,$3); } | |
| 349 | | factor { $$ = $1; } | |
| 350 | ; | |
| 351 | factor: '(' expr ')' { $$ = $2; } | |
| 352 | | NUMBER { $$ = new Number($1); } | |
| 353 | | IDENT { $$ = new Ident(string($1)); } | |
| 354 | ; | |
| 355 | ]]) | |
| 356 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 357 | [[test.y:24.36-41: reference is invalid: `$cond1', symbol not found | |
| 358 | test.y:26.43-53: reference is invalid: `$stmt.field' | |
| 359 | test.y:25.35-38: possibly meant: $then.field, hiding $stmt.field at $4 | |
| 360 | test.y:28.43-52: reference is invalid: `$stmt.list' | |
| 361 | test.y:27.30-38: possibly meant: $[stmt.list] at $4 | |
| 362 | test.y:30.43-46: reference is ambiguous: `$xyz' | |
| 363 | test.y:29.35-37: refers to: $xyz at $4 | |
| 364 | test.y:29.50-52: refers to: $xyz at $6 | |
| 365 | test.y:32.43-52: reference is invalid: `$stmt.list' | |
| 366 | test.y:31.40-43: possibly meant: $then, hiding $[stmt.list] at $4 | |
| 367 | test.y:31.61-64: possibly meant: $else, hiding $[stmt.list] at $6 | |
| 368 | test.y:34.43-58: reference is invalid: `$stmt.list.field' | |
| 369 | test.y:33.40-43: possibly meant: $then.field, hiding $[stmt.list].field at $4 | |
| 370 | test.y:33.61-64: possibly meant: $else.field, hiding $[stmt.list].field at $6 | |
| 371 | test.y:36.43-54: reference is invalid: `$[stmt.list]' | |
| 372 | test.y:35.40-43: possibly meant: $then, hiding $[stmt.list] at $4 | |
| 373 | test.y:35.61-64: possibly meant: $else, hiding $[stmt.list] at $6 | |
| 374 | test.y:38.43-49: reference is invalid: `$then.1' | |
| 375 | test.y:37.40-45: possibly meant: $[then.1] at $4 | |
| 376 | test.y:40.43-55: reference is invalid: `$then.1.field' | |
| 377 | test.y:39.40-45: possibly meant: $[then.1].field at $4 | |
| 378 | test.y:42.44-50: reference is invalid: `$stmt.x' | |
| 379 | test.y:41.36-41: possibly meant: $[stmt.x].x, hiding $stmt.x at $4 | |
| 380 | test.y:41.36-41: possibly meant: $[stmt.x] at $4 | |
| 381 | test.y:44.13-22: reference is invalid: `$if-stmt-a' | |
| 382 | test.y:43.1-9: possibly meant: $[if-stmt-a] at $$ | |
| 383 | test.y:46.46-54: reference is invalid: `$then-a.f' | |
| 384 | test.y:45.41-46: possibly meant: $[then-a].f at $4 | |
| 385 | ]]) | |
| 386 | AT_CLEANUP | |
| 387 | ||
| 388 | ####################################################################### | |
| 389 | ||
| 390 | AT_SETUP([Missing identifiers in brackets]) | |
| 391 | AT_DATA_GRAMMAR([test.y], | |
| 392 | [[ | |
| 393 | %% | |
| 394 | start: foo[] bar | |
| 395 | { s = $foo; } | |
| 396 | ]]) | |
| 397 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 398 | [[test.y:11.12: a non empty identifier expected | |
| 399 | ]]) | |
| 400 | AT_CLEANUP | |
| 401 | ||
| 402 | ####################################################################### | |
| 403 | ||
| 404 | AT_SETUP([Redundant words in brackets]) | |
| 405 | AT_DATA_GRAMMAR([test.y], | |
| 406 | [[ | |
| 407 | %% | |
| 408 | start: foo[ a d ] bar | |
| 409 | { s = $foo; } | |
| 410 | ]]) | |
| 411 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 412 | [[test.y:11.15: redundant identifier in bracketed name: `d' | |
| 413 | ]]) | |
| 414 | AT_CLEANUP | |
| 415 | ||
| 416 | ####################################################################### | |
| 417 | ||
| 418 | AT_SETUP([Comments in brackets]) | |
| 419 | AT_DATA_GRAMMAR([test.y], | |
| 420 | [[ | |
| 421 | %% | |
| 422 | start: foo[/* comment */] bar | |
| 423 | { s = $foo; } | |
| 424 | ]]) | |
| 425 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 426 | [[test.y:11.25: a non empty identifier expected | |
| 427 | ]]) | |
| 428 | AT_CLEANUP | |
| 429 | ||
| 430 | ####################################################################### | |
| 431 | ||
| 432 | AT_SETUP([Stray symbols in brackets]) | |
| 433 | AT_DATA_GRAMMAR([test.y], | |
| 434 | [[ | |
| 435 | %% | |
| 436 | start: foo[ /* aaa */ *&-+ ] bar | |
| 437 | { s = $foo; } | |
| 438 | ]]) | |
| 439 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 440 | [[test.y:11.23: invalid character in bracketed name: `*' | |
| 441 | test.y:11.24: invalid character in bracketed name: `&' | |
| 442 | test.y:11.26: invalid character in bracketed name: `+' | |
| 443 | ]]) | |
| 444 | AT_CLEANUP | |
| 445 | ||
| 446 | ####################################################################### | |
| 447 | ||
| 448 | AT_SETUP([Redundant words in LHS brackets]) | |
| 449 | AT_DATA_GRAMMAR([test.y], | |
| 450 | [[ | |
| 451 | %% | |
| 452 | start[a s]: foo | |
| 453 | ]]) | |
| 454 | AT_BISON_CHECK([-o test.c test.y], 1, [], | |
| 455 | [[test.y:11.9: redundant identifier in bracketed name: `s' | |
| 456 | ]]) | |
| 457 | AT_CLEANUP |