src/files.c

   1 /* Open and close files for bison,
   2    Copyright 1984, 1986, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.
   3
   4    This file is part of Bison, the GNU Compiler Compiler.
   5
   6    Bison is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    Bison is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with Bison; see the file COPYING.  If not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19    02111-1307, USA.  */
  20
  21
  22 #include "system.h"
  23 #include "getargs.h"
  24 #include "files.h"
  25 #include "gram.h"
  26 #include "error.h"
  27 #include "complain.h"
  28
  29 /* From basename.c.  Almost a lie, as it returns a char *. */
  30 const char *base_name PARAMS ((char const *name));
  31
  32 FILE *finput = NULL;
  33
  34 struct obstack action_obstack;
  35 struct obstack attrs_obstack;
  36 struct obstack output_obstack;
  37
  38 /* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is
  39    tempting, but don't do that: for the time being our handling of the
  40    %directive vs --option leaves precedence to the options by deciding
  41    that if a %directive sets a variable which is really set (i.e., not
  42    NULL), then the %directive is ignored.  As a result, %name-prefix,
  43    for instance, will not be honored.  */
  44
  45 char *spec_outfile = NULL;      /* for -o. */
  46 char *spec_file_prefix = NULL;  /* for -b. */
  47 const char *spec_name_prefix = NULL;    /* for -p. */
  48 char *spec_verbose_file = NULL;   /* for --verbose. */
  49 char *spec_graph_file = NULL;   /* for -g. */
  50 char *spec_defines_file = NULL; /* for --defines. */
  51 char *parser_file_name = NULL;
  52
  53 char *infile = NULL;
  54 char *attrsfile = NULL;
  55
  56 static char *full_base_name = NULL;
  57 char *short_base_name = NULL;
  58
  59 /* C source file extension (the parser source).  */
  60 const char *src_extension = NULL;
  61 /* Header file extension (if option ``-d'' is specified).  */
  62 const char *header_extension = NULL;
  63
  64 /* Should we insert '.tab' in yacc-compatible parsers?  */
  65 int tab_extension = 0;
  66 \f
  67
  68 /*--------------------------.
  69 | Is SUFFIX ending STRING?  |
  70 `--------------------------*/
  71
  72 int
  73 strsuffix (const char *string, const char *suffix)
  74 {
  75   size_t string_len = strlen (string);
  76   size_t suffix_len = strlen (suffix);
  77   if (suffix_len <= string_len)
  78     return !strcmp (string + string_len - suffix_len, suffix);
  79   else
  80     return 0;
  81 }
  82
  83
  84 /*-----------------------------------------------------------------.
  85 | Return a newly allocated string composed of the concatenation of |
  86 | STRING1, and STRING2.                                            |
  87 `-----------------------------------------------------------------*/
  88
  89 char*
  90 stringappend (const char *string1, const char *string2)
  91 {
  92   size_t len = strlen (string1) + strlen (string2);
  93   char *res = XMALLOC (char, len + 1);
  94   char *cp;
  95   cp = stpcpy (res, string1);
  96   cp = stpcpy (cp, string2);
  97   return res;
  98 }
  99
 100
 101 /*-----------------------------------------------------------------.
 102 | Computes the macro name used to avoid double inclusion in the    |
 103 | header of the parser and store it in header_macro_name.  Be sure |
 104 | to produce valid CPP names (don't start with digit, remain       |
 105 | alphanumerical + underscore).                                    |
 106 `-----------------------------------------------------------------*/
 107
 108 char *
 109 compute_header_macro (void)
 110 {
 111   const char *prefix = "BISON_";
 112   char *macro_name, *cp;
 113
 114   if (spec_defines_file)
 115     {
 116       macro_name = XMALLOC (char,
 117                             strlen (prefix) +
 118                             strlen (spec_defines_file) + 1);
 119       cp = stpcpy (macro_name, prefix);
 120       cp = stpcpy (cp, spec_defines_file);
 121     }
 122   else
 123     {
 124       macro_name = XMALLOC (char,
 125                             strlen (prefix) +
 126                             strlen (full_base_name) +
 127                             strlen (header_extension) + 1);
 128       cp = stpcpy (macro_name, prefix);
 129       cp = stpcpy (cp, full_base_name);
 130       cp = stpcpy (cp, header_extension);
 131     }
 132
 133   for (cp = macro_name; *cp; ++cp)
 134     if (islower (*cp))
 135       *cp = toupper (*cp);
 136     else if (!isalnum (*cp))
 137       *cp = '_';
 138
 139   return macro_name;
 140 }
 141
 142
 143 /*-----------------------------------------------------------------.
 144 | Try to open file NAME with mode MODE, and print an error message |
 145 | if fails.                                                        |
 146 `-----------------------------------------------------------------*/
 147
 148 FILE *
 149 xfopen (const char *name, const char *mode)
 150 {
 151   FILE *ptr;
 152
 153   ptr = fopen (name, mode);
 154   if (!ptr)
 155     error (2, errno, _("cannot open file `%s'"), name);
 156
 157   return ptr;
 158 }
 159
 160 /*-------------------------------------------------------------.
 161 | Try to close file PTR, and print an error message if fails.  |
 162 `-------------------------------------------------------------*/
 163
 164 int
 165 xfclose (FILE *ptr)
 166 {
 167   int result;
 168
 169   if (ptr == NULL)
 170     return 0;
 171
 172   result = fclose (ptr);
 173   if (result == EOF)
 174     error (2, errno, _("cannot close file"));
 175
 176   return result;
 177 }
 178
 179
 180 /*------------------------------------------------------------------.
 181 | Return the path to the skeleton which locaction might be given in |
 182 | ENVVAR, otherwise return SKELETON_NAME.                           |
 183 `------------------------------------------------------------------*/
 184
 185 const char *
 186 skeleton_find (const char *envvar, const char *skeleton_name)
 187 {
 188   const char *res = getenv (envvar);
 189
 190 #if defined (MSDOS) || defined (_WIN32)
 191   if (!res)
 192     {
 193       /* Skeleton file name without path */
 194       const char *skel_name = strrchr (skeleton_name, '/');
 195       if (!skel_name)
 196         skel_name = strrchr (skeleton_name, '\\');
 197       if (!skel_name)
 198         skel_name = skeleton_name;
 199       else
 200         ++skel_name;
 201
 202       /* File doesn't exist in current directory; try in INIT directory.  */
 203       const char *cp = getenv ("INIT");
 204       if (cp)
 205         {
 206           res = XMALLOC (char, strlen (cp) + strlen (skel_name) + 2);
 207           sprintf (res, "%s%c%s", cp, '\\', skel_name);
 208         }
 209       else if (access (skel_name, 4) == 0) /* Look in current dir. */
 210         res = skel_name;
 211       else
 212         {
 213           /* Look in program locations dir. */
 214           extern char *program_name;
 215           cp = strrchr(program_name, '\\');
 216           if (!cp)
 217             return skeleton_name;
 218           else
 219             ++cp;
 220           res = XMALLOC (char, cp - program_name + strlen (skel_name) + 1);
 221           strncpy (res, program_name, cp - program_name);
 222           strcpy (res + (cp - program_name), skel_name);
 223         }
 224     }
 225 #endif /* defined (MSDOS) || defined (_WIN32) */
 226   if (!res)
 227     res = skeleton_name;
 228
 229   return res;
 230 }
 231 \f
 232
 233 /*----------------------------------------------------------------.
 234 | Compute BASE_NAME, SHORT_BASE_NAME and output files extensions. |
 235 `----------------------------------------------------------------*/
 236
 237 /* Replace all characters FROM by TO in the string IN.
 238    and returns a new allocated string.  */
 239 static char *
 240 tr (const char *in, char from, char to)
 241 {
 242   char *temp;
 243   char *out;
 244
 245   out = XMALLOC (char, strlen (in) + 1);
 246
 247   for (temp = out; *in; in++, out++)
 248     if (*in == from)
 249       *out = to;
 250     else
 251       *out = *in;
 252   *out = 0;
 253   return (temp);
 254 }
 255
 256 /* Gets the extension index in FILENAME. Returns 0 if fails to
 257    find an extension.  */
 258 static int
 259 get_extension_index (const char *filename)
 260 {
 261   int len;
 262
 263   len = strlen (filename);
 264
 265   if (filename[len-- - 1] == '.')
 266     return (0);
 267
 268   while ((len > 0) && (filename[len - 1] != '.'))
 269     if (filename[len - 1] == '/')
 270       return (0);
 271     else
 272       len--;
 273
 274   return (len - 1);
 275 }
 276
 277 /* Computes extensions from the grammar file extension. */
 278 static void
 279 compute_exts_from_gf (const char *ext)
 280 {
 281   src_extension = tr (ext, 'y', 'c');
 282   src_extension = tr (src_extension, 'Y', 'C');
 283   header_extension = tr (ext, 'y', 'h');
 284   header_extension = tr (header_extension, 'Y', 'H');
 285 }
 286
 287 /* Computes extensions from the given c source file extension. */
 288 static void
 289 compute_exts_from_src (const char *ext)
 290 {
 291   /* We use this function when the user specifies `-o' or `--output',
 292      so the extenions must be computed unconditionally from the file name
 293      given by this option.  */
 294   src_extension = xstrdup (ext);
 295   header_extension = tr (ext, 'c', 'h');
 296   header_extension = tr (header_extension, 'C', 'H');
 297 }
 298
 299
 300 /* Decompose FILENAME in four parts: *BASE, *TAB, and *EXT, the fourth
 301    part, (the directory) is ranging from FILENAME to the char before
 302    *BASE, so we don't need an additional parameter.
 303
 304    *EXT points to the last period in the basename, or NULL if none.
 305
 306    If there is no *EXT, *TAB is NULL.  Otherwise, *TAB points to
 307    `.tab' or `_tab' if present right before *EXT, or is NULL. *TAB
 308    cannot be equal to *BASE.
 309
 310    None are allocated, they are simply pointers to parts of FILENAME.
 311    Examples:
 312
 313    '/tmp/foo.tab.c' -> *BASE = 'foo.tab.c', *TAB = '.tab.c', *EXT =
 314    '.c'
 315
 316    'foo.c' -> *BASE = 'foo.c', *TAB = NULL, *EXT = '.c'
 317
 318    'tab.c' -> *BASE = 'tab.c', *TAB = NULL, *EXT = '.c'
 319
 320    '.tab.c' -> *BASE = '.tab.c', *TAB = NULL, *EXT = '.c'
 321
 322    'foo.tab' -> *BASE = 'foo.tab', *TAB = NULL, *EXT = '.tab'
 323
 324    'foo_tab' -> *BASE = 'foo_tab', *TAB = NULL, *EXT = NULL
 325
 326    'foo' -> *BASE = 'foo', *TAB = NULL, *EXT = NULL.  */
 327
 328 static void
 329 filename_split (const char *filename,
 330                 const char **base, const char **tab, const char **ext)
 331 {
 332   *base = base_name (filename);
 333
 334   /* Look for the extension, i.e., look for the last dot. */
 335   *ext = strrchr (*base, '.');
 336   *tab = NULL;
 337
 338   /* If there is an exentension, check if there is a `.tab' part right
 339      before.  */
 340   if (*ext
 341       && (*ext - *base) > strlen (".tab")
 342       && (!strncmp (*ext - strlen (".tab"), ".tab", strlen (".tab"))
 343           || !strncmp (*ext - strlen ("_tab"), "_tab", strlen ("_tab"))))
 344     *tab = *ext - strlen (".tab");
 345 }
 346
 347
 348 /* FIXME: Should use xstrndup. */
 349
 350 static void
 351 compute_base_names (void)
 352 {
 353   const char *base, *tab, *ext;
 354   size_t base_length;
 355   size_t short_base_length;
 356   size_t ext_index;
 357
 358   /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
 359      BASE_NAME and SHORT_BASE_NAME are `foo'.
 360
 361      If --output=foo.tab.c was specified, BASE_NAME is `foo.tab' and
 362      SHORT_BASE_NAME is `foo'.
 363
 364      The precise -o name will be used for FTABLE.  For other output
 365      files, remove the ".c" or ".tab.c" suffix.  */
 366   if (spec_outfile)
 367     {
 368       const char *cp;
 369       filename_split (spec_outfile, &base, &tab, &ext);
 370
 371       /* The full base name goes up the EXT, excluding it. */
 372       full_base_name =
 373         xstrndup (spec_outfile,
 374                   (strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
 375       /* The short base name goes up to TAB, excluding it.  */
 376       short_base_name =
 377         xstrndup (spec_outfile,
 378                   (strlen (spec_outfile)
 379                    - (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
 380
 381       /* Do we have a tab part? */
 382       tab_extension = !!tab;
 383
 384       if (ext)
 385         compute_exts_from_src (ext);
 386     }
 387
 388   /* If --file-prefix=foo was specified, FULL_BASE_NAME = `foo.tab'
 389      and SHORT_BASE_NAME = `foo'.
 390
 391      Construct names from it.  */
 392   else
 393     {
 394       if (spec_file_prefix)
 395         {
 396           /* If --file-prefix=foo was specified, SHORT_BASE_NAME =
 397              `foo'.  */
 398           short_base_name = xstrdup (spec_file_prefix);
 399         }
 400       else if (yacc_flag)
 401         {
 402           /* If --yacc, then the output is `y.tab.c'. */
 403           short_base_name = xstrdup ("y");
 404         }
 405       else
 406         {
 407           /* Otherwise, the short base name is computed from the input
 408              grammar: `foo.yy' => `foo'.  */
 409           filename_split (infile, &base, &tab, &ext);
 410           short_base_name =
 411             xstrndup (infile,
 412                       (strlen (infile) - (ext ? strlen (ext) : 0)));
 413         }
 414
 415       /* In these cases, always append `.tab'. */
 416       tab_extension = 1;
 417       full_base_name = XMALLOC (char,
 418                                 strlen (short_base_name)
 419                                 + strlen (EXT_TAB) + 1);
 420       stpcpy (stpcpy (full_base_name, short_base_name), EXT_TAB);
 421
 422       /* Computes the extensions from the grammar file name.  */
 423       filename_split (infile, &base, &tab, &ext);
 424       if (ext)
 425         compute_exts_from_gf (ext);
 426     }
 427 }
 428
 429 /*-------------------------------------------------------.
 430 | Close the open files, compute the output files names.  |
 431 `-------------------------------------------------------*/
 432
 433 void
 434 compute_output_file_names (void)
 435 {
 436   compute_base_names ();
 437
 438   parser_file_name =
 439     spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);
 440
 441   /* If not yet done. */
 442   if (!src_extension)
 443     src_extension = ".c";
 444   if (!header_extension)
 445     header_extension = ".h";
 446
 447   /* It the defines filename if not given, we create it.  */
 448   if (!spec_defines_file)
 449     spec_defines_file = stringappend (full_base_name, header_extension);
 450
 451   /* It the graph filename if not given, we create it.  */
 452   if (!spec_graph_file)
 453     spec_graph_file = stringappend (short_base_name, ".vcg");
 454
 455   spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
 456
 457   attrsfile = stringappend (short_base_name, EXT_STYPE_H);
 458 }