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