OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gas/] [input-file.c] - Blame information for rev 272

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 147 khays
/* 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
 
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
 
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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.