1/* Open and close files for Bison. 2 3 Copyright (C) 1984, 1986, 1989, 1992, 2000-2012 Free Software 4 Foundation, Inc. 5 6 This file is part of Bison, the GNU Compiler Compiler. 7 8 This program is free software: you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation, either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21#include <config.h> 22#include "system.h" 23 24#include <error.h> 25#include <dirname.h> 26#include <get-errno.h> 27#include <quote.h> 28#include <quotearg.h> 29#include <stdio-safer.h> 30#include <xstrndup.h> 31 32#include "complain.h" 33#include "files.h" 34#include "getargs.h" 35#include "gram.h" 36 37/* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is 38 tempting, but don't do that: for the time being our handling of the 39 %directive vs --option leaves precedence to the options by deciding 40 that if a %directive sets a variable which is really set (i.e., not 41 NULL), then the %directive is ignored. As a result, %name-prefix, 42 for instance, will not be honored. */ 43 44char const *spec_outfile = NULL; /* for -o. */ 45char const *spec_file_prefix = NULL; /* for -b. */ 46char const *spec_name_prefix = NULL; /* for -p. */ 47char *spec_verbose_file = NULL; /* for --verbose. */ 48char *spec_graph_file = NULL; /* for -g. */ 49char *spec_xml_file = NULL; /* for -x. */ 50char *spec_defines_file = NULL; /* for --defines. */ 51char *parser_file_name; 52 53/* All computed output file names. */ 54static char **file_names = NULL; 55static int file_names_count = 0; 56 57uniqstr grammar_file = NULL; 58uniqstr current_file = NULL; 59 60/* If --output=dir/foo.c was specified, 61 DIR_PREFIX is `dir/' and ALL_BUT_EXT and ALL_BUT_TAB_EXT are `dir/foo'. 62 63 If --output=dir/foo.tab.c was specified, DIR_PREFIX is `dir/', 64 ALL_BUT_EXT is `dir/foo.tab', and ALL_BUT_TAB_EXT is `dir/foo'. 65 66 If --output was not specified but --file-prefix=dir/foo was specified, 67 ALL_BUT_EXT = `foo.tab' and ALL_BUT_TAB_EXT = `foo'. 68 69 If neither --output nor --file was specified but the input grammar 70 is name dir/foo.y, ALL_BUT_EXT and ALL_BUT_TAB_EXT are `foo'. 71 72 If neither --output nor --file was specified, DIR_PREFIX is the 73 empty string (meaning the current directory); otherwise it is 74 `dir/'. */ 75 76char *all_but_ext; 77static char *all_but_tab_ext; 78char *dir_prefix; 79 80/* C source file extension (the parser source). */ 81static char *src_extension = NULL; 82/* Header file extension (if option ``-d'' is specified). */ 83static char *header_extension = NULL; 84 85/*-----------------------------------------------------------------. 86| Return a newly allocated string composed of the concatenation of | 87| STR1, and STR2. | 88`-----------------------------------------------------------------*/ 89 90static char * 91concat2 (char const *str1, char const *str2) 92{ 93 size_t len = strlen (str1) + strlen (str2); 94 char *res = xmalloc (len + 1); 95 char *cp; 96 cp = stpcpy (res, str1); 97 cp = stpcpy (cp, str2); 98 return res; 99} 100 101/*-----------------------------------------------------------------. 102| Try to open file NAME with mode MODE, and print an error message | 103| if fails. | 104`-----------------------------------------------------------------*/ 105 106FILE * 107xfopen (const char *name, const char *mode) 108{ 109 FILE *ptr; 110 111 ptr = fopen_safer (name, mode); 112 if (!ptr) 113 error (EXIT_FAILURE, get_errno (), 114 _("%s: cannot open"), quotearg_colon (name)); 115 116 return ptr; 117} 118 119/*-------------------------------------------------------------. 120| Try to close file PTR, and print an error message if fails. | 121`-------------------------------------------------------------*/ 122 123void 124xfclose (FILE *ptr) 125{ 126 if (ptr == NULL) 127 return; 128 129 if (ferror (ptr)) 130 error (EXIT_FAILURE, 0, _("input/output error")); 131 132 if (fclose (ptr) != 0) 133 error (EXIT_FAILURE, get_errno (), _("cannot close file")); 134} 135 136 137/*------------------------------------------------------------------. 138| Compute ALL_BUT_EXT, ALL_BUT_TAB_EXT and output files extensions. | 139`------------------------------------------------------------------*/ 140 141/* Compute extensions from the grammar file extension. */ 142static void 143compute_exts_from_gf (const char *ext) 144{ 145 if (strcmp (ext, ".y") == 0) 146 { 147 src_extension = xstrdup (language->src_extension); 148 header_extension = xstrdup (language->header_extension); 149 } 150 else 151 { 152 src_extension = xstrdup (ext); 153 header_extension = xstrdup (ext); 154 tr (src_extension, 'y', 'c'); 155 tr (src_extension, 'Y', 'C'); 156 tr (header_extension, 'y', 'h'); 157 tr (header_extension, 'Y', 'H'); 158 } 159} 160 161/* Compute extensions from the given c source file extension. */ 162static void 163compute_exts_from_src (const char *ext) 164{ 165 /* We use this function when the user specifies `-o' or `--output', 166 so the extenions must be computed unconditionally from the file name 167 given by this option. */ 168 src_extension = xstrdup (ext); 169 header_extension = xstrdup (ext); 170 tr (header_extension, 'c', 'h'); 171 tr (header_extension, 'C', 'H'); 172} 173 174 175/* Decompose FILE_NAME in four parts: *BASE, *TAB, and *EXT, the fourth 176 part, (the directory) is ranging from FILE_NAME to the char before 177 *BASE, so we don't need an additional parameter. 178 179 *EXT points to the last period in the basename, or NULL if none. 180 181 If there is no *EXT, *TAB is NULL. Otherwise, *TAB points to 182 `.tab' or `_tab' if present right before *EXT, or is NULL. *TAB 183 cannot be equal to *BASE. 184 185 None are allocated, they are simply pointers to parts of FILE_NAME. 186 Examples: 187 188 '/tmp/foo.tab.c' -> *BASE = 'foo.tab.c', *TAB = '.tab.c', *EXT = 189 '.c' 190 191 'foo.c' -> *BASE = 'foo.c', *TAB = NULL, *EXT = '.c' 192 193 'tab.c' -> *BASE = 'tab.c', *TAB = NULL, *EXT = '.c' 194 195 '.tab.c' -> *BASE = '.tab.c', *TAB = NULL, *EXT = '.c' 196 197 'foo.tab' -> *BASE = 'foo.tab', *TAB = NULL, *EXT = '.tab' 198 199 'foo_tab' -> *BASE = 'foo_tab', *TAB = NULL, *EXT = NULL 200 201 'foo' -> *BASE = 'foo', *TAB = NULL, *EXT = NULL. */ 202 203static void 204file_name_split (const char *file_name, 205 const char **base, const char **tab, const char **ext) 206{ 207 *base = last_component (file_name); 208 209 /* Look for the extension, i.e., look for the last dot. */ 210 *ext = mbsrchr (*base, '.'); 211 *tab = NULL; 212 213 /* If there is an extension, check if there is a `.tab' part right 214 before. */ 215 if (*ext) 216 { 217 size_t baselen = *ext - *base; 218 size_t dottablen = 4; 219 if (dottablen < baselen 220 && (strncmp (*ext - dottablen, ".tab", dottablen) == 0 221 || strncmp (*ext - dottablen, "_tab", dottablen) == 0)) 222 *tab = *ext - dottablen; 223 } 224} 225 226 227static void 228compute_file_name_parts (void) 229{ 230 const char *base, *tab, *ext; 231 232 /* Compute ALL_BUT_EXT and ALL_BUT_TAB_EXT from SPEC_OUTFILE 233 or GRAMMAR_FILE. 234 235 The precise -o name will be used for FTABLE. For other output 236 files, remove the ".c" or ".tab.c" suffix. */ 237 if (spec_outfile) 238 { 239 file_name_split (spec_outfile, &base, &tab, &ext); 240 dir_prefix = xstrndup (spec_outfile, base - spec_outfile); 241 242 /* ALL_BUT_EXT goes up the EXT, excluding it. */ 243 all_but_ext = 244 xstrndup (spec_outfile, 245 (strlen (spec_outfile) - (ext ? strlen (ext) : 0))); 246 247 /* ALL_BUT_TAB_EXT goes up to TAB, excluding it. */ 248 all_but_tab_ext = 249 xstrndup (spec_outfile, 250 (strlen (spec_outfile) 251 - (tab ? strlen (tab) : (ext ? strlen (ext) : 0)))); 252 253 if (ext) 254 compute_exts_from_src (ext); 255 } 256 else 257 { 258 file_name_split (grammar_file, &base, &tab, &ext); 259 260 if (spec_file_prefix) 261 { 262 /* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT = `foo'. */ 263 dir_prefix = 264 xstrndup (spec_file_prefix, 265 last_component (spec_file_prefix) - spec_file_prefix); 266 all_but_tab_ext = xstrdup (spec_file_prefix); 267 } 268 else if (yacc_flag) 269 { 270 /* If --yacc, then the output is `y.tab.c'. */ 271 dir_prefix = xstrdup (""); 272 all_but_tab_ext = xstrdup ("y"); 273 } 274 else 275 { 276 /* Otherwise, ALL_BUT_TAB_EXT is computed from the input 277 grammar: `foo/bar.yy' => `bar'. */ 278 dir_prefix = xstrdup (""); 279 all_but_tab_ext = 280 xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0))); 281 } 282 283 if (language->add_tab) 284 all_but_ext = concat2 (all_but_tab_ext, TAB_EXT); 285 else 286 all_but_ext = xstrdup (all_but_tab_ext); 287 288 /* Compute the extensions from the grammar file name. */ 289 if (ext && !yacc_flag) 290 compute_exts_from_gf (ext); 291 } 292} 293 294 295/* Compute the output file names. Warn if we detect conflicting 296 outputs to the same file. */ 297 298void 299compute_output_file_names (void) 300{ 301 compute_file_name_parts (); 302 303 /* If not yet done. */ 304 if (!src_extension) 305 src_extension = xstrdup (".c"); 306 if (!header_extension) 307 header_extension = xstrdup (".h"); 308 309 parser_file_name = 310 (spec_outfile 311 ? xstrdup (spec_outfile) 312 : concat2 (all_but_ext, src_extension)); 313 314 if (defines_flag) 315 { 316 if (! spec_defines_file) 317 spec_defines_file = concat2 (all_but_ext, header_extension); 318 } 319 320 if (graph_flag) 321 { 322 if (! spec_graph_file) 323 spec_graph_file = concat2 (all_but_tab_ext, ".dot"); 324 output_file_name_check (&spec_graph_file); 325 } 326 327 if (xml_flag) 328 { 329 if (! spec_xml_file) 330 spec_xml_file = concat2 (all_but_tab_ext, ".xml"); 331 output_file_name_check (&spec_xml_file); 332 } 333 334 if (report_flag) 335 { 336 if (!spec_verbose_file) 337 spec_verbose_file = concat2 (all_but_tab_ext, OUTPUT_EXT); 338 output_file_name_check (&spec_verbose_file); 339 } 340 341 free (all_but_tab_ext); 342 free (src_extension); 343 free (header_extension); 344} 345 346void 347output_file_name_check (char **file_name) 348{ 349 bool conflict = false; 350 if (0 == strcmp (*file_name, grammar_file)) 351 { 352 complain (_("refusing to overwrite the input file %s"), 353 quote (*file_name)); 354 conflict = true; 355 } 356 else 357 { 358 int i; 359 for (i = 0; i < file_names_count; i++) 360 if (0 == strcmp (file_names[i], *file_name)) 361 { 362 warn (_("conflicting outputs to file %s"), 363 quote (*file_name)); 364 conflict = true; 365 } 366 } 367 if (conflict) 368 { 369 free (*file_name); 370 *file_name = strdup ("/dev/null"); 371 } 372 else 373 { 374 file_names = xnrealloc (file_names, ++file_names_count, 375 sizeof *file_names); 376 file_names[file_names_count-1] = xstrdup (*file_name); 377 } 378} 379 380void 381output_file_names_free (void) 382{ 383 free (all_but_ext); 384 free (spec_verbose_file); 385 free (spec_graph_file); 386 free (spec_xml_file); 387 free (spec_defines_file); 388 free (parser_file_name); 389 free (dir_prefix); 390 { 391 int i; 392 for (i = 0; i < file_names_count; i++) 393 free (file_names[i]); 394 } 395 free (file_names); 396} 397