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
   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   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   if (c == '#')
 161     {
 162       /* Begins with comment, may not want to preprocess.  */
 163       c = getc (f_in);
 164       if (c == 'N')
 165         {
 166           if (fgets (buf, sizeof (buf), f_in)
 167               && !strncmp (buf, "O_APP", 5) && ISSPACE (buf[5]))
 168             preprocess = 0;
 169           if (!strchr (buf, '\n'))
 170             ungetc ('#', f_in); /* It was longer.  */
 171           else
 172             ungetc ('\n', f_in);
 173         }
 174       else if (c == 'A')
 175         {
 176           if (fgets (buf, sizeof (buf), f_in)
 177               && !strncmp (buf, "PP", 2) && ISSPACE (buf[2]))
 178             preprocess = 1;
 179           if (!strchr (buf, '\n'))
 180             ungetc ('#', f_in);
 181           else
 182             ungetc ('\n', f_in);
 183         }
 184       else if (c == '\n')
 185         ungetc ('\n', f_in);
 186       else
 187         ungetc ('#', f_in);
 188     }
 189   else
 190     ungetc (c, f_in);
 191 }
 192
 193 /* Close input file.  */
 194
 195 void
 196 input_file_close (void)
 197 {
 198   /* Don't close a null file pointer.  */
 199   if (f_in != NULL)
 200     fclose (f_in);
 201
 202   f_in = 0;
 203 }
 204
 205 /* This function is passed to do_scrub_chars.  */
 206
 207 static int
 208 input_file_get (char *buf, int buflen)
 209 {
 210   int size;
 211
 212   size = fread (buf, sizeof (char), buflen, f_in);
 213   if (size < 0)
 214     {
 215       as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
 216       size = 0;
 217     }
 218   return size;
 219 }
 220
 221 /* Read a buffer from the input file.  */
 222
 223 char *
 224 input_file_give_next_buffer (char *where /* Where to place 1st character of new buffer.  */)
 225 {
 226   char *return_value;           /* -> Last char of what we read, + 1.  */
 227   register int size;
 228
 229   if (f_in == (FILE *) 0)
 230     return 0;
 231   /* fflush (stdin); could be done here if you want to synchronise
 232      stdin and stdout, for the case where our input file is stdin.
 233      Since the assembler shouldn't do any output to stdout, we
 234      don't bother to synch output and input.  */
 235   if (preprocess)
 236     size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
 237   else
 238     size = fread (where, sizeof (char), BUFFER_SIZE, f_in);
 239   if (size < 0)
 240     {
 241       as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
 242       size = 0;
 243     }
 244   if (size)
 245     return_value = where + size;
 246   else
 247     {
 248       if (fclose (f_in))
 249         as_warn (_("can't close %s: %s"), file_name, xstrerror (errno));
 250
 251       f_in = (FILE *) 0;
 252       return_value = 0;
 253     }
 254
 255   return return_value;
 256 }