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
  30 #include "as.h"
  31 #include "input-file.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 (!strcmp (buf, "O_APP\n"))
 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 == '\n')
 170         ungetc ('\n', f_in);
 171       else
 172         ungetc ('#', f_in);
 173     }
 174   else
 175     ungetc (c, f_in);
 176 }
 177
 178 /* Close input file.  */
 179
 180 void
 181 input_file_close ()
 182 {
 183   /* Don't close a null file pointer.  */
 184   if (f_in != NULL)
 185     fclose (f_in);
 186
 187   f_in = 0;
 188 }
 189
 190 /* This function is passed to do_scrub_chars.  */
 191
 192 static int
 193 input_file_get (buf, buflen)
 194      char *buf;
 195      int buflen;
 196 {
 197   int size;
 198
 199   size = fread (buf, sizeof (char), buflen, f_in);
 200   if (size < 0)
 201     {
 202       as_perror (_("Can't read from %s"), file_name);
 203       size = 0;
 204     }
 205   return size;
 206 }
 207
 208 /* Read a buffer from the input file.  */
 209
 210 char *
 211 input_file_give_next_buffer (where)
 212      char *where;               /* Where to place 1st character of new buffer.  */
 213 {
 214   char *return_value;           /* -> Last char of what we read, + 1.  */
 215   register int size;
 216
 217   if (f_in == (FILE *) 0)
 218     return 0;
 219   /* fflush (stdin); could be done here if you want to synchronise
 220      stdin and stdout, for the case where our input file is stdin.
 221      Since the assembler shouldn't do any output to stdout, we
 222      don't bother to synch output and input.  */
 223   if (preprocess)
 224     size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
 225   else
 226     size = fread (where, sizeof (char), BUFFER_SIZE, f_in);
 227   if (size < 0)
 228     {
 229       as_perror (_("Can't read from %s"), file_name);
 230       size = 0;
 231     }
 232   if (size)
 233     return_value = where + size;
 234   else
 235     {
 236       if (fclose (f_in))
 237         as_perror (_("Can't close %s"), file_name);
 238       f_in = (FILE *) 0;
 239       return_value = 0;
 240     }
 241
 242   return return_value;
 243 }