tests/glr-regression.at

   1 # Checking GLR Parsing: Regression Tests           -*- Autotest -*-
   2 # Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
   3
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 2, or (at your option)
   7 # any later version.
   8
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17 # 02110-1301, USA.
  18
  19 AT_BANNER([[GLR Regression Tests]])
  20
  21 ## --------------------------- ##
  22 ## Badly Collapsed GLR States. ##
  23 ## --------------------------- ##
  24
  25 AT_SETUP([Badly Collapsed GLR States])
  26
  27 AT_DATA_GRAMMAR([glr-regr1.y],
  28 [[/* Regression Test: Improper state compression */
  29 /* Reported by Scott McPeak */
  30
  31 %{
  32 #include <stdio.h>
  33
  34 #define YYSTYPE int
  35 static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
  36 int yylex (void);
  37 int yyerror (char const *msg);
  38 %}
  39
  40
  41 %glr-parser
  42
  43
  44 /* -------- productions ------ */
  45 %%
  46
  47 StartSymbol: E  { $$=0; }                   %merge <exprMerge>
  48            ;
  49
  50 E: E 'P' E { $$=1; printf("E -> E 'P' E\n"); }  %merge <exprMerge>
  51  | 'B'     { $$=2; printf("E -> 'B'\n"); }      %merge <exprMerge>
  52  ;
  53
  54
  55
  56 /* ---------- C code ----------- */
  57 %%
  58
  59 static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1)
  60 {
  61   (void) x0;
  62   (void) x1;
  63   printf ("<OR>\n");
  64   return 0;
  65 }
  66
  67 int
  68 main (void)
  69 {
  70   return yyparse ();
  71 }
  72
  73 int
  74 yyerror (char const *msg)
  75 {
  76   fprintf (stderr, "%s\n", msg);
  77   exit (4);
  78 }
  79
  80
  81 int
  82 yylex (void)
  83 {
  84   for (;;)
  85     {
  86       int ch = getchar ();
  87       if (ch == EOF)
  88         return 0;
  89       else if (ch == 'B' || ch == 'P')
  90         return ch;
  91     }
  92 }
  93 ]])
  94
  95 AT_CHECK([[bison -o glr-regr1.c glr-regr1.y]], 0, [],
  96 [glr-regr1.y: conflicts: 1 shift/reduce
  97 ])
  98 AT_COMPILE([glr-regr1])
  99 AT_CHECK([[echo BPBPB | ./glr-regr1]], 0,
 100 [[E -> 'B'
 101 E -> 'B'
 102 E -> E 'P' E
 103 E -> 'B'
 104 E -> E 'P' E
 105 E -> 'B'
 106 E -> E 'P' E
 107 E -> E 'P' E
 108 <OR>
 109 ]], [])
 110
 111 AT_CLEANUP
 112
 113 ## ------------------------------------------------------------ ##
 114 ## Improper handling of embedded actions and $-N in GLR parsers ##
 115 ## ------------------------------------------------------------ ##
 116
 117 AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers])
 118
 119 AT_DATA_GRAMMAR([glr-regr2a.y],
 120 [[/* Regression Test: Improper handling of embedded actions and $-N  */
 121 /* Reported by S. Eken */
 122
 123 %{
 124   #define YYSTYPE char const *
 125   #define yyfalse 0
 126   #define yytrue 1
 127
 128   #include <ctype.h>
 129   #include <stdio.h>
 130   #include <stdlib.h>
 131   #include <string.h>
 132   int yylex (void);
 133   void yyerror (char const *);
 134 %}
 135
 136 %glr-parser
 137
 138 %%
 139
 140 command:
 141     's' var 't'
 142        { printf ("Variable: '%s'\n", $2); }
 143     'v' 'x' 'q'
 144   | 's' var_list 't' 'e'
 145        { printf ("Varlist: '%s'\n", $2); }
 146   | 's' var 't' var_printer 'x'
 147   ;
 148
 149 var:
 150   'V'
 151      { $$ = $1; }
 152   ;
 153
 154 var_list:
 155   var
 156     { $$ = $1; }
 157   | var ',' var_list
 158     {
 159       $$ = malloc (strlen ($1) + 1 + strlen ($3) + 1);
 160       strcpy ($$, $1);
 161       strcat ($$, ",");
 162       strcat ($$, $3);
 163     }
 164   ;
 165
 166 var_printer: 'v'
 167    { printf ("Variable: '%s'\n", $-1); }
 168
 169 %%
 170
 171 FILE *yyin = NULL;
 172
 173 int
 174 yylex (void)
 175 {
 176   char buf[50];
 177   switch (fscanf (yyin, " %1[a-z,]", buf)) {
 178   case 1:
 179     return buf[0];
 180   case EOF:
 181     return 0;
 182   default:
 183     break;
 184   }
 185   if (fscanf (yyin, "%49s", buf) != 1)
 186     abort ();
 187   if (sizeof buf - 1 <= strlen (buf))
 188     abort ();
 189   yylval = malloc (strlen (buf) + 1);
 190   strcpy (yylval, buf);
 191   return 'V';
 192 }
 193
 194 void
 195 yyerror (char const *s)
 196 { printf ("%s\n", s);
 197 }
 198
 199 int
 200 main (int argc, char **argv)
 201 {
 202   yyin = stdin;
 203   if (argc == 2 && !(yyin = fopen (argv[1], "r"))) return 1;
 204   return yyparse ();
 205 }
 206 ]])
 207
 208 AT_CHECK([[bison -o glr-regr2a.c glr-regr2a.y]], 0, [],
 209 [glr-regr2a.y: conflicts: 2 shift/reduce
 210 ])
 211 AT_COMPILE([glr-regr2a])
 212
 213 AT_CHECK([[echo s VARIABLE_1 t v x q | ./glr-regr2a]], 0,
 214 [[Variable: 'VARIABLE_1'
 215 ]], [])
 216 AT_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e | ./glr-regr2a]], 0,
 217 [[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
 218 ]])
 219 AT_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0,
 220 [[Variable: 'VARIABLE_3'
 221 ]], [])
 222
 223
 224 AT_CLEANUP
 225
 226 ## ------------------------------------------------------------ ##
 227 ## Improper merging of GLR delayed action sets                  ##
 228 ## ------------------------------------------------------------ ##
 229
 230 AT_SETUP([Improper merging of GLR delayed action sets])
 231
 232 AT_DATA_GRAMMAR([glr-regr3.y],
 233 [[/* Regression Test: Improper merging of GLR delayed action sets.  */
 234 /* Reported by M. Rosien */
 235
 236 %{
 237 #include <stdio.h>
 238 #include <stdarg.h>
 239
 240 static int MergeRule (int x0, int x1);
 241 static void yyerror(char const * s);
 242 int yylex (void);
 243
 244 #define RULE(x) (1 << (x))
 245
 246 %}
 247
 248 %glr-parser
 249
 250 %token BAD_CHAR
 251 %token P1 P2 T1 T2 T3 T4 O1 O2
 252
 253 %%
 254
 255 S : P1 T4 O2 NT6 P2  { printf ("Result: %x\n", $4); }
 256 ;
 257
 258 NT1 : P1 T1 O1 T2 P2 { $$ = RULE(2); }  %merge<MergeRule>
 259 ;
 260
 261 NT2 : NT1             { $$ = RULE(3); } %merge<MergeRule>
 262     | P1 NT1 O1 T3 P2 { $$ = RULE(4); } %merge<MergeRule>
 263 ;
 264
 265 NT3 : T3              { $$ = RULE(5); } %merge<MergeRule>
 266     | P1 NT1 O1 T3 P2 { $$ = RULE(6); } %merge<MergeRule>
 267 ;
 268
 269 NT4 : NT3              { $$ = RULE(7); } %merge<MergeRule>
 270     | NT2              { $$ = RULE(8); } %merge<MergeRule>
 271     | P1 NT2 O1 NT3 P2 { $$ = RULE(9); } %merge<MergeRule>
 272 ;
 273
 274 NT5 : NT4              { $$ = RULE(10); } %merge<MergeRule>
 275 ;
 276
 277 NT6 : P1 NT1 O1 T3 P2  { $$ = RULE(11) | $2; } %merge<MergeRule>
 278     | NT5              { $$ = RULE(12) | $1; } %merge<MergeRule>
 279 ;
 280
 281 %%
 282
 283 static int MergeRule (int x0, int x1) {
 284   return x0 | x1;
 285 }
 286
 287 static void yyerror(char const * s) {
 288   fprintf(stderr,"error: %s\n",s);
 289 }
 290
 291 FILE *yyin = NULL;
 292
 293 int P[] = { P1, P2 };
 294 int O[] = { O1, O2 };
 295 int T[] = { T1, T2, T3, T4 };
 296
 297 int yylex (void)
 298 {
 299   char inp[3];
 300   if (fscanf (yyin, "%2s", inp) == EOF)
 301     return 0;
 302   switch (inp[0])
 303     {
 304     case 'p': return P[inp[1] - '1'];
 305     case 't': return T[inp[1] - '1'];
 306     case 'o': return O[inp[1] - '1'];
 307     }
 308   return BAD_CHAR;
 309 }
 310
 311 int main(int argc, char* argv[]) {
 312   yyin = stdin;
 313   if (argc == 2 && !(yyin = fopen (argv[1], "r"))) return 1;
 314   return yyparse ();
 315 }
 316 ]])
 317
 318 AT_CHECK([[bison -o glr-regr3.c glr-regr3.y]], 0, [],
 319 [glr-regr3.y: conflicts: 1 shift/reduce, 1 reduce/reduce
 320 ])
 321 AT_COMPILE([glr-regr3])
 322
 323 AT_CHECK([[echo p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2 | ./glr-regr3]], 0,
 324 [[Result: 1c04
 325 ]], [])
 326
 327 AT_CLEANUP