1 | /* input.c -- functions to perform buffered input with synchronization. */ |
---|
2 | |
---|
3 | /* Copyright (C) 1992 Free Software Foundation, Inc. |
---|
4 | |
---|
5 | This file is part of GNU Bash, the Bourne Again SHell. |
---|
6 | |
---|
7 | Bash is free software; you can redistribute it and/or modify it under |
---|
8 | the terms of the GNU General Public License as published by the Free |
---|
9 | Software Foundation; either version 2, or (at your option) any later |
---|
10 | version. |
---|
11 | |
---|
12 | Bash is distributed in the hope that it will be useful, but WITHOUT ANY |
---|
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
---|
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
---|
15 | for more details. |
---|
16 | |
---|
17 | You should have received a copy of the GNU General Public License along |
---|
18 | with Bash; see the file COPYING. If not, write to the Free Software |
---|
19 | Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ |
---|
20 | |
---|
21 | #include "config.h" |
---|
22 | |
---|
23 | #include "bashtypes.h" |
---|
24 | #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H) |
---|
25 | # include <sys/file.h> |
---|
26 | #endif |
---|
27 | #include "filecntl.h" |
---|
28 | #include "posixstat.h" |
---|
29 | #include <stdio.h> |
---|
30 | #include <errno.h> |
---|
31 | |
---|
32 | #if defined (HAVE_UNISTD_H) |
---|
33 | # include <unistd.h> |
---|
34 | #endif |
---|
35 | |
---|
36 | #include "bashansi.h" |
---|
37 | #include "bashintl.h" |
---|
38 | |
---|
39 | #include "command.h" |
---|
40 | #include "general.h" |
---|
41 | #include "input.h" |
---|
42 | #include "error.h" |
---|
43 | #include "externs.h" |
---|
44 | |
---|
45 | #if !defined (errno) |
---|
46 | extern int errno; |
---|
47 | #endif /* !errno */ |
---|
48 | |
---|
49 | /* Functions to handle reading input on systems that don't restart read(2) |
---|
50 | if a signal is received. */ |
---|
51 | |
---|
52 | static char localbuf[128]; |
---|
53 | static int local_index, local_bufused; |
---|
54 | |
---|
55 | /* Posix and USG systems do not guarantee to restart read () if it is |
---|
56 | interrupted by a signal. We do the read ourselves, and restart it |
---|
57 | if it returns EINTR. */ |
---|
58 | int |
---|
59 | getc_with_restart (stream) |
---|
60 | FILE *stream; |
---|
61 | { |
---|
62 | unsigned char uc; |
---|
63 | |
---|
64 | /* Try local buffering to reduce the number of read(2) calls. */ |
---|
65 | if (local_index == local_bufused || local_bufused == 0) |
---|
66 | { |
---|
67 | while (1) |
---|
68 | { |
---|
69 | local_bufused = read (fileno (stream), localbuf, sizeof(localbuf)); |
---|
70 | if (local_bufused > 0) |
---|
71 | break; |
---|
72 | else if (local_bufused == 0 || errno != EINTR) |
---|
73 | { |
---|
74 | local_index = 0; |
---|
75 | return EOF; |
---|
76 | } |
---|
77 | } |
---|
78 | local_index = 0; |
---|
79 | } |
---|
80 | uc = localbuf[local_index++]; |
---|
81 | return uc; |
---|
82 | } |
---|
83 | |
---|
84 | int |
---|
85 | ungetc_with_restart (c, stream) |
---|
86 | int c; |
---|
87 | FILE *stream; |
---|
88 | { |
---|
89 | if (local_index == 0 || c == EOF) |
---|
90 | return EOF; |
---|
91 | localbuf[--local_index] = c; |
---|
92 | return c; |
---|
93 | } |
---|
94 | |
---|
95 | #if defined (BUFFERED_INPUT) |
---|
96 | |
---|
97 | /* A facility similar to stdio, but input-only. */ |
---|
98 | |
---|
99 | #if defined (USING_BASH_MALLOC) |
---|
100 | # define MAX_INPUT_BUFFER_SIZE 8176 |
---|
101 | #else |
---|
102 | # define MAX_INPUT_BUFFER_SIZE 8192 |
---|
103 | #endif |
---|
104 | |
---|
105 | #if !defined (SEEK_CUR) |
---|
106 | # define SEEK_CUR 1 |
---|
107 | #endif /* !SEEK_CUR */ |
---|
108 | |
---|
109 | #ifdef max |
---|
110 | # undef max |
---|
111 | #endif |
---|
112 | #define max(a, b) (((a) > (b)) ? (a) : (b)) |
---|
113 | #ifdef min |
---|
114 | # undef min |
---|
115 | #endif |
---|
116 | #define min(a, b) ((a) > (b) ? (b) : (a)) |
---|
117 | |
---|
118 | extern int interactive_shell; |
---|
119 | |
---|
120 | int bash_input_fd_changed; |
---|
121 | |
---|
122 | /* This provides a way to map from a file descriptor to the buffer |
---|
123 | associated with that file descriptor, rather than just the other |
---|
124 | way around. This is needed so that buffers are managed properly |
---|
125 | in constructs like 3<&4. buffers[x]->b_fd == x -- that is how the |
---|
126 | correspondence is maintained. */ |
---|
127 | static BUFFERED_STREAM **buffers = (BUFFERED_STREAM **)NULL; |
---|
128 | static int nbuffers; |
---|
129 | |
---|
130 | #define ALLOCATE_BUFFERS(n) \ |
---|
131 | do { if ((n) >= nbuffers) allocate_buffers (n); } while (0) |
---|
132 | |
---|
133 | /* Make sure `buffers' has at least N elements. */ |
---|
134 | static void |
---|
135 | allocate_buffers (n) |
---|
136 | int n; |
---|
137 | { |
---|
138 | register int i, orig_nbuffers; |
---|
139 | |
---|
140 | orig_nbuffers = nbuffers; |
---|
141 | nbuffers = n + 20; |
---|
142 | buffers = (BUFFERED_STREAM **)xrealloc |
---|
143 | (buffers, nbuffers * sizeof (BUFFERED_STREAM *)); |
---|
144 | |
---|
145 | /* Zero out the new buffers. */ |
---|
146 | for (i = orig_nbuffers; i < nbuffers; i++) |
---|
147 | buffers[i] = (BUFFERED_STREAM *)NULL; |
---|
148 | } |
---|
149 | |
---|
150 | /* Construct and return a BUFFERED_STREAM corresponding to file descriptor |
---|
151 | FD, using BUFFER. */ |
---|
152 | static BUFFERED_STREAM * |
---|
153 | make_buffered_stream (fd, buffer, bufsize) |
---|
154 | int fd; |
---|
155 | char *buffer; |
---|
156 | size_t bufsize; |
---|
157 | { |
---|
158 | BUFFERED_STREAM *bp; |
---|
159 | |
---|
160 | bp = (BUFFERED_STREAM *)xmalloc (sizeof (BUFFERED_STREAM)); |
---|
161 | ALLOCATE_BUFFERS (fd); |
---|
162 | buffers[fd] = bp; |
---|
163 | bp->b_fd = fd; |
---|
164 | bp->b_buffer = buffer; |
---|
165 | bp->b_size = bufsize; |
---|
166 | bp->b_used = bp->b_inputp = bp->b_flag = 0; |
---|
167 | if (bufsize == 1) |
---|
168 | bp->b_flag |= B_UNBUFF; |
---|
169 | return (bp); |
---|
170 | } |
---|
171 | |
---|
172 | /* Allocate a new BUFFERED_STREAM, copy BP to it, and return the new copy. */ |
---|
173 | static BUFFERED_STREAM * |
---|
174 | copy_buffered_stream (bp) |
---|
175 | BUFFERED_STREAM *bp; |
---|
176 | { |
---|
177 | BUFFERED_STREAM *nbp; |
---|
178 | |
---|
179 | if (!bp) |
---|
180 | return ((BUFFERED_STREAM *)NULL); |
---|
181 | |
---|
182 | nbp = (BUFFERED_STREAM *)xmalloc (sizeof (BUFFERED_STREAM)); |
---|
183 | xbcopy ((char *)bp, (char *)nbp, sizeof (BUFFERED_STREAM)); |
---|
184 | return (nbp); |
---|
185 | } |
---|
186 | |
---|
187 | int |
---|
188 | set_bash_input_fd (fd) |
---|
189 | int fd; |
---|
190 | { |
---|
191 | if (bash_input.type == st_bstream) |
---|
192 | bash_input.location.buffered_fd = fd; |
---|
193 | else if (interactive_shell == 0) |
---|
194 | default_buffered_input = fd; |
---|
195 | return 0; |
---|
196 | } |
---|
197 | |
---|
198 | int |
---|
199 | fd_is_bash_input (fd) |
---|
200 | int fd; |
---|
201 | { |
---|
202 | if (bash_input.type == st_bstream && bash_input.location.buffered_fd == fd) |
---|
203 | return 1; |
---|
204 | else if (interactive_shell == 0 && default_buffered_input == fd) |
---|
205 | return 1; |
---|
206 | return 0; |
---|
207 | } |
---|
208 | |
---|
209 | /* Save the buffered stream corresponding to file descriptor FD (which bash |
---|
210 | is using to read input) to a buffered stream associated with NEW_FD. If |
---|
211 | NEW_FD is -1, a new file descriptor is allocated with fcntl. The new |
---|
212 | file descriptor is returned on success, -1 on error. */ |
---|
213 | int |
---|
214 | save_bash_input (fd, new_fd) |
---|
215 | int fd, new_fd; |
---|
216 | { |
---|
217 | int nfd; |
---|
218 | |
---|
219 | /* Sync the stream so we can re-read from the new file descriptor. We |
---|
220 | might be able to avoid this by copying the buffered stream verbatim |
---|
221 | to the new file descriptor. */ |
---|
222 | if (buffers[fd]) |
---|
223 | sync_buffered_stream (fd); |
---|
224 | |
---|
225 | /* Now take care of duplicating the file descriptor that bash is |
---|
226 | using for input, so we can reinitialize it later. */ |
---|
227 | nfd = (new_fd == -1) ? fcntl (fd, F_DUPFD, 10) : new_fd; |
---|
228 | if (nfd == -1) |
---|
229 | { |
---|
230 | if (fcntl (fd, F_GETFD, 0) == 0) |
---|
231 | sys_error (_("cannot allocate new file descriptor for bash input from fd %d"), fd); |
---|
232 | return -1; |
---|
233 | } |
---|
234 | |
---|
235 | if (buffers[nfd]) |
---|
236 | { |
---|
237 | /* What's this? A stray buffer without an associated open file |
---|
238 | descriptor? Free up the buffer and report the error. */ |
---|
239 | internal_error (_("save_bash_input: buffer already exists for new fd %d"), nfd); |
---|
240 | free_buffered_stream (buffers[nfd]); |
---|
241 | } |
---|
242 | |
---|
243 | /* Reinitialize bash_input.location. */ |
---|
244 | if (bash_input.type == st_bstream) |
---|
245 | { |
---|
246 | bash_input.location.buffered_fd = nfd; |
---|
247 | fd_to_buffered_stream (nfd); |
---|
248 | close_buffered_fd (fd); /* XXX */ |
---|
249 | } |
---|
250 | else |
---|
251 | /* If the current input type is not a buffered stream, but the shell |
---|
252 | is not interactive and therefore using a buffered stream to read |
---|
253 | input (e.g. with an `eval exec 3>output' inside a script), note |
---|
254 | that the input fd has been changed. pop_stream() looks at this |
---|
255 | value and adjusts the input fd to the new value of |
---|
256 | default_buffered_input accordingly. */ |
---|
257 | bash_input_fd_changed++; |
---|
258 | |
---|
259 | if (default_buffered_input == fd) |
---|
260 | default_buffered_input = nfd; |
---|
261 | |
---|
262 | SET_CLOSE_ON_EXEC (nfd); |
---|
263 | return nfd; |
---|
264 | } |
---|
265 | |
---|
266 | /* Check that file descriptor FD is not the one that bash is currently |
---|
267 | using to read input from a script. FD is about to be duplicated onto, |
---|
268 | which means that the kernel will close it for us. If FD is the bash |
---|
269 | input file descriptor, we need to seek backwards in the script (if |
---|
270 | possible and necessary -- scripts read from stdin are still unbuffered), |
---|
271 | allocate a new file descriptor to use for bash input, and re-initialize |
---|
272 | the buffered stream. Make sure the file descriptor used to save bash |
---|
273 | input is set close-on-exec. Returns 0 on success, -1 on failure. This |
---|
274 | works only if fd is > 0 -- if fd == 0 and bash is reading input from |
---|
275 | fd 0, save_bash_input is used instead, to cooperate with input |
---|
276 | redirection (look at redir.c:add_undo_redirect()). */ |
---|
277 | int |
---|
278 | check_bash_input (fd) |
---|
279 | int fd; |
---|
280 | { |
---|
281 | if (fd_is_bash_input (fd)) |
---|
282 | { |
---|
283 | if (fd > 0) |
---|
284 | return ((save_bash_input (fd, -1) == -1) ? -1 : 0); |
---|
285 | else if (fd == 0) |
---|
286 | return ((sync_buffered_stream (fd) == -1) ? -1 : 0); |
---|
287 | } |
---|
288 | return 0; |
---|
289 | } |
---|
290 | |
---|
291 | /* This is the buffered stream analogue of dup2(fd1, fd2). The |
---|
292 | BUFFERED_STREAM corresponding to fd2 is deallocated, if one exists. |
---|
293 | BUFFERS[fd1] is copied to BUFFERS[fd2]. This is called by the |
---|
294 | redirect code for constructs like 4<&0 and 3</etc/rc.local. */ |
---|
295 | int |
---|
296 | duplicate_buffered_stream (fd1, fd2) |
---|
297 | int fd1, fd2; |
---|
298 | { |
---|
299 | int is_bash_input, m; |
---|
300 | |
---|
301 | if (fd1 == fd2) |
---|
302 | return 0; |
---|
303 | |
---|
304 | m = max (fd1, fd2); |
---|
305 | ALLOCATE_BUFFERS (m); |
---|
306 | |
---|
307 | /* If FD2 is the file descriptor bash is currently using for shell input, |
---|
308 | we need to do some extra work to make sure that the buffered stream |
---|
309 | actually exists (it might not if fd1 was not active, and the copy |
---|
310 | didn't actually do anything). */ |
---|
311 | is_bash_input = (bash_input.type == st_bstream) && |
---|
312 | (bash_input.location.buffered_fd == fd2); |
---|
313 | |
---|
314 | if (buffers[fd2]) |
---|
315 | free_buffered_stream (buffers[fd2]); |
---|
316 | buffers[fd2] = copy_buffered_stream (buffers[fd1]); |
---|
317 | if (buffers[fd2]) |
---|
318 | buffers[fd2]->b_fd = fd2; |
---|
319 | |
---|
320 | if (is_bash_input) |
---|
321 | { |
---|
322 | if (!buffers[fd2]) |
---|
323 | fd_to_buffered_stream (fd2); |
---|
324 | buffers[fd2]->b_flag |= B_WASBASHINPUT; |
---|
325 | } |
---|
326 | |
---|
327 | return (fd2); |
---|
328 | } |
---|
329 | |
---|
330 | /* Return 1 if a seek on FD will succeed. */ |
---|
331 | #ifndef __CYGWIN__ |
---|
332 | # define fd_is_seekable(fd) (lseek ((fd), 0L, SEEK_CUR) >= 0) |
---|
333 | #else |
---|
334 | # define fd_is_seekable(fd) 0 |
---|
335 | #endif /* __CYGWIN__ */ |
---|
336 | |
---|
337 | /* Take FD, a file descriptor, and create and return a buffered stream |
---|
338 | corresponding to it. If something is wrong and the file descriptor |
---|
339 | is invalid, return a NULL stream. */ |
---|
340 | BUFFERED_STREAM * |
---|
341 | fd_to_buffered_stream (fd) |
---|
342 | int fd; |
---|
343 | { |
---|
344 | char *buffer; |
---|
345 | size_t size; |
---|
346 | struct stat sb; |
---|
347 | |
---|
348 | if (fstat (fd, &sb) < 0) |
---|
349 | { |
---|
350 | close (fd); |
---|
351 | return ((BUFFERED_STREAM *)NULL); |
---|
352 | } |
---|
353 | |
---|
354 | size = (fd_is_seekable (fd)) ? min (sb.st_size, MAX_INPUT_BUFFER_SIZE) : 1; |
---|
355 | if (size == 0) |
---|
356 | size = 1; |
---|
357 | buffer = (char *)xmalloc (size); |
---|
358 | |
---|
359 | return (make_buffered_stream (fd, buffer, size)); |
---|
360 | } |
---|
361 | |
---|
362 | /* Return a buffered stream corresponding to FILE, a file name. */ |
---|
363 | BUFFERED_STREAM * |
---|
364 | open_buffered_stream (file) |
---|
365 | char *file; |
---|
366 | { |
---|
367 | int fd; |
---|
368 | |
---|
369 | fd = open (file, O_RDONLY); |
---|
370 | return ((fd >= 0) ? fd_to_buffered_stream (fd) : (BUFFERED_STREAM *)NULL); |
---|
371 | } |
---|
372 | |
---|
373 | /* Deallocate a buffered stream and free up its resources. Make sure we |
---|
374 | zero out the slot in BUFFERS that points to BP. */ |
---|
375 | void |
---|
376 | free_buffered_stream (bp) |
---|
377 | BUFFERED_STREAM *bp; |
---|
378 | { |
---|
379 | int n; |
---|
380 | |
---|
381 | if (!bp) |
---|
382 | return; |
---|
383 | |
---|
384 | n = bp->b_fd; |
---|
385 | if (bp->b_buffer) |
---|
386 | free (bp->b_buffer); |
---|
387 | free (bp); |
---|
388 | buffers[n] = (BUFFERED_STREAM *)NULL; |
---|
389 | } |
---|
390 | |
---|
391 | /* Close the file descriptor associated with BP, a buffered stream, and free |
---|
392 | up the stream. Return the status of closing BP's file descriptor. */ |
---|
393 | int |
---|
394 | close_buffered_stream (bp) |
---|
395 | BUFFERED_STREAM *bp; |
---|
396 | { |
---|
397 | int fd; |
---|
398 | |
---|
399 | if (!bp) |
---|
400 | return (0); |
---|
401 | fd = bp->b_fd; |
---|
402 | free_buffered_stream (bp); |
---|
403 | return (close (fd)); |
---|
404 | } |
---|
405 | |
---|
406 | /* Deallocate the buffered stream associated with file descriptor FD, and |
---|
407 | close FD. Return the status of the close on FD. */ |
---|
408 | int |
---|
409 | close_buffered_fd (fd) |
---|
410 | int fd; |
---|
411 | { |
---|
412 | if (fd < 0) |
---|
413 | { |
---|
414 | errno = EBADF; |
---|
415 | return -1; |
---|
416 | } |
---|
417 | if (fd >= nbuffers || !buffers || !buffers[fd]) |
---|
418 | return (close (fd)); |
---|
419 | return (close_buffered_stream (buffers[fd])); |
---|
420 | } |
---|
421 | |
---|
422 | /* Make the BUFFERED_STREAM associcated with buffers[FD] be BP, and return |
---|
423 | the old BUFFERED_STREAM. */ |
---|
424 | BUFFERED_STREAM * |
---|
425 | set_buffered_stream (fd, bp) |
---|
426 | int fd; |
---|
427 | BUFFERED_STREAM *bp; |
---|
428 | { |
---|
429 | BUFFERED_STREAM *ret; |
---|
430 | |
---|
431 | ret = buffers[fd]; |
---|
432 | buffers[fd] = bp; |
---|
433 | return ret; |
---|
434 | } |
---|
435 | |
---|
436 | /* Read a buffer full of characters from BP, a buffered stream. */ |
---|
437 | static int |
---|
438 | b_fill_buffer (bp) |
---|
439 | BUFFERED_STREAM *bp; |
---|
440 | { |
---|
441 | ssize_t nr; |
---|
442 | |
---|
443 | nr = zread (bp->b_fd, bp->b_buffer, bp->b_size); |
---|
444 | if (nr <= 0) |
---|
445 | { |
---|
446 | bp->b_used = 0; |
---|
447 | bp->b_buffer[0] = 0; |
---|
448 | if (nr == 0) |
---|
449 | bp->b_flag |= B_EOF; |
---|
450 | else |
---|
451 | bp->b_flag |= B_ERROR; |
---|
452 | return (EOF); |
---|
453 | } |
---|
454 | |
---|
455 | #if defined (__CYGWIN__) |
---|
456 | /* If on cygwin, translate \r\n to \n. */ |
---|
457 | if (nr >= 2 && bp->b_buffer[nr - 2] == '\r' && bp->b_buffer[nr - 1] == '\n') |
---|
458 | { |
---|
459 | bp->b_buffer[nr - 2] = '\n'; |
---|
460 | nr--; |
---|
461 | } |
---|
462 | #endif |
---|
463 | |
---|
464 | bp->b_used = nr; |
---|
465 | bp->b_inputp = 0; |
---|
466 | return (bp->b_buffer[bp->b_inputp++] & 0xFF); |
---|
467 | } |
---|
468 | |
---|
469 | /* Get a character from buffered stream BP. */ |
---|
470 | #define bufstream_getc(bp) \ |
---|
471 | (bp->b_inputp == bp->b_used || !bp->b_used) \ |
---|
472 | ? b_fill_buffer (bp) \ |
---|
473 | : bp->b_buffer[bp->b_inputp++] & 0xFF |
---|
474 | |
---|
475 | /* Push C back onto buffered stream BP. */ |
---|
476 | static int |
---|
477 | bufstream_ungetc(c, bp) |
---|
478 | int c; |
---|
479 | BUFFERED_STREAM *bp; |
---|
480 | { |
---|
481 | if (c == EOF || bp->b_inputp == 0) |
---|
482 | return (EOF); |
---|
483 | |
---|
484 | bp->b_buffer[--bp->b_inputp] = c; |
---|
485 | return (c); |
---|
486 | } |
---|
487 | |
---|
488 | /* Seek backwards on file BFD to synchronize what we've read so far |
---|
489 | with the underlying file pointer. */ |
---|
490 | int |
---|
491 | sync_buffered_stream (bfd) |
---|
492 | int bfd; |
---|
493 | { |
---|
494 | BUFFERED_STREAM *bp; |
---|
495 | off_t chars_left; |
---|
496 | |
---|
497 | if (buffers == 0 || (bp = buffers[bfd]) == 0) |
---|
498 | return (-1); |
---|
499 | |
---|
500 | chars_left = bp->b_used - bp->b_inputp; |
---|
501 | if (chars_left) |
---|
502 | lseek (bp->b_fd, -chars_left, SEEK_CUR); |
---|
503 | bp->b_used = bp->b_inputp = 0; |
---|
504 | return (0); |
---|
505 | } |
---|
506 | |
---|
507 | int |
---|
508 | buffered_getchar () |
---|
509 | { |
---|
510 | #if !defined (DJGPP) |
---|
511 | return (bufstream_getc (buffers[bash_input.location.buffered_fd])); |
---|
512 | #else |
---|
513 | /* On DJGPP, ignore \r. */ |
---|
514 | int ch; |
---|
515 | while ((ch = bufstream_getc (buffers[bash_input.location.buffered_fd])) == '\r') |
---|
516 | ; |
---|
517 | return ch; |
---|
518 | #endif |
---|
519 | } |
---|
520 | |
---|
521 | int |
---|
522 | buffered_ungetchar (c) |
---|
523 | int c; |
---|
524 | { |
---|
525 | return (bufstream_ungetc (c, buffers[bash_input.location.buffered_fd])); |
---|
526 | } |
---|
527 | |
---|
528 | /* Make input come from file descriptor BFD through a buffered stream. */ |
---|
529 | void |
---|
530 | with_input_from_buffered_stream (bfd, name) |
---|
531 | int bfd; |
---|
532 | char *name; |
---|
533 | { |
---|
534 | INPUT_STREAM location; |
---|
535 | BUFFERED_STREAM *bp; |
---|
536 | |
---|
537 | location.buffered_fd = bfd; |
---|
538 | /* Make sure the buffered stream exists. */ |
---|
539 | bp = fd_to_buffered_stream (bfd); |
---|
540 | init_yy_io (bp == 0 ? return_EOF : buffered_getchar, |
---|
541 | buffered_ungetchar, st_bstream, name, location); |
---|
542 | } |
---|
543 | |
---|
544 | #if defined (TEST) |
---|
545 | void * |
---|
546 | xmalloc(s) |
---|
547 | int s; |
---|
548 | { |
---|
549 | return (malloc (s)); |
---|
550 | } |
---|
551 | |
---|
552 | void * |
---|
553 | xrealloc(s, size) |
---|
554 | char *s; |
---|
555 | int size; |
---|
556 | { |
---|
557 | if (!s) |
---|
558 | return(malloc (size)); |
---|
559 | else |
---|
560 | return(realloc (s, size)); |
---|
561 | } |
---|
562 | |
---|
563 | void |
---|
564 | init_yy_io () |
---|
565 | { |
---|
566 | } |
---|
567 | |
---|
568 | process(bp) |
---|
569 | BUFFERED_STREAM *bp; |
---|
570 | { |
---|
571 | int c; |
---|
572 | |
---|
573 | while ((c = bufstream_getc(bp)) != EOF) |
---|
574 | putchar(c); |
---|
575 | } |
---|
576 | |
---|
577 | BASH_INPUT bash_input; |
---|
578 | |
---|
579 | struct stat dsb; /* can be used from gdb */ |
---|
580 | |
---|
581 | /* imitate /bin/cat */ |
---|
582 | main(argc, argv) |
---|
583 | int argc; |
---|
584 | char **argv; |
---|
585 | { |
---|
586 | register int i; |
---|
587 | BUFFERED_STREAM *bp; |
---|
588 | |
---|
589 | if (argc == 1) { |
---|
590 | bp = fd_to_buffered_stream (0); |
---|
591 | process(bp); |
---|
592 | exit(0); |
---|
593 | } |
---|
594 | for (i = 1; i < argc; i++) { |
---|
595 | if (argv[i][0] == '-' && argv[i][1] == '\0') { |
---|
596 | bp = fd_to_buffered_stream (0); |
---|
597 | if (!bp) |
---|
598 | continue; |
---|
599 | process(bp); |
---|
600 | free_buffered_stream (bp); |
---|
601 | } else { |
---|
602 | bp = open_buffered_stream (argv[i]); |
---|
603 | if (!bp) |
---|
604 | continue; |
---|
605 | process(bp); |
---|
606 | close_buffered_stream (bp); |
---|
607 | } |
---|
608 | } |
---|
609 | exit(0); |
---|
610 | } |
---|
611 | #endif /* TEST */ |
---|
612 | #endif /* BUFFERED_INPUT */ |
---|