Import binutils-2.20
[dragonfly.git] / contrib / binutils-2.20 / 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   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 }