WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/gas/input-file.c


/* input_file.c - Deal with Input Files -
 
 
   Copyright (C) 1987-2015 Free Software Foundation, Inc.
 
   This file is part of GAS, the GNU Assembler.
 
   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
 
   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
   02110-1301, USA.  */
 
/* Confines all details of reading source bytes to this module.
   All O/S specific crocks should live here.
   What we lose in "efficiency" we gain in modularity.
   Note we don't need to #include the "as.h" file. No common coupling!  */
 
#include "as.h"
#include "input-file.h"
#include "safe-ctype.h"
 
/* This variable is non-zero if the file currently being read should be
   preprocessed by app.  It is zero if the file can be read straight in.  */
int preprocess = 0;
 
/* This code opens a file, then delivers BUFFER_SIZE character
   chunks of the file on demand.
   BUFFER_SIZE is supposed to be a number chosen for speed.
   The caller only asks once what BUFFER_SIZE is, and asks before
   the nature of the input files (if any) is known.  */
 
#define BUFFER_SIZE (32 * 1024)
 
/* We use static data: the data area is not sharable.  */
 
static FILE *f_in;
static char *file_name;
 
/* Struct for saving the state of this module for file includes.  */
struct saved_file
  {
    FILE * f_in;
    char * file_name;
    int    preprocess;
    char * app_save;
  };

/* These hooks accommodate most operating systems.  */
 
void
input_file_begin (void)
{
  f_in = (FILE *) 0;
}
 
void
input_file_end (void)
{
}
 
/* Return BUFFER_SIZE.  */
size_t
input_file_buffer_size (void)
{
  return (BUFFER_SIZE);
}
 
/* Push the state of our input, returning a pointer to saved info that
   can be restored with input_file_pop ().  */
 
char *
input_file_push (void)
{
  struct saved_file *saved;
 
  saved = (struct saved_file *) xmalloc (sizeof *saved);
 
  saved->f_in = f_in;
  saved->file_name = file_name;
  saved->preprocess = preprocess;
  if (preprocess)
    saved->app_save = app_push ();
 
  /* Initialize for new file.  */
  input_file_begin ();
 
  return (char *) saved;
}
 
void
input_file_pop (char *arg)
{
  struct saved_file *saved = (struct saved_file *) arg;
 
  input_file_end ();		/* Close out old file.  */
 
  f_in = saved->f_in;
  file_name = saved->file_name;
  preprocess = saved->preprocess;
  if (preprocess)
    app_pop (saved->app_save);
 
  free (arg);
}

void
input_file_open (char *filename, /* "" means use stdin. Must not be 0.  */
		 int pre)
{
  int c;
  char buf[80];
 
  preprocess = pre;
 
  gas_assert (filename != 0);	/* Filename may not be NULL.  */
  if (filename[0])
    {
      f_in = fopen (filename, FOPEN_RT);
      file_name = filename;
    }
  else
    {
      /* Use stdin for the input file.  */
      f_in = stdin;
      /* For error messages.  */
      file_name = _("{standard input}");
    }
 
  if (f_in == NULL)
    {
      as_bad (_("can't open %s for reading: %s"),
	      file_name, xstrerror (errno));
      return;
    }
 
  c = getc (f_in);
 
  if (ferror (f_in))
    {
      as_bad (_("can't read from %s: %s"),
	      file_name, xstrerror (errno));
 
      fclose (f_in);
      f_in = NULL;
      return;
    }
 
  /* Check for an empty input file.  */
  if (feof (f_in))
    {
      fclose (f_in);
      f_in = NULL;
      return;
    }
  gas_assert (c != EOF);
 
  if (c == '#')
    {
      /* Begins with comment, may not want to preprocess.  */
      c = getc (f_in);
      if (c == 'N')
	{
	  if (fgets (buf, sizeof (buf), f_in)
	      && !strncmp (buf, "O_APP", 5) && ISSPACE (buf[5]))
	    preprocess = 0;
	  if (!strchr (buf, '\n'))
	    ungetc ('#', f_in);	/* It was longer.  */
	  else
	    ungetc ('\n', f_in);
	}
      else if (c == 'A')
	{
	  if (fgets (buf, sizeof (buf), f_in)
	      && !strncmp (buf, "PP", 2) && ISSPACE (buf[2]))
	    preprocess = 1;
	  if (!strchr (buf, '\n'))
	    ungetc ('#', f_in);
	  else
	    ungetc ('\n', f_in);
	}
      else if (c == '\n')
	ungetc ('\n', f_in);
      else
	ungetc ('#', f_in);
    }
  else
    ungetc (c, f_in);
}
 
