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