# Checking the output filenames. -*- Autotest -*- # Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. ## ---------------------------------------------------- ## ## Compile the grammar described in the documentation. ## ## ---------------------------------------------------- ## # ------------------------- # # Helping Autotest macros. # # ------------------------- # # _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES]) # ----------------------------------------------- # Produce `calc.y'. Don't call this macro directly, because it contains # some occurrences of `$1' etc. which will be interpreted by m4. So # you should call it with $1, $2, and $3 as arguments, which is what # AT_DATA_CALC_Y does. m4_define([_AT_DATA_CALC_Y], [m4_if([$1$2$3], $[1]$[2]$[3], [], [m4_fatal([$0: Invalid arguments: $@])])dnl AT_DATA_GRAMMAR([calc.y], [[/* Infix notation calculator--calc */ ]$4[ %{ #include <stdio.h> #if STDC_HEADERS # include <stdlib.h> # include <string.h> #endif #include <ctype.h> extern void perror (const char *s); /* Exercise pre-prologue dependency to %union. */ typedef int value_t; static value_t global_result = 0; static int global_count = 0; %} /* Exercise %union. */ %union { value_t ival; }; %{ #if YYPURE # define LOC (*yylloc) # define VAL (*yylval) #else # define LOC (yylloc) # define VAL (yylval) #endif #define YYLLOC_FORMAL ]AT_LOCATION_IF([, YYLTYPE *yylloc])[ #define YYLLOC_ARG ]AT_LOCATION_IF([, yylloc])[ #define USE_YYLLOC ]AT_LOCATION_IF([(void) yylloc;])[ #if YYPURE # define LEX_FORMALS YYSTYPE *yylval YYLLOC_FORMAL # define LEX_ARGS yylval YYLLOC_ARG # define USE_LEX_ARGS (void) yylval; USE_YYLLOC # define LEX_PRE_FORMALS LEX_FORMALS, # define LEX_PRE_ARGS LEX_ARGS, #else # define LEX_FORMALS void # define LEX_PRE_FORMALS # define LEX_ARGS # define LEX_PRE_ARGS # define USE_LEX_ARGS #endif static int power (int base, int exponent); /* yyerror receives the location if: - %location & %pure & %glr - %location & %pure & %yacc & %parse-param. */ static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[ ]AT_PARAM_IF([value_t *result, int *count, ])[ const char *s ); static int yylex (LEX_FORMALS); static int yygetc (LEX_FORMALS); static void yyungetc (LEX_PRE_FORMALS int c); %} /* Bison Declarations */ %token CALC_EOF 0 "end of input" %token <ival> NUM "number" %type <ival> exp %nonassoc '=' /* comparison */ %left '-' '+' %left '*' '/' %left NEG /* negation--unary minus */ %right '^' /* exponentiation */ /* Grammar follows */ %% input: line | input line { ]AT_PARAM_IF([++*count; ++global_count;])[ } ; line: '\n' | exp '\n' { ]AT_PARAM_IF([*result = global_result = $1;])[ } ; exp: NUM { $$ = $1; } | exp '=' exp { if ($1 != $3) fprintf (stderr, "calc: error: %d != %d\n", $1, $3); $$ = $1; } | exp '+' exp { $$ = $1 + $3; } | exp '-' exp { $$ = $1 - $3; } | exp '*' exp { $$ = $1 * $3; } | exp '/' exp { $$ = $1 / $3; } | '-' exp %prec NEG { $$ = -$2; } | exp '^' exp { $$ = power ($1, $3); } | '(' exp ')' { $$ = $2; } | '(' error ')' { $$ = 0; } ; %% /* The input. */ static FILE *yyin; static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[ ]AT_PARAM_IF([value_t *result, int *count, ])[ const char *s ) { ]AT_PARAM_IF([(void) result; (void) count; ])[ ]AT_YYERROR_SEES_LOC_IF([ fprintf (stderr, "%d.%d-%d.%d: ", LOC.first_line, LOC.first_column, LOC.last_line, LOC.last_column); ])[ fprintf (stderr, "%s\n", s); } ]AT_LOCATION_IF([ static YYLTYPE last_yylloc; ])[ static int yygetc (LEX_FORMALS) { int res = getc (yyin); USE_LEX_ARGS; ]AT_LOCATION_IF([ last_yylloc = LOC; if (res == '\n') { LOC.last_line++; LOC.last_column = 1; } else LOC.last_column++; ])[ return res; } static void yyungetc (LEX_PRE_FORMALS int c) { USE_LEX_ARGS; ]AT_LOCATION_IF([ /* Wrong when C == `\n'. */ LOC = last_yylloc; ])[ ungetc (c, yyin); } static int read_signed_integer (LEX_FORMALS) { int c = yygetc (LEX_ARGS); int sign = 1; int n = 0; USE_LEX_ARGS; if (c == '-') { c = yygetc (LEX_ARGS); sign = -1; } while (isdigit (c)) { n = 10 * n + (c - '0'); c = yygetc (LEX_ARGS); } yyungetc (LEX_PRE_ARGS c); return sign * n; } /*---------------------------------------------------------------. | Lexical analyzer returns an integer on the stack and the token | | NUM, or the ASCII character read if not a number. Skips all | | blanks and tabs, returns 0 for EOF. | `---------------------------------------------------------------*/ static int yylex (LEX_FORMALS) { static int init = 1; int c; if (init) { init = 0; ]AT_LOCATION_IF([ LOC.last_column = 1; LOC.last_line = 1; ])[ } ]AT_LOCATION_IF([ LOC.first_column = LOC.last_column; LOC.first_line = LOC.last_line; ])[ /* Skip white space. */ while ((c = yygetc (LEX_ARGS)) == ' ' || c == '\t') { ]AT_LOCATION_IF([ LOC.first_column = LOC.last_column; LOC.first_line = LOC.last_line; ])[ } /* process numbers */ if (c == '.' || isdigit (c)) { yyungetc (LEX_PRE_ARGS c); VAL.ival = read_signed_integer (LEX_ARGS); return NUM; } /* Return end-of-file. */ if (c == EOF) return CALC_EOF; /* Return single chars. */ return c; } static int power (int base, int exponent) { int res = 1; if (exponent < 0) exit (1); for (/* Niente */; exponent; --exponent) res *= base; return res; } int main (int argc, const char **argv) { value_t result = 0; int count = 0; int status; if (argc == 2) yyin = fopen (argv[1], "r"); else yyin = stdin; if (!yyin) { perror (argv[1]); exit (1); } #if YYDEBUG yydebug = 1; #endif status = yyparse (]AT_PARAM_IF([&result, &count])[); if (global_result != result) abort (); if (global_count != count) abort (); return status; } ]]) ])# _AT_DATA_CALC_Y # AT_DATA_CALC_Y([BISON-OPTIONS]) # ------------------------------- # Produce `calc.y'. m4_define([AT_DATA_CALC_Y], [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1]) ]) # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES = 0]) # ------------------------------------------------------------ # Run `calc' on INPUT and expect no STDOUT nor STDERR. # # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then # NUM-STDERR-LINES is the number of expected lines on stderr. # # We don't count GLR's traces yet, since its traces are somewhat # different from LALR's. m4_define([_AT_CHECK_CALC], [AT_DATA([[input]], [[$2 ]]) AT_PARSER_CHECK([./calc input], 0, [], [stderr]) m4_bmatch([$1], [%debug.*%glr\|%glr.*%debug], [], [%debug], [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3 ])]) ]) # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT, # [NUM-DEBUG-LINES], # [VERBOSE-AND-LOCATED-ERROR-MESSAGE]) # --------------------------------------------------------- # Run `calc' on INPUT, and expect a `syntax error' message. # # If INPUT starts with a slash, it is used as absolute input file name, # otherwise as contents. # # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION # is correctly output on stderr. # # If BISON-OPTIONS contains `%error-verbose', then make sure the # IF-YYERROR-VERBOSE message is properly output after `syntax error, ' # on STDERR. # # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES # is the number of expected lines on stderr. m4_define([_AT_CHECK_CALC_ERROR], [m4_bmatch([$3], [^/], [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])], [AT_DATA([[input]], [[$3 ]]) AT_PARSER_CHECK([./calc input], $2, [], [stderr])]) m4_bmatch([$1], [%debug.*%glr\|%glr.*%debug], [], [%debug], [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$4 ])]) # Normalize the observed and expected error messages, depending upon the # options. # 1. Remove the traces from observed. sed '/^Starting/d /^Entering/d /^Stack/d /^Reading/d /^Reducing/d /^Shifting/d /^state/d /^Error:/d /^Next/d /^Discarding/d /^yydestructor:/d' stderr >at-stderr mv at-stderr stderr # 2. Create the reference error message. AT_DATA([[expout]], [$5 ]) # 3. If locations are not used, remove them. AT_YYERROR_SEES_LOC_IF([], [[sed 's/^[-0-9.]*: //' expout >at-expout mv at-expout expout]]) # 4. If error-verbose is not used, strip the`, unexpected....' part. m4_bmatch([$1], [%error-verbose], [], [[sed 's/syntax error, .*$/syntax error/' expout >at-expout mv at-expout expout]]) # 5. Check AT_CHECK([cat stderr], 0, [expout]) ]) # AT_CALC_PUSHDEFS($1, $2, [BISON-OPTIONS]) # ----------------------------------------- # This macro works around the impossibility to define macros # inside macros, because issuing `[$1]' is not possible in M4 :(. # This sucks hard, GNU M4 should really provide M5 like $$1. m4_define([AT_CHECK_PUSHDEFS], [m4_if([$1$2], $[1]$[2], [], [m4_fatal([$0: Invalid arguments: $@])])dnl m4_pushdef([AT_PARAM_IF], [m4_bmatch([$3], [%parse-param], [$1], [$2])]) m4_pushdef([AT_LOCATION_IF], [m4_bmatch([$3], [%locations], [$1], [$2])]) m4_pushdef([AT_PURE_IF], [m4_bmatch([$3], [%pure-parser], [$1], [$2])]) m4_pushdef([AT_GLR_IF], [m4_bmatch([$3], [%glr-parser], [$1], [$2])]) m4_pushdef([AT_PURE_AND_LOC_IF], [m4_bmatch([$3], [%locations.*%pure-parser\|%pure-parser.*%locations], [$1], [$2])]) m4_pushdef([AT_GLR_OR_PARAM_IF], [m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])]) # yyerror receives the location if %location & %pure & (%glr or %parse-param). m4_pushdef([AT_YYERROR_ARG_LOC_IF], [AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])], [$2])]) # yyerror cannot see the locations if !glr & pure & !param. m4_pushdef([AT_YYERROR_SEES_LOC_IF], [AT_LOCATION_IF([AT_GLR_IF([$1], [AT_PURE_IF([AT_PARAM_IF([$1], [$2])], [$1])])], [$2])]) ]) # AT_CALC_POPDEFS # --------------- m4_define([AT_CHECK_POPDEFS], [m4_popdef([AT_YYERROR_SEES_LOC_IF]) m4_popdef([AT_YYERROR_ARG_LOC_IF]) m4_popdef([AT_GLR_OR_PARAM_IF]) m4_popdef([AT_PURE_AND_LOC_IF]) m4_popdef([AT_GLR_IF]) m4_popdef([AT_LOCATION_IF]) m4_popdef([AT_PARAM_IF]) ]) # AT_CHECK_CALC([BISON-OPTIONS]) # ------------------------------ # Start a testing chunk which compiles `calc' grammar with # BISON-OPTIONS, and performs several tests over the parser. m4_define([AT_CHECK_CALC], [# We use integers to avoid dependencies upon the precision of doubles. AT_SETUP([Calculator $1]) AT_CHECK_PUSHDEFS($[1], $[2], [$1]) AT_DATA_CALC_Y([$1]) # Specify the output files to avoid problems on different file systems. AT_CHECK([bison -o calc.c calc.y], [0], [], []) AT_COMPILE([calc]) # Test the priorities. _AT_CHECK_CALC([$1], [1 + 2 * 3 = 7 1 + 2 * -3 = -5 -1^2 = -1 (-1)^2 = 1 ---1 = -1 1 - 2 - 3 = -4 1 - (2 - 3) = 2 2^2^3 = 256 (2^2)^3 = 64], [486]) # Some syntax errors. _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [11], [1.3-1.4: syntax error, unexpected "number"]) _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [15], [1.3-1.4: syntax error, unexpected '/', expecting "number" or '-' or '(']) _AT_CHECK_CALC_ERROR([$1], [1], [error], [4], [1.1-1.2: syntax error, unexpected $undefined, expecting "number" or '-' or '\n' or '(']) _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [22], [1.7-1.8: syntax error, unexpected '=']) _AT_CHECK_CALC_ERROR([$1], [1], [ +1], [14], [2.1-2.2: syntax error, unexpected '+']) # Exercise error messages with EOF: work on an empty file. _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4], [1.1-1.2: syntax error, unexpected "end of input", expecting "number" or '-' or '\n' or '(']) # Exercise the error token: without it, we die at the first error, # hence be sure i. to have several errors, ii. to test the action # associated to `error'. _AT_CHECK_CALC_ERROR([$1], [0], [(1 ++ 2) + (0 0) = 1], [82], [1.5-1.6: syntax error, unexpected '+', expecting "number" or '-' or '(' 1.15-1.16: syntax error, unexpected "number" calc: error: 0 != 1]) AT_CHECK_POPDEFS AT_CLEANUP ])# AT_CHECK_CALC # ------------------------ # # Simple LALR Calculator. # # ------------------------ # AT_BANNER([[Simple LALR Calculator.]]) # AT_CHECK_CALC_LALR([BISON-OPTIONS]) # ----------------------------------- # Start a testing chunk which compiles `calc' grammar with # BISON-OPTIONS, and performs several tests over the parser. m4_define([AT_CHECK_CALC_LALR], [AT_CHECK_CALC($@)]) AT_CHECK_CALC_LALR() AT_CHECK_CALC_LALR([%defines]) AT_CHECK_CALC_LALR([%locations]) AT_CHECK_CALC_LALR([%name-prefix="calc"]) AT_CHECK_CALC_LALR([%verbose]) AT_CHECK_CALC_LALR([%yacc]) AT_CHECK_CALC_LALR([%error-verbose]) AT_CHECK_CALC_LALR([%error-verbose %locations]) AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc]) AT_CHECK_CALC_LALR([%debug]) AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc]) AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc]) AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value_t *result}, {result} %parse-param {int *count}, {count}]) # ----------------------- # # Simple GLR Calculator. # # ----------------------- # AT_BANNER([[Simple GLR Calculator.]]) # AT_CHECK_CALC_GLR([BISON-OPTIONS]) # ---------------------------------- # Start a testing chunk which compiles `calc' grammar with # BISON-OPTIONS and %glr-parser, and performs several tests over the parser. m4_define([AT_CHECK_CALC_GLR], [AT_CHECK_CALC([%glr-parser] $@)]) AT_CHECK_CALC_GLR() AT_CHECK_CALC_GLR([%defines]) AT_CHECK_CALC_GLR([%locations]) AT_CHECK_CALC_GLR([%name-prefix="calc"]) AT_CHECK_CALC_GLR([%verbose]) AT_CHECK_CALC_GLR([%yacc]) AT_CHECK_CALC_GLR([%error-verbose]) AT_CHECK_CALC_GLR([%error-verbose %locations]) AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc]) AT_CHECK_CALC_GLR([%debug]) AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc]) AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc]) AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value_t *result}, {result} %parse-param {int *count}, {count}])