1 /* input_file.c - Deal with Input Files -
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2003
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 <errno.h>
30 #include "as.h"
31 #include "input-file.h"
32 #include "safe-ctype.h"
33
34 static int input_file_get (char *, int);
35
36 /* This variable is non-zero if the file currently being read should be
37 preprocessed by app. It is zero if the file can be read straight in. */
38 int preprocess = 0;
39
40 /* This code opens a file, then delivers BUFFER_SIZE character
41 chunks of the file on demand.
42 BUFFER_SIZE is supposed to be a number chosen for speed.
43 The caller only asks once what BUFFER_SIZE is, and asks before
44 the nature of the input files (if any) is known. */
45
46 #define BUFFER_SIZE (32 * 1024)
47
48 /* We use static data: the data area is not sharable. */
49
50 static FILE *f_in;
51 static char *file_name;
52
53 /* Struct for saving the state of this module for file includes. */
54 struct saved_file
55 {
56 FILE * f_in;
57 char * file_name;
58 int preprocess;
59 char * app_save;
60 };
61
62 /* These hooks accommodate most operating systems. */
63
64 void
input_file_begin(void)65 input_file_begin (void)
66 {
67 f_in = (FILE *) 0;
68 }
69
70 void
input_file_end(void)71 input_file_end (void)
72 {
73 }
74
75 /* Return BUFFER_SIZE. */
76 unsigned int
input_file_buffer_size(void)77 input_file_buffer_size (void)
78 {
79 return (BUFFER_SIZE);
80 }
81
82 int
input_file_is_open(void)83 input_file_is_open (void)
84 {
85 return f_in != (FILE *) 0;
86 }
87
88 /* Push the state of our input, returning a pointer to saved info that
89 can be restored with input_file_pop (). */
90
91 char *
input_file_push(void)92 input_file_push (void)
93 {
94 register struct saved_file *saved;
95
96 saved = (struct saved_file *) xmalloc (sizeof *saved);
97
98 saved->f_in = f_in;
99 saved->file_name = file_name;
100 saved->preprocess = preprocess;
101 if (preprocess)
102 saved->app_save = app_push ();
103
104 /* Initialize for new file. */
105 input_file_begin ();
106
107 return (char *) saved;
108 }
109
110 void
input_file_pop(char * arg)111 input_file_pop (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
126 void
input_file_open(char * filename,int pre)127 input_file_open (char *filename, /* "" means use stdin. Must not be 0. */
128 int pre)
129 {
130 int c;
131 char buf[80];
132
133 preprocess = pre;
134
135 assert (filename != 0); /* Filename may not be NULL. */
136 if (filename[0])
137 {
138 f_in = fopen (filename, FOPEN_RT);
139 file_name = filename;
140 }
141 else
142 {
143 /* Use stdin for the input file. */
144 f_in = stdin;
145 /* For error messages. */
146 file_name = _("{standard input}");
147 }
148
149 if (f_in)
150 c = getc (f_in);
151
152 if (f_in == NULL || ferror (f_in))
153 {
154 #ifdef BFD_ASSEMBLER
155 bfd_set_error (bfd_error_system_call);
156 #endif
157 as_perror (_("Can't open %s for reading"), file_name);
158
159 if (f_in)
160 {
161 fclose (f_in);
162 f_in = NULL;
163 }
164 return;
165 }
166
167 if (c == '#')
168 {
169 /* Begins with comment, may not want to preprocess. */
170 c = getc (f_in);
171 if (c == 'N')
172 {
173 fgets (buf, 80, f_in);
174 if (!strncmp (buf, "O_APP", 5) && ISSPACE (buf[5]))
175 preprocess = 0;
176 if (!strchr (buf, '\n'))
177 ungetc ('#', f_in); /* It was longer. */
178 else
179 ungetc ('\n', f_in);
180 }
181 else if (c == 'A')
182 {
183 fgets (buf, 80, f_in);
184 if (!strncmp (buf, "PP", 2) && ISSPACE (buf[2]))
185 preprocess = 1;
186 if (!strchr (buf, '\n'))
187 ungetc ('#', f_in);
188 else
189 ungetc ('\n', f_in);
190 }
191 else if (c == '\n')
192 ungetc ('\n', f_in);
193 else
194 ungetc ('#', f_in);
195 }
196 else
197 ungetc (c, f_in);
198 }
199
200 /* Close input file. */
201
202 void
input_file_close(void)203 input_file_close (void)
204 {
205 /* Don't close a null file pointer. */
206 if (f_in != NULL)
207 fclose (f_in);
208
209 f_in = 0;
210 }
211
212 /* This function is passed to do_scrub_chars. */
213
214 static int
input_file_get(char * buf,int buflen)215 input_file_get (char *buf, int buflen)
216 {
217 int size;
218
219 size = fread (buf, sizeof (char), buflen, f_in);
220 if (size < 0)
221 {
222 #ifdef BFD_ASSEMBLER
223 bfd_set_error (bfd_error_system_call);
224 #endif
225 as_perror (_("Can't read from %s"), file_name);
226 size = 0;
227 }
228 return size;
229 }
230
231 /* Read a buffer from the input file. */
232
233 char *
input_file_give_next_buffer(char * where)234 input_file_give_next_buffer (char *where /* Where to place 1st character of new buffer. */)
235 {
236 char *return_value; /* -> Last char of what we read, + 1. */
237 register int size;
238
239 if (f_in == (FILE *) 0)
240 return 0;
241 /* fflush (stdin); could be done here if you want to synchronise
242 stdin and stdout, for the case where our input file is stdin.
243 Since the assembler shouldn't do any output to stdout, we
244 don't bother to synch output and input. */
245 if (preprocess)
246 size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
247 else
248 size = fread (where, sizeof (char), BUFFER_SIZE, f_in);
249 if (size < 0)
250 {
251 #ifdef BFD_ASSEMBLER
252 bfd_set_error (bfd_error_system_call);
253 #endif
254 as_perror (_("Can't read from %s"), file_name);
255 size = 0;
256 }
257 if (size)
258 return_value = where + size;
259 else
260 {
261 if (fclose (f_in))
262 {
263 #ifdef BFD_ASSEMBLER
264 bfd_set_error (bfd_error_system_call);
265 #endif
266 as_perror (_("Can't close %s"), file_name);
267 }
268 f_in = (FILE *) 0;
269 return_value = 0;
270 }
271
272 return return_value;
273 }
274