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