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
|
/* estream.h - Extended stream I/O/ Library
Copyright (C) 2004 g10 Code GmbH
This file is part of Libestream.
Libestream 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 2 of the License,
or (at your option) any later version.
Libestream 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
Lesser General Public License for more details.
You should have received a copy of the GNU General Public License
along with Libestream; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#ifndef ESTREAM_H
#define ESTREAM_H
#include <sys/types.h>
#include <stdarg.h>
#include <stdio.h>
typedef struct estream_public *estream_t;
typedef struct estream_internal *estream_internal_t;
/* This struct is entirely private - use it and you will shoot
yourself in the foot. */
struct estream_public
{
estream_internal_t internal;
unsigned char *buffer;
size_t buffer_size;
size_t data_size;
off_t data_offset;
size_t data_flushed;
unsigned char *unread_buffer;
size_t unread_buffer_size;
off_t unread_data_offset;
unsigned int dirty: 1;
};
typedef ssize_t (*es_cookie_read_function_t) (void *cookie,
char *buffer, size_t size);
typedef ssize_t (*es_cookie_write_function_t) (void *cookie,
const char *buffer, size_t size);
typedef int (*es_cookie_seek_function_t) (void *cookie,
off_t *pos, int whence);
typedef int (*es_cookie_close_function_t) (void *cookie);
typedef struct es_cookie_io_functions
{
es_cookie_read_function_t func_read;
es_cookie_write_function_t func_write;
es_cookie_seek_function_t func_seek;
es_cookie_close_function_t func_close;
} es_cookie_io_functions_t;
#define restrict
int es_init (void);
estream_t es_fopen (const char * restrict path, const char * restrict mode);
estream_t es_mopen (unsigned char *data, size_t data_n, size_t data_size,
unsigned int grow,
void *(*func_realloc) (void *mem, size_t size),
void (*func_free) (void *mem),
const char * restrict mode);
estream_t es_open_memstream (char **ptr, size_t *size);
estream_t es_fdopen (int filedes, const char *mode);
estream_t es_freopen (const char *path, const char *mode, estream_t stream);
estream_t es_fopencookie (void *cookie,
const char * restrict mode, es_cookie_io_functions_t functions);
int es_fclose (estream_t stream);
int es_fileno (estream_t stream);
int es_fileno_unlocked (estream_t stream);
void es_flockfile (estream_t stream);
int es_ftrylockfile (estream_t stream);
void es_funlockfile (estream_t stream);
int es_feof (estream_t stream);
int es_feof_unlocked (estream_t stream);
int es_ferror (estream_t stream);
int es_ferror_unlocked (estream_t stream);
void es_clearerr (estream_t stream);
void es_clearerr_unlocked (estream_t stream);
int es_fflush (estream_t stream);
int es_fseek (estream_t stream, long int offset, int whence);
int es_fseeko (estream_t stream, off_t offset, int whence);
long int es_ftell (estream_t stream);
off_t es_ftello (estream_t stream);
void es_rewind (estream_t stream);
int es_fgetc (estream_t stream);
int es_fputc (int c, estream_t stream);
int _es_getc_underflow (estream_t stream);
int _es_putc_overflow (int c, estream_t stream);
#define es_getc_unlocked(stream) \
(((! (stream)->dirty) \
&& ((stream)->data_offset < (stream)->data_size) \
&& (! (stream)->unread_data_offset)) ? \
((int) (unsigned char) \
(stream)->buffer[((stream)->data_offset)++]) : \
_es_getc_underflow ((stream)))
#define es_putc_unlocked(c, stream) \
(((stream)->dirty \
&& ((stream)->data_offset < (stream)->buffer_size) \
&& (c != '\n')) ? \
((int) (unsigned char) \
(stream)->buffer[((stream)->data_offset)++] = (c)) : \
_es_putc_overflow ((c), (stream)))
#define es_getc(stream) \
es_fgetc (stream)
#define es_putc(c, stream) \
es_fputc (c, stream)
int es_ungetc (int c, estream_t stream);
int es_read (estream_t stream,
char *buffer, size_t bytes_to_read, size_t *bytes_read);
int es_write (estream_t stream,
const char *buffer, size_t bytes_to_write, size_t *bytes_written);
size_t es_fread (void * restrict ptr, size_t size, size_t nitems,
estream_t restrict stream);
size_t es_fwrite (const void * restrict ptr, size_t size, size_t memb,
estream_t restrict stream);
char *es_fgets (char * restrict s, int n, estream_t restrict stream);
int es_fputs (const char * restrict s, estream_t restrict stream);
ssize_t es_getline (char **lineptr, size_t *n, estream_t stream);
int es_fprintf (estream_t restrict stream, const char * restrict format, ...);
int es_vfprintf (estream_t restrict stream, const char *restrict format,
va_list ap);
int es_setvbuf (estream_t restrict stream,
char * restrict buf, int mode, size_t size);
void es_setbuf (estream_t restrict stream, char * restrict buf);
estream_t es_tmpfile (void);
void es_opaque_set (estream_t stream, void *opaque);
void *es_opaque_get (estream_t stream);
#endif
|
