tests/cxx-type.at

   1 # Checking GLR Parsing.                         -*- Autotest -*-
   2 # Copyright (C) 2002, 2003 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., 59 Temple Place - Suite 330, Boston, MA
  17 # 02111-1307, USA.
  18
  19 AT_BANNER([[C++ Type Syntax (GLR).]])
  20
  21 # _AT_TEST_GLR_CXXTYPES(DECL, RESOLVE1, RESOLVE2)
  22 # -----------------------------------------------
  23 # Store into types.y the calc program, with DECL inserted as a declaration,
  24 # and with RESOLVE1 and RESOLVE2 as annotations on the conflicted rule for
  25 # stmt.  Then compile the result.
  26 m4_define([_AT_TEST_GLR_CXXTYPES],
  27 [
  28 AT_BISON_OPTION_PUSHDEFS([$1])
  29
  30 AT_DATA_GRAMMAR([types.y],
  31 [[/* Simplified C++ Type and Expression Grammar.  */
  32
  33 $1
  34
  35 %{
  36   #include <stdio.h>
  37   #define YYSTYPE char const *
  38 ]m4_bmatch([$2], [stmtMerge],
  39 [ static YYSTYPE stmtMerge (YYSTYPE x0, YYSTYPE x1);])[
  40   #define YYINITDEPTH 10
  41   static char *format (char const *, ...);
  42   struct YYLTYPE;
  43 #if YYPURE
  44 # if YYLSP_NEEDED
  45 #  define LEX_PARAMETERS YYSTYPE *lvalp, struct YYLTYPE *llocp
  46 #  define ERROR_PARAMETERS struct YYLTYPE *llocp, char const *s
  47 # else
  48 #  define LEX_PARAMETERS YYSTYPE *lvalp
  49 # endif
  50 #endif
  51 #ifndef LEX_PARAMETERS
  52 # define LEX_PARAMETERS void
  53 #endif
  54 #ifndef ERROR_PARAMETERS
  55 # define ERROR_PARAMETERS char const *s
  56 #endif
  57   int yylex (LEX_PARAMETERS);
  58   int yyerror (ERROR_PARAMETERS);
  59 %}
  60
  61 %token TYPENAME ID
  62
  63 %right '='
  64 %left '+'
  65
  66 %glr-parser
  67
  68 %%
  69
  70 prog :
  71      | prog stmt   {
  72 ]AT_LOCATION_IF([
  73                         printf ("%d.%d-%d.%d: ",
  74                              @2.first_line, @2.first_column,
  75                              @2.last_line, @2.last_column);])[
  76                         printf ("%s\n", ]$[2);
  77                    }
  78      ;
  79
  80 stmt : expr ';'  $2     { $$ = ]$[1; }
  81      | decl      $3
  82      | error ';'        { $$ = "<error>"; }
  83      | '@'              { YYACCEPT; }
  84      ;
  85
  86 expr : ID
  87      | TYPENAME '(' expr ')'  { $$ = format ("<cast>(%s,%s)", ]$[3, ]$[1); }
  88      | expr '+' expr          { $$ = format ("+(%s,%s)", ]$[1, ]$[3); }
  89      | expr '=' expr          { $$ = format ("=(%s,%s)", ]$[1, ]$[3); }
  90      ;
  91
  92 decl : TYPENAME declarator ';'
  93                         { $$ = format ("<declare>(%s,%s)", ]$[1, ]$[2); }
  94      | TYPENAME declarator '=' expr ';'
  95                         { $$ = format ("<init-declare>(%s,%s,%s)", ]$[1, ]$[2, ]$[4); }
  96      ;
  97
  98 declarator : ID
  99      | '(' declarator ')' { $$ = ]$[2; }
 100      ;
 101
 102 %%
 103
 104 #include <ctype.h>
 105 #include <stdlib.h>
 106 #include <string.h>
 107 #include <stdarg.h>
 108
 109 int
 110 main (int argc, char **argv)
 111 {
 112   if (argc != 2)
 113     abort ();
 114   if (!freopen (argv[1], "r", stdin))
 115     abort ();
 116   exit (yyparse ());
 117 }
 118
 119 int
 120 yylex (LEX_PARAMETERS)
 121 {
 122   char buffer[256];
 123   int c;
 124   unsigned int i;
 125   static int lineNum = 1;
 126   static int colNum = 1;
 127
 128
 129 #if YYPURE
 130 # define yylloc (*llocp)
 131 # define yylval (*lvalp)
 132 #endif
 133
 134   while (1)
 135     {
 136       c = getchar ();
 137       switch (c)
 138         {
 139         case EOF:
 140           return 0;
 141         case '\t':
 142           colNum = 1 + ((colNum + 7) & ~7);
 143           break;
 144         case ' ': case '\f':
 145           colNum += 1;
 146           break;
 147         case '\n':
 148           lineNum += 1;
 149           colNum = 1;
 150           break;
 151         default:
 152           {
 153             int tok;
 154 #if YYLSP_NEEDED
 155             yylloc.first_line = yylloc.last_line = lineNum;
 156             yylloc.first_column = colNum;
 157 #endif
 158             if (isalpha (c))
 159               {
 160                 i = 0;
 161
 162                 do
 163                   {
 164                     buffer[i++] = c;
 165                     colNum += 1;
 166                     if (i == sizeof buffer - 1)
 167                       abort ();
 168                     c = getchar ();
 169                   }
 170                 while (isalnum (c) || c == '_');
 171
 172                 ungetc (c, stdin);
 173                 buffer[i++] = 0;
 174                 tok = isupper ((unsigned char) buffer[0]) ? TYPENAME : ID;
 175                 yylval = strcpy (malloc (i), buffer);
 176               }
 177             else
 178               {
 179                 colNum += 1;
 180                 tok = c;
 181                 yylval = "";
 182               }
 183 #if YYLSP_NEEDED
 184             yylloc.last_column = colNum-1;
 185 #endif
 186             return tok;
 187           }
 188         }
 189     }
 190 }
 191
 192 int
 193 yyerror (ERROR_PARAMETERS)
 194 {
 195 #if YYPURE && YYLSP_NEEDED
 196   /* Pacify GCC by using llocp.  */
 197   if (! llocp)
 198     abort ();
 199 #endif
 200   fprintf (stderr, "%s\n", s);
 201   return 0;
 202 }
 203
 204
 205 static char *
 206 format (char const *form, ...)
 207 {
 208    char buffer[1024];
 209    va_list args;
 210    va_start (args, form);
 211    vsprintf (buffer, form, args);
 212    va_end (args);
 213    return strcpy (malloc (strlen (buffer) + 1), buffer);
 214 }
 215
 216 ]]
 217 m4_bmatch([$2], [stmtMerge],
 218 [[static YYSTYPE
 219 stmtMerge (YYSTYPE x0, YYSTYPE x1)
 220 {
 221   return format ("<OR>(%s,%s)", x0, x1);
 222 }
 223 ]])
 224 )
 225
 226 AT_DATA([test-input],
 227 [[
 228
 229 z + q;
 230
 231 T x;
 232
 233 T x = y;
 234
 235 x = y;
 236
 237 T (x) + y;
 238
 239 T (x);
 240
 241 T (y) = z + q;
 242
 243 T (y y) = z + q;
 244
 245 z + q;
 246
 247 @
 248
 249 This is total garbage, but it should be ignored.
 250 ]])
 251
 252 AT_CHECK([bison -o types.c types.y], 0, [], ignore)
 253 AT_COMPILE([types])
 254 AT_BISON_OPTION_POPDEFS
 255 ])
 256
 257 m4_define([_AT_RESOLVED_GLR_OUTPUT],
 258 [[+(z,q)
 259 <declare>(T,x)
 260 <init-declare>(T,x,y)
 261 =(x,y)
 262 +(<cast>(x,T),y)
 263 <declare>(T,x)
 264 <init-declare>(T,y,+(z,q))
 265 <error>
 266 +(z,q)
 267 ]])
 268
 269 m4_define([_AT_RESOLVED_GLR_OUTPUT_WITH_LOC],
 270 [[3.1-3.6: +(z,q)
 271 5.1-5.4: <declare>(T,x)
 272 7.1-7.8: <init-declare>(T,x,y)
 273 9.1-9.6: =(x,y)
 274 11.1-11.10: +(<cast>(x,T),y)
 275 13.1-13.6: <declare>(T,x)
 276 15.1-15.14: <init-declare>(T,y,+(z,q))
 277 17.6-17.16: <error>
 278 19.1-19.6: +(z,q)
 279 ]])
 280
 281 m4_define([_AT_AMBIG_GLR_OUTPUT],
 282 [[+(z,q)
 283 <declare>(T,x)
 284 <init-declare>(T,x,y)
 285 =(x,y)
 286 +(<cast>(x,T),y)
 287 <OR>(<declare>(T,x),<cast>(x,T))
 288 <OR>(<init-declare>(T,y,+(z,q)),=(<cast>(y,T),+(z,q)))
 289 <error>
 290 +(z,q)
 291 ]])
 292
 293 m4_define([_AT_AMBIG_GLR_OUTPUT_WITH_LOC],
 294 [[3.1-3.6: +(z,q)
 295 5.1-5.4: <declare>(T,x)
 296 7.1-7.8: <init-declare>(T,x,y)
 297 9.1-9.6: =(x,y)
 298 11.1-11.10: +(<cast>(x,T),y)
 299 13.1-13.6: <OR>(<declare>(T,x),<cast>(x,T))
 300 15.1-15.14: <OR>(<init-declare>(T,y,+(z,q)),=(<cast>(y,T),+(z,q)))
 301 17.6-17.16: <error>
 302 19.1-19.6: +(z,q)
 303 ]])
 304
 305 m4_define([_AT_GLR_STDERR],
 306 [[syntax error
 307 ]])
 308
 309 m4_define([_AT_VERBOSE_GLR_STDERR],
 310 [[syntax error, unexpected ID, expecting '=' or '+' or ')'
 311 ]])
 312
 313 ## ---------------------------------------------------- ##
 314 ## Compile the grammar described in the documentation.  ##
 315 ## ---------------------------------------------------- ##
 316
 317 AT_SETUP([GLR: Resolve ambiguity, impure, no locations])
 318 _AT_TEST_GLR_CXXTYPES([],
 319                       [%dprec 1], [%dprec 2])
 320 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 321                 _AT_RESOLVED_GLR_OUTPUT, _AT_GLR_STDERR)
 322 AT_CLEANUP
 323
 324 AT_SETUP([GLR: Resolve ambiguity, impure, locations])
 325 _AT_TEST_GLR_CXXTYPES([%locations],[%dprec 1],[%dprec 2])
 326 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 327                 _AT_RESOLVED_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
 328 AT_CLEANUP
 329
 330 AT_SETUP([GLR: Resolve ambiguity, pure, no locations])
 331 _AT_TEST_GLR_CXXTYPES([%pure-parser],
 332                       [%dprec 1], [%dprec 2])
 333 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 334                 _AT_RESOLVED_GLR_OUTPUT, _AT_GLR_STDERR)
 335 AT_CLEANUP
 336
 337 AT_SETUP([GLR: Resolve ambiguity, pure, locations])
 338 _AT_TEST_GLR_CXXTYPES([%pure-parser %locations],
 339                       [%dprec 1], [%dprec 2])
 340 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 341                 _AT_RESOLVED_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
 342 AT_CLEANUP
 343
 344 AT_SETUP([GLR: Merge conflicting parses, impure, no locations])
 345 _AT_TEST_GLR_CXXTYPES([],
 346                       [%merge <stmtMerge>], [%merge <stmtMerge>])
 347 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 348                 _AT_AMBIG_GLR_OUTPUT, _AT_GLR_STDERR)
 349 AT_CLEANUP
 350
 351 AT_SETUP([GLR: Merge conflicting parses, impure, locations])
 352 _AT_TEST_GLR_CXXTYPES([%locations],
 353                       [%merge <stmtMerge>], [%merge <stmtMerge>])
 354 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 355                 _AT_AMBIG_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
 356 AT_CLEANUP
 357
 358 AT_SETUP([GLR: Merge conflicting parses, pure, no locations])
 359 _AT_TEST_GLR_CXXTYPES([%pure-parser],
 360                       [%merge <stmtMerge>], [%merge <stmtMerge>])
 361 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 362                 _AT_AMBIG_GLR_OUTPUT, _AT_GLR_STDERR)
 363 AT_CLEANUP
 364 AT_SETUP([GLR: Merge conflicting parses, pure, locations])
 365 _AT_TEST_GLR_CXXTYPES([%pure-parser %locations],
 366                       [%merge <stmtMerge>],[%merge <stmtMerge>])
 367 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 368                 _AT_AMBIG_GLR_OUTPUT_WITH_LOC, _AT_GLR_STDERR)
 369 AT_CLEANUP
 370
 371 AT_SETUP([GLR: Verbose messages, resolve ambiguity, impure, no locations])
 372 _AT_TEST_GLR_CXXTYPES([%error-verbose],
 373                       [%merge <stmtMerge>], [%merge <stmtMerge>])
 374 AT_PARSER_CHECK([[./types test-input | sed 's/  *$//']], 0,
 375                 _AT_AMBIG_GLR_OUTPUT, _AT_VERBOSE_GLR_STDERR)
 376 AT_CLEANUP