/* Close input file.  */
 
void
input_file_close (void)
{
  /* Don't close a null file pointer.  */
  if (f_in != NULL)
    fclose (f_in);
 
  f_in = 0;
}
 
/* This function is passed to do_scrub_chars.  */
 
static size_t
input_file_get (char *buf, size_t buflen)
{
  size_t size;
 
  if (feof (f_in))
    return 0;
 
  size = fread (buf, sizeof (char), buflen, f_in);
  if (ferror (f_in))
    as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
  return size;
}
 
/* Read a buffer from the input file.  */
 
char *
input_file_give_next_buffer (char *where /* Where to place 1st character of new buffer.  */)
{
  char *return_value;		/* -> Last char of what we read, + 1.  */
  size_t size;
 
  if (f_in == (FILE *) 0)
    return 0;
  /* fflush (stdin); could be done here if you want to synchronise
     stdin and stdout, for the case where our input file is stdin.
     Since the assembler shouldn't do any output to stdout, we
     don't bother to synch output and input.  */
  if (preprocess)
    size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
  else
    size = input_file_get (where, BUFFER_SIZE);
 
  if (size)
    return_value = where + size;
  else
    {
      if (fclose (f_in))
	as_warn (_("can't close %s: %s"), file_name, xstrerror (errno));
 
      f_in = (FILE *) 0;
      return_value = 0;
    }
 
  return return_value;
}

