1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/* Copyright (C) 1992 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
#include <ansidecl.h>
#include <stdio.h>
#include <obstack.h>
#include <stdarg.h>
#include <string.h>
/* Output-room function for obstack streams. */
static void
DEFUN(grow, (stream, c), FILE *stream AND int c)
{
struct obstack *const obstack = (struct obstack *) stream->__cookie;
/* Move the end of the object back to include only the portion
of the buffer which the user has already written into. */
obstack_blank_fast (obstack, - (stream->__put_limit - stream->__bufp));
if (stream->__target > obstack_object_size (obstack))
{
/* Our target (where the buffer maps to) is always zero except when
the user just did a SEEK_END fseek. If he sought within the
buffer, we need do nothing and will zero the target below. If he
sought past the end of the object, grow and zero-fill the object
up to the target address. */
obstack_blank (obstack,
stream->__target - obstack_object_size (obstack));
/* fseek has just flushed us, so the put limit points
to the end of the written data. */
bzero (stream->__put_limit,
stream->__target - stream->__bufsize);
}
if (c != EOF)
obstack_1grow (obstack, (unsigned char) c);
/* The stream buffer always maps exactly to the object on the top
of the obstack. The start of the buffer is the start of the object.
The put limit points just past the end of the object. On fflush, the
obstack is sync'd so the end of the object points just past the last
character written to the stream. */
stream->__target = stream->__offset = 0;
stream->__buffer = obstack_base (obstack);
stream->__bufsize = obstack_room (obstack);
stream->__bufp = obstack_next_free (obstack);
stream->__get_limit = stream->__bufp;
if (c == EOF)
/* This is fflush. Make the stream buffer, the object,
and the characters actually written all match. */
stream->__put_limit = stream->__get_limit;
else
{
/* Extend the buffer (and the object) to include
the rest of the obstack chunk (which is unitialized).
Data past bufp is undefined. */
stream->__put_limit = stream->__buffer + stream->__bufsize;
obstack_blank_fast (obstack, stream->__put_limit - stream->__bufp);
}
}
/* Seek function for obstack streams.
There is no external state to munge. */
static int
DEFUN(seek, (cookie, pos, whence),
PTR cookie AND fpos_t *pos AND int whence)
{
switch (whence)
{
case SEEK_SET:
case SEEK_CUR:
return 0;
case SEEK_END:
/* Return the position relative to the end of the object.
fseek has just flushed us, so the obstack is consistent. */
*pos += obstack_object_size ((struct obstack *) cookie);
return 0;
default:
__libc_fatal ("obstream::seek called with bogus WHENCE\n");
return -1;
}
}
/* Input room function for obstack streams.
Only what has been written to the stream can be read back. */
static int
DEFUN(input, (stream), FILE *stream)
{
/* Re-sync with the obstack, growing the object if necessary. */
grow (stream, EOF);
if (stream->__bufp < stream->__get_limit)
return (unsigned char) *stream->__bufp++;
stream->__eof = 1;
return EOF;
}
/* Initialize STREAM to talk to OBSTACK. */
static void
DEFUN(init_obstream, (stream, obstack),
FILE *stream AND struct obstack *obstack)
{
stream->__mode.__write = 1;
stream->__mode.__read = 1;
/* Input can read only what has been written. */
stream->__room_funcs.__input = input;
/* Do nothing for close. */
stream->__io_funcs.__close = NULL;
/* When the buffer is full, grow the obstack. */
stream->__room_funcs.__output = grow;
/* Seek within the object, and extend it. */
stream->__io_funcs.__seek = seek;
stream->__target = stream->__offset = 0;
stream->__seen = 1;
/* Don't deallocate that buffer! */
stream->__userbuf = 1;
/* We don't have to initialize the buffer.
The first read attempt will call grow, which will do all the work. */
}
FILE *
open_obstack_stream (obstack)
struct obstack *obstack;
{
register FILE *stream;
stream = __newstream ();
if (stream == NULL)
return NULL;
init_obstream (stream, obstack);
return stream;
}
int
DEFUN(obstack_vprintf, (obstack, format, args),
struct obstack *obstack AND const char *format AND va_list args)
{
FILE f;
bzero (&f, sizeof (f));
init_obstream (&f, obstack);
return vfprintf (&f, format, args);
}
int
DEFUN(obstack_printf, (obstack, format),
struct obstack *obstack AND const char *format DOTS)
{
int result;
va_list ap;
va_start (ap, format);
result = obstack_vprintf (obstack, format, ap);
va_end (ap);
return result;
}
|
