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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [gas/] [input-file.c] - Blame information for rev 853

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

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

powered by: WebSVN 2.1.0

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