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