* ChangeLog: Fix typos.
[external/binutils.git] / 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 accommodate 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 }