update from main archive 960907
[kopensolaris-gnu/glibc.git] / libio / libioP.h
1 /*
2 Copyright (C) 1993 Free Software Foundation
3
4 This file is part of the GNU IO Library.  This library is free
5 software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option)
8 any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this library; see the file COPYING.  If not, write to the Free
17 Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 As a special exception, if you link this library with files
20 compiled with a GNU compiler to produce an executable, this does not cause
21 the resulting executable to be covered by the GNU General Public License.
22 This exception does not however invalidate any other reasons why
23 the executable file might be covered by the GNU General Public License. */
24
25 #include <errno.h>
26 #ifndef errno
27 extern int errno;
28 #endif
29 #include <libc-lock.h>
30
31 #include "iolibio.h"
32
33 #if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(__cplusplus)
34 /* All known AIX compilers implement these things (but don't always
35    define __STDC__).  The RISC/OS MIPS compiler defines these things
36    in SVR4 mode, but does not define __STDC__.  */
37
38 #define AND             ,
39 #define DEFUN(name, arglist, args)      name(args)
40 #define DEFUN_VOID(name)                name(void)
41
42 #else   /* Not ANSI C.  */
43
44 #define AND             ;
45 #ifndef const /* some systems define it in header files for non-ansi mode */
46 #define const
47 #endif
48 #define DEFUN(name, arglist, args)      name arglist args;
49 #define DEFUN_VOID(name)                name()
50 #endif  /* ANSI C.  */
51
52 #ifdef __cplusplus
53 extern "C" {
54 #endif
55
56 #define _IO_seek_set 0
57 #define _IO_seek_cur 1
58 #define _IO_seek_end 2
59
60 typedef int (*_IO_overflow_t) __P((_IO_FILE*, int));
61 typedef int (*_IO_underflow_t) __P((_IO_FILE*));
62 typedef _IO_size_t (*_IO_xsputn_t) __P((_IO_FILE*,const void*,_IO_size_t));
63 typedef _IO_size_t (*_IO_xsgetn_t) __P((_IO_FILE*, void*, _IO_size_t));
64 typedef _IO_ssize_t (*_IO_read_t) __P((_IO_FILE*, void*, _IO_ssize_t));
65 typedef _IO_ssize_t (*_IO_write_t) __P((_IO_FILE*,const void*,_IO_ssize_t));
66 typedef int (*_IO_stat_t) __P((_IO_FILE*, void*));
67 typedef _IO_fpos_t (*_IO_seek_t) __P((_IO_FILE*, _IO_off_t, int));
68 typedef int (*_IO_doallocate_t) __P((_IO_FILE*));
69 typedef int (*_IO_pbackfail_t) __P((_IO_FILE*, int));
70 typedef _IO_FILE* (*_IO_setbuf_t) __P((_IO_FILE*, char *, _IO_ssize_t));
71 typedef int (*_IO_sync_t) __P((_IO_FILE*));
72 typedef void (*_IO_finish_t) __P((_IO_FILE*)); /* finalize */
73 typedef int (*_IO_close_t) __P((_IO_FILE*)); /* finalize */
74 typedef _IO_fpos_t (*_IO_seekoff_t) __P((_IO_FILE*, _IO_off_t, int, int));
75
76 /* The _IO_seek_cur and _IO_seek_end options are not allowed. */
77 typedef _IO_fpos_t (*_IO_seekpos_t) __P((_IO_FILE*, _IO_fpos_t, int));
78
79 #if  !_IO_UNIFIED_JUMPTABLES
80 #define _IO_JUMPS(THIS) (THIS)->_jumps
81 #else
82 #define _IO_JUMPS(THIS) ((struct _IO_FILE_plus*)(THIS))->vtable
83 #endif
84
85 #if  !_IO_UNIFIED_JUMPTABLES
86 #define JUMP_FIELD(TYPE, NAME) TYPE NAME
87 #define JUMP0(FUNC, THIS) _IO_JUMPS(THIS)->FUNC(THIS)
88 #define JUMP1(FUNC, THIS, X1) _IO_JUMPS(THIS)->FUNC(THIS, X1)
89 #define JUMP2(FUNC, THIS, X1, X2) _IO_JUMPS(THIS)->FUNC(THIS, X1, X2)
90 #define JUMP3(FUNC, THIS, X1, X2, X3) _IO_JUMPS(THIS)->FUNC(THIS, X1, X2, X3)
91 #define JUMP_INIT(NAME, VALUE) VALUE
92 #else
93 #define JUMP_FIELD(TYPE, NAME) struct { short delta1, delta2; TYPE pfn; } NAME
94 #define JUMP0(FUNC, THIS) _IO_JUMPS(THIS)->FUNC.pfn(THIS)
95 #define JUMP1(FUNC, THIS, X1) _IO_JUMPS(THIS)->FUNC.pfn(THIS, X1)
96 #define JUMP2(FUNC, THIS, X1, X2) _IO_JUMPS(THIS)->FUNC.pfn(THIS, X1, X2)
97 #define JUMP3(FUNC, THIS, X1,X2,X3) _IO_JUMPS(THIS)->FUNC.pfn(THIS, X1,X2, X3)
98 #define JUMP_INIT(NAME, VALUE) {0, 0, VALUE}
99 #endif
100 #define JUMP_INIT_DUMMY JUMP_INIT(dummy, 0)
101
102 #define _IO_FINISH(FP) JUMP0(__finish, FP)
103 #define _IO_OVERFLOW(FP, CH) JUMP1(__overflow, FP, CH)
104 #define _IO_UNDERFLOW(FP) JUMP0(__underflow, FP)
105 #define _IO_UFLOW(FP) JUMP0(__uflow, FP)
106 #define _IO_PBACKFAIL(FP, CH) JUMP1(__pbackfail, FP, CH)
107 #define _IO_XSPUTN(FP, DATA, N) JUMP2(__xsputn, FP, DATA, N)
108 #define _IO_XSGETN(FP, DATA, N) JUMP2(__xsgetn, FP, DATA, N)
109 #define _IO_SEEKOFF(FP, OFF, DIR, MODE) JUMP3(__seekoff, FP, OFF, DIR, MODE)
110 #define _IO_SEEKPOS(FP, POS, FLAGS) JUMP2(__seekpos, FP, POS, FLAGS)
111 #define _IO_SETBUF(FP, BUFFER, LENGTH) JUMP2(__setbuf, FP, BUFFER, LENGTH)
112 #define _IO_SYNC(FP) JUMP0(__sync, FP)
113 #define _IO_DOALLOCATE(FP) JUMP0(__doallocate, FP)
114 #define _IO_SYSREAD(FP, DATA, LEN) JUMP2(__read, FP, DATA, LEN)
115 #define _IO_SYSWRITE(FP, DATA, LEN) JUMP2(__write, FP, DATA, LEN)
116 #define _IO_SYSSEEK(FP, OFFSET, MODE) JUMP2(__seek, FP, OFFSET, MODE)
117 #define _IO_SYSCLOSE(FP) JUMP0(__close, FP)
118 #define _IO_SYSSTAT(FP, BUF) JUMP1(__stat, FP, BUF)
119
120 #define _IO_CHAR_TYPE char /* unsigned char ? */
121 #define _IO_INT_TYPE int
122
123 struct _IO_jump_t {
124     JUMP_FIELD(_G_size_t, __dummy);
125     JUMP_FIELD(_IO_finish_t, __finish);
126     JUMP_FIELD(_IO_overflow_t, __overflow);
127     JUMP_FIELD(_IO_underflow_t, __underflow);
128     JUMP_FIELD(_IO_underflow_t, __uflow);
129     JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
130     /* showmany */
131     JUMP_FIELD(_IO_xsputn_t, __xsputn);
132     JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
133     JUMP_FIELD(_IO_seekoff_t, __seekoff);
134     JUMP_FIELD(_IO_seekpos_t, __seekpos);
135     JUMP_FIELD(_IO_setbuf_t, __setbuf);
136     JUMP_FIELD(_IO_sync_t, __sync);
137     JUMP_FIELD(_IO_doallocate_t, __doallocate);
138     JUMP_FIELD(_IO_read_t, __read);
139     JUMP_FIELD(_IO_write_t, __write);
140     JUMP_FIELD(_IO_seek_t, __seek);
141     JUMP_FIELD(_IO_close_t, __close);
142     JUMP_FIELD(_IO_stat_t, __stat);
143 #if 0
144     get_column;
145     set_column;
146 #endif
147 };
148
149 /* We always allocate an extra word following an _IO_FILE.
150    This is for compatibility with C++ streambuf; the word can
151    be used to smash to a pointer to a virtual function table. */
152
153 struct _IO_FILE_plus {
154   _IO_FILE file;
155 #if _IO_UNIFIED_JUMPTABLES
156   const struct _IO_jump_t *vtable;
157 #else
158   const void *vtable;
159 #endif
160 };
161
162 /* Generic functions */
163
164 extern _IO_fpos_t _IO_seekoff __P((_IO_FILE*, _IO_off_t, int, int));
165 extern _IO_fpos_t _IO_seekpos __P((_IO_FILE*, _IO_fpos_t, int));
166
167 extern int _IO_switch_to_get_mode __P((_IO_FILE*));
168 extern void _IO_init __P((_IO_FILE*, int));
169 extern int _IO_sputbackc __P((_IO_FILE*, int));
170 extern int _IO_sungetc __P((_IO_FILE*));
171 extern void _IO_un_link __P((_IO_FILE*));
172 extern void _IO_link_in __P((_IO_FILE *));
173 extern void _IO_doallocbuf __P((_IO_FILE*));
174 extern void _IO_unsave_markers __P((_IO_FILE*));
175 extern void _IO_setb __P((_IO_FILE*, char*, char*, int));
176 extern unsigned _IO_adjust_column __P((unsigned, const char *, int));
177 #define _IO_sputn(__fp, __s, __n) _IO_XSPUTN(__fp, __s, __n)
178
179 /* Marker-related function. */
180
181 extern void _IO_init_marker __P((struct _IO_marker *, _IO_FILE *));
182 extern void _IO_remove_marker __P((struct _IO_marker*));
183 extern int _IO_marker_difference __P((struct _IO_marker *, struct _IO_marker *));
184 extern int _IO_marker_delta __P((struct _IO_marker *));
185 extern int _IO_seekmark __P((_IO_FILE *, struct _IO_marker *, int));
186
187 /* Default jumptable functions. */
188
189 extern int _IO_default_underflow __P((_IO_FILE*));
190 extern int _IO_default_uflow __P((_IO_FILE*));
191 extern int _IO_default_doallocate __P((_IO_FILE*));
192 extern void _IO_default_finish __P((_IO_FILE *));
193 extern int _IO_default_pbackfail __P((_IO_FILE*, int));
194 extern _IO_FILE* _IO_default_setbuf __P((_IO_FILE *, char*, _IO_ssize_t));
195 extern _IO_size_t _IO_default_xsputn __P((_IO_FILE *, const void*, _IO_size_t));
196 extern _IO_size_t _IO_default_xsgetn __P((_IO_FILE *, void*, _IO_size_t));
197 extern _IO_fpos_t _IO_default_seekoff __P((_IO_FILE*, _IO_off_t, int, int));
198 extern _IO_fpos_t _IO_default_seekpos __P((_IO_FILE*, _IO_fpos_t, int));
199 extern _IO_ssize_t _IO_default_write __P((_IO_FILE*,const void*,_IO_ssize_t));
200 extern _IO_ssize_t _IO_default_read __P((_IO_FILE*, void*, _IO_ssize_t));
201 extern int _IO_default_stat __P((_IO_FILE*, void*));
202 extern _IO_fpos_t _IO_default_seek __P((_IO_FILE*, _IO_off_t, int));
203 extern int _IO_default_sync __P((_IO_FILE*));
204 #define _IO_default_close ((_IO_close_t)_IO_default_sync)
205
206 extern struct _IO_jump_t _IO_file_jumps;
207 extern struct _IO_jump_t _IO_streambuf_jumps;
208 extern struct _IO_jump_t _IO_proc_jumps;
209 extern struct _IO_jump_t _IO_str_jumps;
210 extern int _IO_do_write __P((_IO_FILE*, const char*, _IO_size_t));
211 extern int _IO_flush_all __P((void));
212 extern void _IO_cleanup __P((void));
213 extern void _IO_flush_all_linebuffered __P((void));
214
215 #define _IO_do_flush(_f) \
216   _IO_do_write(_f, (_f)->_IO_write_base, \
217                (_f)->_IO_write_ptr-(_f)->_IO_write_base)
218 #define _IO_in_put_mode(_fp) ((_fp)->_flags & _IO_CURRENTLY_PUTTING)
219 #define _IO_mask_flags(fp, f, mask) \
220        ((fp)->_flags = ((fp)->_flags & ~(mask)) | ((f) & (mask)))
221 #define _IO_setg(fp, eb, g, eg)  ((fp)->_IO_read_base = (eb),\
222         (fp)->_IO_read_ptr = (g), (fp)->_IO_read_end = (eg))
223 #define _IO_setp(__fp, __p, __ep) \
224        ((__fp)->_IO_write_base = (__fp)->_IO_write_ptr = __p, (__fp)->_IO_write_end = (__ep))
225 #define _IO_have_backup(fp) ((fp)->_IO_save_base != NULL)
226 #define _IO_in_backup(fp) ((fp)->_flags & _IO_IN_BACKUP)
227 #define _IO_have_markers(fp) ((fp)->_markers != NULL)
228 #define _IO_blen(p) ((fp)->_IO_buf_end - (fp)->_IO_buf_base)
229
230 /* Jumptable functions for files. */
231
232 extern int _IO_file_doallocate __P((_IO_FILE*));
233 extern _IO_FILE* _IO_file_setbuf __P((_IO_FILE *, char*, _IO_ssize_t));
234 extern _IO_fpos_t _IO_file_seekoff __P((_IO_FILE*, _IO_off_t, int, int));
235 extern _IO_size_t _IO_file_xsputn __P((_IO_FILE*,const void*,_IO_size_t));
236 extern int _IO_file_stat __P((_IO_FILE*, void*));
237 extern int _IO_file_close __P((_IO_FILE*));
238 extern int _IO_file_underflow __P((_IO_FILE *));
239 extern int _IO_file_overflow __P((_IO_FILE *, int));
240 #define _IO_file_is_open(__fp) ((__fp)->_fileno >= 0)
241 extern void _IO_file_init __P((_IO_FILE*));
242 extern _IO_FILE* _IO_file_attach __P((_IO_FILE*, int));
243 extern _IO_FILE* _IO_file_fopen __P((_IO_FILE*, const char*, const char*));
244 extern _IO_ssize_t _IO_file_write __P((_IO_FILE*,const void*,_IO_ssize_t));
245 extern _IO_ssize_t _IO_file_read __P((_IO_FILE*, void*, _IO_ssize_t));
246 extern int _IO_file_sync __P((_IO_FILE*));
247 extern int _IO_file_close_it __P((_IO_FILE*));
248 extern _IO_fpos_t _IO_file_seek __P((_IO_FILE *, _IO_off_t, int));
249 extern void _IO_file_finish __P((_IO_FILE*));
250
251 /* Other file functions. */
252 extern _IO_FILE* _IO_file_attach __P((_IO_FILE *, int));
253
254 /* Jumptable functions for proc_files. */
255 extern _IO_FILE* _IO_proc_open __P((_IO_FILE*, const char*, const char *));
256 extern int _IO_proc_close __P((_IO_FILE*));
257
258 /* Jumptable functions for strfiles. */
259 extern int _IO_str_underflow __P((_IO_FILE*));
260 extern int _IO_str_overflow __P((_IO_FILE *, int));
261 extern int _IO_str_pbackfail __P((_IO_FILE*, int));
262 extern _IO_fpos_t _IO_str_seekoff __P((_IO_FILE*,_IO_off_t,int,int));
263 extern void _IO_str_finish __P ((_IO_FILE*));
264
265 /* Other strfile functions */
266 extern void _IO_str_init_static __P((_IO_FILE *, char*, int, char*));
267 extern void _IO_str_init_readonly __P((_IO_FILE *, const char*, int));
268 extern _IO_ssize_t _IO_str_count __P ((_IO_FILE*));
269
270 extern int _IO_vasprintf __P ((char **result_ptr, __const char *format,
271                                _IO_va_list args));
272 extern int _IO_vdprintf __P ((int d, __const char *format, _IO_va_list arg));
273 extern int _IO_vsnprintf __P ((char *string, _IO_size_t maxlen,
274                                __const char *format, _IO_va_list args));
275
276
277 extern _IO_size_t _IO_getline __P((_IO_FILE*,char*,_IO_size_t,int,int));
278 extern _IO_ssize_t _IO_getdelim __P((char**, _IO_size_t*, int, _IO_FILE*));
279 extern double _IO_strtod __P((const char *, char **));
280 extern char * _IO_dtoa __P((double __d, int __mode, int __ndigits,
281                                 int *__decpt, int *__sign, char **__rve));
282 extern int _IO_outfloat __P((double __value, _IO_FILE *__sb, int __type,
283                                  int __width, int __precision, int __flags,
284                                  int __sign_mode, int __fill));
285
286 extern _IO_FILE *_IO_list_all;
287 extern void (*_IO_cleanup_registration_needed) __P ((void));
288
289 #ifndef EOF
290 #define EOF (-1)
291 #endif
292 #ifndef NULL
293 #if !defined(__cplusplus) || defined(__GNUC__)
294 #define NULL ((void*)0)
295 #else
296 #define NULL (0)
297 #endif
298 #endif
299
300 #define FREE_BUF(_B) free(_B)
301 #define ALLOC_BUF(_S) (char*)malloc(_S)
302
303 #ifndef OS_FSTAT
304 #define OS_FSTAT fstat
305 #endif
306 struct stat;
307 extern _IO_ssize_t _IO_read __P((int, void*, _IO_size_t));
308 extern _IO_ssize_t _IO_write __P((int, const void*, _IO_size_t));
309 extern _IO_off_t _IO_lseek __P((int, _IO_off_t, int));
310 extern int _IO_close __P((int));
311 extern int _IO_fstat __P((int, struct stat *));
312 extern int _IO_vscanf __P((const char *, _IO_va_list));
313
314 /* Operations on _IO_fpos_t.
315    Normally, these are trivial, but we provide hooks for configurations
316    where an _IO_fpos_t is a struct.
317    Note that _IO_off_t must be an integral type. */
318
319 /* _IO_pos_BAD is an _IO_fpos_t value indicating error, unknown, or EOF. */
320 #ifndef _IO_pos_BAD
321 #define _IO_pos_BAD ((_IO_fpos_t)(-1))
322 #endif
323 /* _IO_pos_as_off converts an _IO_fpos_t value to an _IO_off_t value. */
324 #ifndef _IO_pos_as_off
325 #define _IO_pos_as_off(__pos) ((_IO_off_t)(__pos))
326 #endif
327 /* _IO_pos_adjust adjust an _IO_fpos_t by some number of bytes. */
328 #ifndef _IO_pos_adjust
329 #define _IO_pos_adjust(__pos, __delta) ((__pos) += (__delta))
330 #endif
331 /* _IO_pos_0 is an _IO_fpos_t value indicating beginning of file. */
332 #ifndef _IO_pos_0
333 #define _IO_pos_0 ((_IO_fpos_t)0)
334 #endif
335
336 #ifdef __cplusplus
337 }
338 #endif
339
340 #if  _IO_UNIFIED_JUMPTABLES
341 #define _IO_FJUMP /* nothing */
342 #else
343 #define _IO_FJUMP &_IO_file_jumps,
344 #endif
345 #ifdef _IO_MTSAFE_IO
346 /* check following! */
347 #define FILEBUF_LITERAL(CHAIN, FLAGS, FD) \
348        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
349          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, CHAIN, _IO_FJUMP FD, \
350            0, 0, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock }
351 #else
352 /* check following! */
353 #define FILEBUF_LITERAL(CHAIN, FLAGS, FD) \
354        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
355            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, CHAIN, _IO_FJUMP FD }
356 #endif
357
358 /* VTABLE_LABEL defines NAME as of the CLASS class.
359    CNLENGTH is strlen(#CLASS).  */
360 #ifdef __GNUC__
361 #if _G_VTABLE_LABEL_HAS_LENGTH
362 #define VTABLE_LABEL(NAME, CLASS, CNLENGTH) \
363   extern char NAME[] asm (_G_VTABLE_LABEL_PREFIX #CNLENGTH #CLASS);
364 #else
365 #define VTABLE_LABEL(NAME, CLASS, CNLENGTH) \
366   extern char NAME[] asm (_G_VTABLE_LABEL_PREFIX #CLASS);
367 #endif
368 #endif /* __GNUC__ */
369
370 #if !defined(builtinbuf_vtable) && defined(__cplusplus)
371 #ifdef __GNUC__
372 VTABLE_LABEL(builtinbuf_vtable, builtinbuf, 10)
373 #else
374 #if _G_VTABLE_LABEL_HAS_LENGTH
375 #define builtinbuf_vtable _G_VTABLE_LABEL_PREFIX_ID##10builtinbuf
376 #else
377 #define builtinbuf_vtable _G_VTABLE_LABEL_PREFIX_ID##builtinbuf
378 #endif
379 #endif
380 #endif /* !defined(builtinbuf_vtable) && defined(__cplusplus) */
381
382 #if defined(__STDC__) || defined(__cplusplus)
383 #define _IO_va_start(args, last) va_start(args, last)
384 #else
385 #define _IO_va_start(args, last) va_start(args)
386 #endif
387
388 extern struct _IO_fake_stdiobuf _IO_stdin_buf, _IO_stdout_buf, _IO_stderr_buf;
389
390 #if 1
391 #define COERCE_FILE(FILE) /* Nothing */
392 #else
393 /* This is part of the kludge for binary compatibility with old stdio. */
394 #define COERCE_FILE(FILE) \
395   (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) == _OLD_MAGIC_MASK \
396     && (FILE) = *(FILE**)&((int*)fp)[1])
397 #endif
398
399 #ifdef EINVAL
400 #define MAYBE_SET_EINVAL errno = EINVAL
401 #else
402 #define MAYBE_SET_EINVAL /* nothing */
403 #endif
404
405 #ifdef DEBUG
406 #define CHECK_FILE(FILE,RET) \
407         if ((FILE) == NULL) { MAYBE_SET_EINVAL; return RET; } \
408         else { COERCE_FILE(FILE); \
409                if (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) != _IO_MAGIC) \
410           { errno = EINVAL; return RET; }}
411 #else
412 #define CHECK_FILE(FILE,RET) \
413         COERCE_FILE(FILE)
414 #endif