gas/input-file.c

   1 /* input_file.c - Deal with Input Files -
   2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001,
   3    2002, 2003, 2005, 2006, 2007, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS 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, or (at your option)
  11    any later version.
  12
  13    GAS 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 GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* Confines all details of reading source bytes to this module.
  24    All O/S specific crocks should live here.
  25    What we lose in "efficiency" we gain in modularity.
  26    Note we don't need to #include the "as.h" file. No common coupling!  */
  27
  28 #include "as.h"
  29 #include "input-file.h"
  30 #include "safe-ctype.h"
  31
  32 static int input_file_get (char *, int);
  33
  34 /* This variable is non-zero if the file currently being read should be
  35    preprocessed by app.  It is zero if the file can be read straight in.  */
  36 int preprocess = 0;
  37
  38 /* This code opens a file, then delivers BUFFER_SIZE character
  39    chunks of the file on demand.
  40    BUFFER_SIZE is supposed to be a number chosen for speed.
  41    The caller only asks once what BUFFER_SIZE is, and asks before
  42    the nature of the input files (if any) is known.  */
  43
  44 #define BUFFER_SIZE (32 * 1024)
  45
  46 /* We use static data: the data area is not sharable.  */
  47
  48 static FILE *f_in;
  49 static char *file_name;
  50
  51 /* Struct for saving the state of this module for file includes.  */
  52 struct saved_file
  53   {
  54     FILE * f_in;
  55     char * file_name;
  56     int    preprocess;
  57     char * app_save;
  58   };
  59 \f
  60 /* These hooks accommodate most operating systems.  */
  61
  62 void
  63 input_file_begin (void)
  64 {
  65   f_in = (FILE *) 0;
  66 }
  67
  68 void
  69 input_file_end (void)
  70 {
  71 }
  72
  73 /* Return BUFFER_SIZE.  */
  74 unsigned int
  75 input_file_buffer_size (void)
  76 {
  77   return (BUFFER_SIZE);
  78 }
  79
  80 /* Push the state of our input, returning a pointer to saved info that
  81    can be restored with input_file_pop ().  */
  82
  83 char *
  84 input_file_push (void)
  85 {
  86   register struct saved_file *saved;
  87
  88   saved = (struct saved_file *) xmalloc (sizeof *saved);
  89
  90   saved->f_in = f_in;
  91   saved->file_name = file_name;
  92   saved->preprocess = preprocess;
  93   if (preprocess)
  94     saved->app_save = app_push ();
  95
  96   /* Initialize for new file.  */
  97   input_file_begin ();
  98
  99   return (char *) saved;
 100 }
 101
 102 void
 103 input_file_pop (char *arg)
 104 {
 105   register struct saved_file *saved = (struct saved_file *) arg;
 106
 107   input_file_end ();            /* Close out old file.  */
 108
 109   f_in = saved->f_in;
 110   file_name = saved->file_name;
 111   preprocess = saved->preprocess;
 112   if (preprocess)
 113     app_pop (saved->app_save);
 114
 115   free (arg);
 116 }
 117 \f
 118 void
 119 input_file_open (char *filename, /* "" means use stdin. Must not be 0.  */
 120                  int pre)
 121 {
 122   int c;
 123   char buf[80];
 124
 125   preprocess = pre;
 126
 127   gas_assert (filename != 0);   /* Filename may not be NULL.  */
 128   if (filename[0])
 129     {
 130       f_in = fopen (filename, FOPEN_RT);
 131       file_name = filename;
 132     }
 133   else
 134     {
 135       /* Use stdin for the input file.  */
 136       f_in = stdin;
 137       /* For error messages.  */
 138       file_name = _("{standard input}");
 139     }
 140
 141   if (f_in == NULL)
 142     {
 143       as_bad (_("can't open %s for reading: %s"),
 144               file_name, xstrerror (errno));
 145       return;
 146     }
 147
 148   c = getc (f_in);
 149
 150   if (ferror (f_in))
 151     {
 152       as_bad (_("can't read from %s: %s"),
 153               file_name, xstrerror (errno));
 154
 155       fclose (f_in);
 156       f_in = NULL;
 157       return;
 158     }
 159
 160   /* Check for an empty input file.  */
 161   if (feof (f_in))
 162     {
 163       fclose (f_in);
 164       f_in = NULL;
 165       return;
 166     }
 167   gas_assert (c != EOF);
 168
 169   if (c == '#')
 170     {
 171       /* Begins with comment, may not want to preprocess.  */
 172       c = getc (f_in);
 173       if (c == 'N')
 174         {
 175           if (fgets (buf, sizeof (buf), f_in)
 176               && !strncmp (buf, "O_APP", 5) && ISSPACE (buf[5]))
 177             preprocess = 0;
 178           if (!strchr (buf, '\n'))
 179             ungetc ('#', f_in); /* It was longer.  */
 180           else
 181             ungetc ('\n', f_in);
 182         }
 183       else if (c == 'A')
 184         {
 185           if (fgets (buf, sizeof (buf), f_in)
 186               && !strncmp (buf, "PP", 2) && ISSPACE (buf[2]))
 187             preprocess = 1;
 188           if (!strchr (buf, '\n'))
 189             ungetc ('#', f_in);
 190           else
 191             ungetc ('\n', f_in);
 192         }
 193       else if (c == '\n')
 194         ungetc ('\n', f_in);
 195       else
 196         ungetc ('#', f_in);
 197     }
 198   else
 199     ungetc (c, f_in);
 200 }
 201
 202 /* Close input file.  */
 203
 204 void
 205 input_file_close (void)
 206 {
 207   /* Don't close a null file pointer.  */
 208   if (f_in != NULL)
 209     fclose (f_in);
 210
 211   f_in = 0;
 212 }
 213
 214 /* This function is passed to do_scrub_chars.  */
 215
 216 static int
 217 input_file_get (char *buf, int buflen)
 218 {
 219   int size;
 220
 221   if (feof (f_in))
 222     return 0;
 223
 224   size = fread (buf, sizeof (char), buflen, f_in);
 225   if (size < 0)
 226     {
 227       as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
 228       size = 0;
 229     }
 230   return size;
 231 }
 232
 233 /* Read a buffer from the input file.  */
 234
 235 char *
 236 input_file_give_next_buffer (char *where /* Where to place 1st character of new buffer.  */)
 237 {
 238   char *return_value;           /* -> Last char of what we read, + 1.  */
 239   int size;
 240
 241   if (f_in == (FILE *) 0)
 242     return 0;
 243   /* fflush (stdin); could be done here if you want to synchronise
 244      stdin and stdout, for the case where our input file is stdin.
 245      Since the assembler shouldn't do any output to stdout, we
 246      don't bother to synch output and input.  */
 247   if (preprocess)
 248     size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
 249   else
 250     {
 251       if (feof (f_in))
 252         size = 0;
 253       else
 254         size = fread (where, sizeof (char), BUFFER_SIZE, f_in);
 255     }
 256
 257   if (size < 0)
 258     {
 259       as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
 260       size = 0;
 261     }
 262   if (size)
 263     return_value = where + size;
 264   else
 265     {
 266       if (fclose (f_in))
 267         as_warn (_("can't close %s: %s"), file_name, xstrerror (errno));
 268
 269       f_in = (FILE *) 0;
 270       return_value = 0;
 271     }
 272
 273   return return_value;
 274 }