src/files.c

   1 /* Open and close files for bison,
   2    Copyright 1984, 1986, 1989, 1992, 2000 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 "xalloc.h"
  26 #include "gram.h"
  27 #include "complain.h"
  28
  29 FILE *finput = NULL;
  30 FILE *foutput = NULL;
  31 FILE *fguard = NULL;
  32
  33 struct obstack action_obstack;
  34 struct obstack attrs_obstack;
  35 struct obstack table_obstack;
  36 struct obstack defines_obstack;
  37
  38 /* File name specified with -o for the output file, or 0 if no -o.  */
  39 char *spec_outfile;
  40
  41 char *infile;
  42 char *attrsfile;
  43 char *guardfile;
  44
  45 static char *outfile;
  46 static char *defsfile;
  47 static char *tabfile;
  48 static char *actfile;
  49 \f
  50 /*--------------------------.
  51 | Is SUFFIX ending STRING?  |
  52 `--------------------------*/
  53
  54 static int
  55 strsuffix (const char *string, const char *suffix)
  56 {
  57   size_t string_len = strlen (string);
  58   size_t suffix_len = strlen (suffix);
  59   if (suffix_len <= string_len)
  60     return !strcmp (string + string_len - suffix_len, suffix);
  61   else
  62     return 0;
  63 }
  64
  65
  66 /*-----------------------------------------------------------------.
  67 | Return a newly allocated string composed of the concatenation of |
  68 | STRING1, and STRING2.                                            |
  69 `-----------------------------------------------------------------*/
  70
  71 static char *
  72 stringappend (const char *string1, const char *string2)
  73 {
  74   size_t len = strlen (string1) + strlen (string2);
  75   char *res = XMALLOC (char, len + 1);
  76   char *cp;
  77   cp = stpcpy (res, string1);
  78   cp = stpcpy (cp, string2);
  79   return res;
  80 }
  81
  82 /*-----------------------------------------------------------------.
  83 | Try to open file NAME with mode MODE, and print an error message |
  84 | if fails.                                                        |
  85 `-----------------------------------------------------------------*/
  86
  87 FILE *
  88 xfopen (const char *name, const char *mode)
  89 {
  90   FILE *ptr;
  91
  92   ptr = fopen (name, mode);
  93   if (!ptr)
  94     error (2, errno, _("cannot open file `%s'"), name);
  95
  96   return ptr;
  97 }
  98
  99 /*-------------------------------------------------------------.
 100 | Try to close file PTR, and print an error message if fails.  |
 101 `-------------------------------------------------------------*/
 102
 103 int
 104 xfclose (FILE *ptr)
 105 {
 106   int result;
 107
 108   if (ptr == NULL)
 109     return 0;
 110
 111   result = fclose (ptr);
 112   if (result == EOF)
 113     error (2, errno, _("cannot close file"));
 114
 115   return result;
 116 }
 117
 118 /*--------------------------------------------------.
 119 | Save the content of the obstack OBS in FILENAME.  |
 120 `--------------------------------------------------*/
 121
 122 static void
 123 obstack_save (struct obstack *obs, const char *filename)
 124 {
 125   FILE *out = xfopen (filename, "w");
 126   size_t size = obstack_object_size (obs);
 127   fwrite (obstack_finish (obs), 1, size, out);
 128   xfclose (out);
 129 }
 130
 131
 132 /*------------------------------------------------------------------.
 133 | Return the path to the skeleton which locaction might be given in |
 134 | ENVVAR, otherwise return SKELETON.                                |
 135 `------------------------------------------------------------------*/
 136
 137 const char *
 138 skeleton_find (const char *envvar, const char *skeleton)
 139 {
 140   const char *res = getenv (envvar);
 141
 142 #ifdef MSDOS
 143   const char *cp;
 144
 145   /* File doesn't exist in current directory; try in INIT directory.  */
 146   if (!res && (cp = getenv ("INIT")))
 147     {
 148       res = XMALLOC (char, strlen (cp) + strlen (skeleton) + 2);
 149       sprintf (res, "%s%c%s", cp, '/', skeleton);
 150     }
 151 #endif /* !MSDOS */
 152
 153   if (!res)
 154     res = skeleton;
 155
 156   return res;
 157 }
 158
 159 \f
 160 /*----------------------------------------.
 161 | Compute BASE_NAME and SHORT_BASE_NAME.  |
 162 `----------------------------------------*/
 163
 164 /* FIXME: Should use xstrndup. */
 165
 166 static void
 167 base_names (char **base_name, char **short_base_name)
 168 {
 169   size_t base_length;
 170   size_t short_base_length;
 171
 172   /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
 173      BASE_NAME and SHORT_BASE_NAME are `foo'.
 174
 175      If --output=foo.tab.c was specified, BASE_NAME is `foo.tab' and
 176      SHORT_BASE_NAME is `foo'.
 177
 178      The precise -o name will be used for FTABLE.  For other output
 179      files, remove the ".c" or ".tab.c" suffix.  */
 180   if (spec_outfile)
 181     {
 182 #ifdef MSDOS
 183       strlwr (spec_outfile);
 184 #endif /* MSDOS */
 185       /* BASE_LENGTH includes ".tab" but not ".c".  */
 186       base_length = strlen (spec_outfile);
 187       if (strsuffix (spec_outfile, ".c"))
 188         base_length -= 2;
 189       /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
 190       short_base_length = base_length;
 191       if (strsuffix (spec_outfile, ".tab") || strsuffix (spec_outfile, "_tab"))
 192         short_base_length -= 4;
 193       *base_name = strndup (spec_outfile, base_length);
 194       *short_base_name = strndup (spec_outfile, short_base_length);
 195
 196       return;
 197     }
 198
 199   /* If --file-prefix=foo was specified, BASE_NAME and SHORT_BASE_NAME
 200      are `foo'.
 201
 202      Construct names from it.  */
 203   if (spec_file_prefix)
 204     {
 205 #ifdef MSDOS
 206       strlwr (spec_file_prefix);
 207 #endif /* MSDOS */
 208       *short_base_name = xstrdup (spec_file_prefix);
 209
 210       *base_name = XMALLOC (char,
 211                             strlen (*short_base_name) + strlen (EXT_TAB) + 1);
 212       stpcpy (stpcpy (*base_name, *short_base_name), EXT_TAB);
 213
 214       return;
 215     }
 216
 217   /* If neither -o nor --file-prefix were specified, and the input
 218      file is foo.y, BASE_NAME is `foo.tab', and SHORT_BASE_NAME is
 219      `foo'.
 220
 221      If --yacc is used, do as if the input file was `y.y'.  */
 222   {
 223     const char *name_base = yacc_flag ? "y.y" : infile;
 224
 225     /* BASE_LENGTH gets length of BASE_NAME, sans ".y" suffix if any.  */
 226
 227     base_length = strlen (name_base);
 228     if (strsuffix (name_base, ".y"))
 229       base_length -= 2;
 230     short_base_length = base_length;
 231     *short_base_name = strndup (name_base, short_base_length);
 232
 233     *base_name = XMALLOC (char,
 234                           strlen (*short_base_name) + strlen (EXT_TAB) + 1);
 235     stpcpy (stpcpy (*base_name, *short_base_name), EXT_TAB);
 236
 237     return;
 238   }
 239 }
 240
 241 /*-----------------------------------------------------------------.
 242 | Open the input file.  Look for the skeletons.  Find the names of |
 243 | the output files.  Prepare the obstacks.                         |
 244 `-----------------------------------------------------------------*/
 245
 246 void
 247 open_files (void)
 248 {
 249   char *base_name;
 250   char *short_base_name;
 251
 252   base_names (&base_name, &short_base_name);
 253
 254   finput = xfopen (infile, "r");
 255
 256   if (verbose_flag)
 257     {
 258       /* We used to use just .out if spec_name_prefix (-p) was used,
 259          but that conflicts with Posix.  */
 260       outfile = stringappend (base_name, EXT_OUTPUT);
 261       foutput = xfopen (outfile, "w");
 262     }
 263
 264   if (no_parser_flag)
 265     {
 266       /* use permanent name for actions file */
 267       actfile = stringappend (short_base_name, ".act");
 268     }
 269
 270   if (defines_flag)
 271     {
 272       defsfile = stringappend (base_name, ".h");
 273     }
 274
 275   /* These are opened by `done' or `open_extra_files', if at all */
 276   if (spec_outfile)
 277     tabfile = spec_outfile;
 278   else
 279     tabfile = stringappend (base_name, ".c");
 280
 281   attrsfile = stringappend (short_base_name, EXT_STYPE_H);
 282   guardfile = stringappend (short_base_name, EXT_GUARD_C);
 283
 284   /* Initialize the obstacks. */
 285   obstack_init (&action_obstack);
 286   obstack_init (&attrs_obstack);
 287   obstack_init (&table_obstack);
 288   obstack_init (&defines_obstack);
 289 }
 290
 291
 292
 293 /*-----------------------------------------------------.
 294 | Close the open files, produce all the output files.  |
 295 `-----------------------------------------------------*/
 296
 297 void
 298 output_files (void)
 299 {
 300   xfclose (fguard);
 301   xfclose (finput);
 302   xfclose (foutput);
 303
 304   /* Output the main file.  */
 305   obstack_save (&table_obstack, tabfile);
 306
 307   /* Output the header file if wanted. */
 308   if (defines_flag)
 309     obstack_save (&defines_obstack, defsfile);
 310
 311   /* If we output only the table, dump the actions in ACTFILE.
 312      */
 313   if (no_parser_flag)
 314     obstack_save (&action_obstack, actfile);
 315
 316   /* If we produced a semantic parser ATTRS_OBSTACK must be dumped
 317      into its own file, ATTTRSFILE.  */
 318   if (semantic_parser)
 319     obstack_save (&attrs_obstack, attrsfile);
 320 }