Rev 5222	Rev 6324
1	/* input_file.c - Deal with Input Files -	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, 2012	-
4	Free Software Foundation, Inc.	2	Copyright (C) 1987-2015 Free Software Foundation, Inc.
5		3
6	This file is part of GAS, the GNU Assembler.	4	This file is part of GAS, the GNU Assembler.
7		5
8	GAS is free software; you can redistribute it and/or modify	6	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	7	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)	8	the Free Software Foundation; either version 3, or (at your option)
11	any later version.	9	any later version.
12		10
13	GAS is distributed in the hope that it will be useful,	11	GAS is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.	14	GNU General Public License for more details.
17		15
18	You should have received a copy of the GNU General Public License	16	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	17	along with GAS; see the file COPYING. If not, write to the Free
20	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA	18	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21	02110-1301, USA. */	19	02110-1301, USA. */
22		20
23	/* Confines all details of reading source bytes to this module.	21	/* Confines all details of reading source bytes to this module.
24	All O/S specific crocks should live here.	22	All O/S specific crocks should live here.
25	What we lose in "efficiency" we gain in modularity.	23	What we lose in "efficiency" we gain in modularity.
26	Note we don't need to #include the "as.h" file. No common coupling! */	24	Note we don't need to #include the "as.h" file. No common coupling! */
27		25
28	#include "as.h"	26	#include "as.h"
29	#include "input-file.h"	27	#include "input-file.h"
30	#include "safe-ctype.h"	28	#include "safe-ctype.h"
31		29
32	/* This variable is non-zero if the file currently being read should be	30	/* This variable is non-zero if the file currently being read should be
33	preprocessed by app. It is zero if the file can be read straight in. */	31	preprocessed by app. It is zero if the file can be read straight in. */
34	int preprocess = 0;	32	int preprocess = 0;
35		33
36	/* This code opens a file, then delivers BUFFER_SIZE character	34	/* This code opens a file, then delivers BUFFER_SIZE character
37	chunks of the file on demand.	35	chunks of the file on demand.
38	BUFFER_SIZE is supposed to be a number chosen for speed.	36	BUFFER_SIZE is supposed to be a number chosen for speed.
39	The caller only asks once what BUFFER_SIZE is, and asks before	37	The caller only asks once what BUFFER_SIZE is, and asks before
40	the nature of the input files (if any) is known. */	38	the nature of the input files (if any) is known. */
41		39
42	#define BUFFER_SIZE (32 * 1024)	40	#define BUFFER_SIZE (32 * 1024)
43		41
44	/* We use static data: the data area is not sharable. */	42	/* We use static data: the data area is not sharable. */
45		43
46	static FILE *f_in;	44	static FILE *f_in;
47	static char *file_name;	45	static char *file_name;
48		46
49	/* Struct for saving the state of this module for file includes. */	47	/* Struct for saving the state of this module for file includes. */
50	struct saved_file	48	struct saved_file
51	{	49	{
52	FILE * f_in;	50	FILE * f_in;
53	char * file_name;	51	char * file_name;
54	int preprocess;	52	int preprocess;
55	char * app_save;	53	char * app_save;
56	};	54	};
57		55
58	/* These hooks accommodate most operating systems. */	56	/* These hooks accommodate most operating systems. */
59		57
60	void	58	void
61	input_file_begin (void)	59	input_file_begin (void)
62	{	60	{
63	f_in = (FILE *) 0;	61	f_in = (FILE *) 0;
64	}	62	}
65		63
66	void	64	void
67	input_file_end (void)	65	input_file_end (void)
68	{	66	{
69	}	67	}
70		68
71	/* Return BUFFER_SIZE. */	69	/* Return BUFFER_SIZE. */
72	size_t	70	size_t
73	input_file_buffer_size (void)	71	input_file_buffer_size (void)
74	{	72	{
75	return (BUFFER_SIZE);	73	return (BUFFER_SIZE);
76	}	74	}
77		75
78	/* Push the state of our input, returning a pointer to saved info that	76	/* Push the state of our input, returning a pointer to saved info that
79	can be restored with input_file_pop (). */	77	can be restored with input_file_pop (). */
80		78
81	char *	79	char *
82	input_file_push (void)	80	input_file_push (void)
83	{	81	{
84	register struct saved_file *saved;	82	struct saved_file *saved;
85		83
86	saved = (struct saved_file ) xmalloc (sizeof saved);	84	saved = (struct saved_file ) xmalloc (sizeof saved);
87		85
88	saved->f_in = f_in;	86	saved->f_in = f_in;
89	saved->file_name = file_name;	87	saved->file_name = file_name;
90	saved->preprocess = preprocess;	88	saved->preprocess = preprocess;
91	if (preprocess)	89	if (preprocess)
92	saved->app_save = app_push ();	90	saved->app_save = app_push ();
93		91
94	/* Initialize for new file. */	92	/* Initialize for new file. */
95	input_file_begin ();	93	input_file_begin ();
96		94
97	return (char *) saved;	95	return (char *) saved;
98	}	96	}
99		97
100	void	98	void
101	input_file_pop (char *arg)	99	input_file_pop (char *arg)
102	{	100	{
103	register struct saved_file saved = (struct saved_file ) arg;	101	struct saved_file saved = (struct saved_file ) arg;
104		102
105	input_file_end (); /* Close out old file. */	103	input_file_end (); /* Close out old file. */
106		104
107	f_in = saved->f_in;	105	f_in = saved->f_in;
108	file_name = saved->file_name;	106	file_name = saved->file_name;
109	preprocess = saved->preprocess;	107	preprocess = saved->preprocess;
110	if (preprocess)	108	if (preprocess)
111	app_pop (saved->app_save);	109	app_pop (saved->app_save);
112		110
113	free (arg);	111	free (arg);
114	}	112	}
115		113
116	void	114	void
117	input_file_open (char filename, / "" means use stdin. Must not be 0. */	115	input_file_open (char filename, / "" means use stdin. Must not be 0. */
118	int pre)	116	int pre)
119	{	117	{
120	int c;	118	int c;
121	char buf[80];	119	char buf[80];
122		120
123	preprocess = pre;	121	preprocess = pre;
124		122
125	gas_assert (filename != 0); /* Filename may not be NULL. */	123	gas_assert (filename != 0); /* Filename may not be NULL. */
126	if (filename[0])	124	if (filename[0])
127	{	125	{
128	f_in = fopen (filename, FOPEN_RT);	126	f_in = fopen (filename, FOPEN_RT);
129	file_name = filename;	127	file_name = filename;
130	}	128	}
131	else	129	else
132	{	130	{
133	/* Use stdin for the input file. */	131	/* Use stdin for the input file. */
134	f_in = stdin;	132	f_in = stdin;
135	/* For error messages. */	133	/* For error messages. */
136	file_name = _("{standard input}");	134	file_name = _("{standard input}");
137	}	135	}
138		136
139	if (f_in == NULL)	137	if (f_in == NULL)
140	{	138	{
141	as_bad (_("can't open %s for reading: %s"),	139	as_bad (_("can't open %s for reading: %s"),
142	file_name, xstrerror (errno));	140	file_name, xstrerror (errno));
143	return;	141	return;
144	}	142	}
145		143
146	c = getc (f_in);	144	c = getc (f_in);
147		145
148	if (ferror (f_in))	146	if (ferror (f_in))
149	{	147	{
150	as_bad (_("can't read from %s: %s"),	148	as_bad (_("can't read from %s: %s"),
151	file_name, xstrerror (errno));	149	file_name, xstrerror (errno));
152		150
153	fclose (f_in);	151	fclose (f_in);
154	f_in = NULL;	152	f_in = NULL;
155	return;	153	return;
156	}	154	}
157		155
158	/* Check for an empty input file. */	156	/* Check for an empty input file. */
159	if (feof (f_in))	157	if (feof (f_in))
160	{	158	{
161	fclose (f_in);	159	fclose (f_in);
162	f_in = NULL;	160	f_in = NULL;
163	return;	161	return;
164	}	162	}
165	gas_assert (c != EOF);	163	gas_assert (c != EOF);
166		164
167	if (c == '#')	165	if (c == '#')
168	{	166	{
169	/* Begins with comment, may not want to preprocess. */	167	/* Begins with comment, may not want to preprocess. */
170	c = getc (f_in);	168	c = getc (f_in);
171	if (c == 'N')	169	if (c == 'N')
172	{	170	{
173	if (fgets (buf, sizeof (buf), f_in)	171	if (fgets (buf, sizeof (buf), f_in)
174	&& !strncmp (buf, "O_APP", 5) && ISSPACE (buf[5]))	172	&& !strncmp (buf, "O_APP", 5) && ISSPACE (buf[5]))
175	preprocess = 0;	173	preprocess = 0;
176	if (!strchr (buf, '\n'))	174	if (!strchr (buf, '\n'))
177	ungetc ('#', f_in); /* It was longer. */	175	ungetc ('#', f_in); /* It was longer. */
178	else	176	else
179	ungetc ('\n', f_in);	177	ungetc ('\n', f_in);
180	}	178	}
181	else if (c == 'A')	179	else if (c == 'A')
182	{	180	{
183	if (fgets (buf, sizeof (buf), f_in)	181	if (fgets (buf, sizeof (buf), f_in)
184	&& !strncmp (buf, "PP", 2) && ISSPACE (buf[2]))	182	&& !strncmp (buf, "PP", 2) && ISSPACE (buf[2]))
185	preprocess = 1;	183	preprocess = 1;
186	if (!strchr (buf, '\n'))	184	if (!strchr (buf, '\n'))
187	ungetc ('#', f_in);	185	ungetc ('#', f_in);
188	else	186	else
189	ungetc ('\n', f_in);	187	ungetc ('\n', f_in);
190	}	188	}
191	else if (c == '\n')	189	else if (c == '\n')
192	ungetc ('\n', f_in);	190	ungetc ('\n', f_in);
193	else	191	else
194	ungetc ('#', f_in);	192	ungetc ('#', f_in);
195	}	193	}
196	else	194	else
197	ungetc (c, f_in);	195	ungetc (c, f_in);
198	}	196	}
199		197
200	/* Close input file. */	198	/* Close input file. */
201		199
202	void	200	void
203	input_file_close (void)	201	input_file_close (void)
204	{	202	{
205	/* Don't close a null file pointer. */	203	/* Don't close a null file pointer. */
206	if (f_in != NULL)	204	if (f_in != NULL)
207	fclose (f_in);	205	fclose (f_in);
208		206
209	f_in = 0;	207	f_in = 0;
210	}	208	}
211		209
212	/* This function is passed to do_scrub_chars. */	210	/* This function is passed to do_scrub_chars. */
213		211
214	static size_t	212	static size_t
215	input_file_get (char *buf, size_t buflen)	213	input_file_get (char *buf, size_t buflen)
216	{	214	{
217	size_t size;	215	size_t size;
218		216
219	if (feof (f_in))	217	if (feof (f_in))
220	return 0;	218	return 0;
221		219
222	size = fread (buf, sizeof (char), buflen, f_in);	220	size = fread (buf, sizeof (char), buflen, f_in);
223	if (ferror (f_in))	221	if (ferror (f_in))
224	as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));	222	as_bad (_("can't read from %s: %s"), file_name, xstrerror (errno));
225	return size;	223	return size;
226	}	224	}
227		225
228	/* Read a buffer from the input file. */	226	/* Read a buffer from the input file. */
229		227
230	char *	228	char *
231	input_file_give_next_buffer (char where / Where to place 1st character of new buffer. */)	229	input_file_give_next_buffer (char where / Where to place 1st character of new buffer. */)
232	{	230	{
233	char return_value; / -> Last char of what we read, + 1. */	231	char return_value; / -> Last char of what we read, + 1. */
234	size_t size;	232	size_t size;
235		233
236	if (f_in == (FILE *) 0)	234	if (f_in == (FILE *) 0)
237	return 0;	235	return 0;
238	/* fflush (stdin); could be done here if you want to synchronise	236	/* fflush (stdin); could be done here if you want to synchronise
239	stdin and stdout, for the case where our input file is stdin.	237	stdin and stdout, for the case where our input file is stdin.
240	Since the assembler shouldn't do any output to stdout, we	238	Since the assembler shouldn't do any output to stdout, we
241	don't bother to synch output and input. */	239	don't bother to synch output and input. */
242	if (preprocess)	240	if (preprocess)
243	size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);	241	size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
244	else	242	else
245	size = input_file_get (where, BUFFER_SIZE);	243	size = input_file_get (where, BUFFER_SIZE);
246		244
247	if (size)	245	if (size)
248	return_value = where + size;	246	return_value = where + size;
249	else	247	else
250	{	248	{
251	if (fclose (f_in))	249	if (fclose (f_in))
252	as_warn (_("can't close %s: %s"), file_name, xstrerror (errno));	250	as_warn (_("can't close %s: %s"), file_name, xstrerror (errno));
253		251
254	f_in = (FILE *) 0;	252	f_in = (FILE *) 0;
255	return_value = 0;	253	return_value = 0;
256	}	254	}
257		255
258	return return_value;	256	return return_value;
259	}	257	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/gas/input-file.c – Rev 5222 → 6324