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