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