Mercurial > repo

comparison src/ploki/IO.c @ 4223:ac0403686959

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
<oerjan> rm -rf src/ploki; mv ploki src
author HackBot
date Fri, 20 Dec 2013 22:18:50 +0000
parents
children
comparison
equal deleted inserted replaced
4222:b0f3e267bb1e 4223:ac0403686959
1 #include "config.h"
2 #include "IO.h"
3 #include "Str.h"
4 #include "main.h"
5 #include "main_io.h"
6 #include "xmalloc.h"
7 #include "zz.h"
8
9 #include <errno.h>
10 #include <stdio.h>
11 #include <string.h>
12 #include <assert.h>
13
14 struct IO {
15 struct IO *prev, *next;
16 enum io_flags mode;
17 FILE *fp;
18 char *name;
19 size_t refs;
20 String *buf;
21 long told;
22 enum {
23 DI_NONE,
24 DI_RD,
25 DI_WR
26 } dirct;
27 };
28
29 static IO *Root;
30
31 static void sanitycheck(enum io_flags m) {
32 #if !DEBUG_P
33 (void)m;
34 #endif
35 assert(
36 (
37 m & IO_READ ||
38 m & IO_WRITE ||
39 m & IO_APPEND
40 ) &&
41 !(
42 m & IO_WRITE &&
43 m & IO_APPEND
44 ) &&
45 (
46 !(m & IO_BUFFERED) || m & IO_READ
47 ) &&
48 (
49 !(m & IO_AUTOFLUSH) ||
50 (
51 m & IO_WRITE ||
52 m & IO_APPEND
53 )
54 ) &&
55 (
56 !(m & IO_WRITE) || (m & IO_TRUNCATE || m & IO_READ)
57 ) &&
58 (
59 !(m & IO_TRUNCATE) || m & IO_WRITE
60 )
61 );
62 }
63
64 void io_init(void) {
65 }
66
67 static void io_delete(IO *io) {
68 if (io->mode & IO_BUFFERED) {
69 St_clear(io->buf);
70 xfree(io->buf);
71 }
72 if (io->fp && io->fp != stderr) {
73 if (fclose(io->fp)) {
74 fprintf(io_fp(Err), "%s: %s: %s\n", Prog, io->name, strerror(errno));
75 }
76 }
77 xfree(io->name);
78 if (io->prev) {
79 io->prev->next = io->next;
80 } else {
81 assert(io == Root);
82 Root = io->next;
83 }
84 if (io->next) {
85 io->next->prev = io->prev;
86 }
87 xfree(io);
88 }
89
90 void io_end(void) {
91 while (Root) {
92 io_delete(Root);
93 }
94 }
95
96 static char *xstrdup(const char *s) {
97 const size_t len = strlen(s) + 1;
98 char *const tmp = xmalloc(len, sizeof *tmp);
99 memcpy(tmp, s, len);
100 return tmp;
101 }
102
103 IO *io_enter(const char *name, FILE *fp, enum io_flags mode) {
104 IO *io;
105 sanitycheck(mode);
106 io = xmalloc(1, sizeof *io);
107 io->fp = fp;
108 io->mode = mode;
109 if (mode & IO_BUFFERED) {
110 io->buf = xmalloc(1, sizeof *io->buf);
111 St_init(io->buf);
112 io->told = -1;
113 }
114 io->name = xstrdup(name);
115 io->refs = 1;
116
117 io->dirct = DI_NONE;
118
119 io->prev = NULL;
120 io->next = Root;
121 if (Root) {
122 Root->prev = io;
123 }
124 Root = io;
125 return io;
126 }
127
128 const char *io_name(const IO *io, String *s) {
129 if (s) {
130 St_cpy_s(s, io->name);
131 }
132 return io->name;
133 }
134
135 IO *io_open(const char *name, enum io_flags mode) {
136 FILE *fp;
137 char mbuf[4], *p = mbuf;
138 sanitycheck(mode);
139
140 if (mode & IO_APPEND) {
141 *p++ = 'a';
142 if (mode & IO_READ) {
143 *p++ = '+';
144 }
145 } else if (mode & IO_WRITE) {
146 if (mode & IO_TRUNCATE) {
147 *p++ = 'w';
148 if (mode & IO_READ) {
149 *p++ = '+';
150 }
151 } else {
152 assert(mode & IO_READ);
153 *p++ = 'r';
154 *p++ = '+';
155 }
156 } else {
157 assert(mode & IO_READ);
158 *p++ = 'r';
159 }
160
161 if (mode & IO_BINARY) {
162 *p++ = 'b';
163 }
164 *p = '\0';
165
166 if (!(fp = fopen(name, mbuf))) {
167 return NULL;
168 }
169 return io_enter(name, fp, mode);
170 }
171
172 IO *io_incr(IO *io) {
173 ++io->refs;
174 return io;
175 }
176
177 void io_decr(IO *io) {
178 if (!--io->refs) {
179 io_delete(io);
180 }
181 }
182
183 int io_close(IO *io) {
184 int ret;
185 assert(io->fp != NULL);
186 ret = fclose(io->fp);
187 io->fp = NULL;
188 if (io->mode & IO_BUFFERED) {
189 St_clear(io->buf);
190 xfree(io->buf);
191 io->mode &= ~IO_BUFFERED;
192 }
193 return ret;
194 }
195
196 int io_bufred(const IO *io) {
197 return !!(io->mode & IO_BUFFERED);
198 }
199
200 void io_unbuffer(IO *io) {
201 assert(io->mode & IO_BUFFERED);
202 if (St_len(io->buf) && io->told != -1) {
203 io_seek(io, io->told, SEEK_SET);
204 }
205 St_clear(io->buf);
206 xfree(io->buf);
207 io->mode &= ~IO_BUFFERED;
208 }
209
210 FILE *io_fp(const IO *io) {
211 return io->fp;
212 }
213
214 static void bufk(IO *f, size_t n) {
215 String tmp;
216 assert(f->mode & IO_BUFFERED);
217
218 if (St_len(f->buf) >= n || feof(f->fp) || ferror(f->fp)) {
219 return;
220 }
221
222 assert(f->dirct != DI_WR);
223 #if 0
224 if (f->dirct == DI_WR) {
225 io_seek(f, 0, SEEK_CUR);
226 }
227 f->dirct = DI_RD;
228 #endif
229
230 if (!(St_len(f->buf) || f->mode & IO_BINARY)) {
231 f->told = ftell(f->fp);
232 }
233
234 St_init(&tmp);
235 while (
236 St_len(f->buf) < n &&
237 !feof(f->fp) && !ferror(f->fp) &&
238 St_read(&tmp, f->fp, n - St_len(f->buf))
239 ) {
240 St_cat(f->buf, &tmp);
241 }
242 St_clear(&tmp);
243 }
244
245 #ifdef EBADF
246 #define BADF ((void)(errno = EBADF))
247 #else
248 #define BADF ((void)0)
249 #endif
250
251 #define XMODE(c, x) \
252 do { \
253 if (!(c)) { \
254 BADF; \
255 return (x); \
256 } \
257 } while (0)
258
259 #define WMODE(f, x) XMODE((f)->mode & IO_WRITE || (f)->mode & IO_APPEND, (x))
260 #define PMODE(f, x) XMODE((f)->mode & IO_BUFFERED, (x))
261 #define RMODE(f, x) XMODE((f)->mode & IO_READ, (x))
262
263 const char *io_bufptr(IO *io) {
264 PMODE(io, NULL);
265 return St_ptr(io->buf);
266 }
267
268 int io_flush(IO *f) {
269 WMODE(f, EOF);
270 return fflush(f->fp);
271 }
272
273 int io_err(const IO *f) {
274 return ferror(f->fp);
275 }
276
277 int io_eof(const IO *f) {
278 return feof(f->fp);
279 }
280
281 int io_peek(IO *f, size_t pos) {
282 PMODE(f, EOF);
283 bufk(f, pos + 1);
284 if (St_len(f->buf) <= pos) {
285 return EOF;
286 }
287 return ST_INDEX(f->buf, pos);
288 }
289
290 int io_cmppeek(IO *f, size_t o, const void *p, size_t n) {
291 size_t i;
292 PMODE(f, -1);
293
294 for (i = 0; i < n; ++i) {
295 bufk(f, o + i + 1u);
296 if (ST_INDEX(f->buf, o + i) != i[(const unsigned char *)p]) {
297 return 1;
298 }
299 }
300 return 0;
301 }
302
303 int io_xcmp(IO *f, size_t a, size_t b, size_t n) {
304 const size_t max = a > b ? a : b;
305 PMODE(f, -1);
306 bufk(f, max + n);
307 if (St_len(f->buf) < max + n) {
308 return 1;
309 }
310 return memcmp(St_ptr(f->buf) + a, St_ptr(f->buf) + b, n) != 0;
311 }
312
313 size_t io_read(IO *f, String *s, size_t n) {
314 RMODE(f, -1);
315
316 if (f->mode & IO_BUFFERED) {
317 String null;
318 size_t old;
319
320 bufk(f, n);
321 old = St_len(f->buf);
322 St_init(&null);
323 St_substr(s, f->buf, 0, n, &null);
324 St_clear(&null);
325 old -= St_len(f->buf);
326 if (St_len(f->buf) && old && !(f->mode & IO_BINARY) && f->told != -1) {
327 const long keep = ftell(f->fp);
328 if (fseek(f->fp, f->told, SEEK_SET) != -1) {
329 size_t i;
330 for (i = 0; i < old; ++i) {
331 getc(f->fp);
332 }
333 f->told = ftell(f->fp);
334 f->dirct = DI_RD;
335 fseek(f->fp, keep, SEEK_SET);
336 }
337 }
338 return old;
339 } else {
340 if (f->dirct == DI_WR) {
341 fseek(f->fp, 0, SEEK_CUR);
342 }
343 f->dirct = DI_RD;
344 return St_read(s, f->fp, n);
345 }
346 }
347
348 int io_getc(IO *f) {
349 RMODE(f, EOF);
350
351 if (f->mode & IO_BUFFERED) {
352 int c;
353 bufk(f, 1);
354 c = St_shift(f->buf);
355 if (St_len(f->buf) && c != EOF && !(f->mode & IO_BINARY) && f->told != -1) {
356 const long keep = ftell(f->fp);
357 if (fseek(f->fp, f->told, SEEK_SET) != -1) {
358 getc(f->fp);
359 f->told = ftell(f->fp);
360 f->dirct = DI_RD;
361 fseek(f->fp, keep, SEEK_SET);
362 }
363 }
364 return c;
365 }
366
367 if (f->dirct == DI_WR) {
368 fseek(f->fp, 0, SEEK_CUR);
369 }
370 f->dirct = DI_RD;
371 return getc(f->fp);
372 }
373
374 size_t io_getline(IO *f, String *s) {
375 RMODE(f, -1);
376
377 if (f->mode & IO_BUFFERED) {
378 size_t p;
379 size_t old;
380
381 p = St_chr(f->buf, '\n') + 1u;
382 if (p) {
383 old = St_len(f->buf);
384 if (s) {
385 St_cpy_m(s, St_ptr(f->buf), p);
386 }
387 St_del(f->buf, 0, p);
388 } else {
389 for (p = St_len(f->buf); io_peek(f, p) != EOF; ++p) {
390 if (ST_LASTCHAR(f->buf) == '\n') {
391 break;
392 }
393 }
394 old = St_len(f->buf);
395 if (s) {
396 St_cpy(s, f->buf);
397 }
398 St_zero(f->buf);
399 }
400 old -= St_len(f->buf);
401 if (St_len(f->buf) && old && !(f->mode & IO_BINARY) && f->told != -1) {
402 const long keep = ftell(f->fp);
403 if (fseek(f->fp, f->told, SEEK_SET) != -1) {
404 size_t i;
405 for (i = 0; i < old; ++i) {
406 getc(f->fp);
407 }
408 f->dirct = DI_RD;
409 f->told = ftell(f->fp);
410 fseek(f->fp, keep, SEEK_SET);
411 }
412 }
413 return old;
414 } else {
415 int c;
416 size_t n;
417
418 if (f->dirct == DI_WR) {
419 fseek(f->fp, 0, SEEK_CUR);
420 }
421 f->dirct = DI_RD;
422
423 if (s) {
424 St_zero(s);
425 }
426 n = 0;
427 while ((c = getc(f->fp)) != EOF) {
428 if (s) {
429 St_cat_c(s, c);
430 }
431 ++n;
432 if (c == '\n') {
433 break;
434 }
435 }
436 if (!n && ferror(f->fp)) {
437 return -1;
438 }
439 return n;
440 }
441 }
442
443 size_t io_write(IO *f, const String *s) {
444 size_t ret;
445 WMODE(f, -1);
446 if (f->dirct == DI_RD) {
447 fseek(f->fp, 0, SEEK_CUR);
448 }
449 f->dirct = DI_WR;
450 ret = ST_WRITE(s, f->fp);
451 if (f->mode & IO_AUTOFLUSH) {
452 fflush(f->fp);
453 }
454 return ret;
455 }
456
457 size_t io_write_m(IO *f, const void *p, size_t n) {
458 size_t ret;
459 WMODE(f, -1);
460 if (f->dirct == DI_RD) {
461 fseek(f->fp, 0, SEEK_CUR);
462 }
463 f->dirct = DI_WR;
464 ret = fwrite(p, 1, n, f->fp);
465 if (f->mode & IO_AUTOFLUSH) {
466 fflush(f->fp);
467 }
468 return ret;
469 }
470
471 size_t io_write_s(IO *f, const char *s) {
472 return io_write_m(f, s, strlen(s));
473 }
474
475 int io_putc(IO *f, int c) {
476 int ret;
477 WMODE(f, EOF);
478 if (f->dirct == DI_RD) {
479 fseek(f->fp, 0, SEEK_CUR);
480 }
481 f->dirct = DI_WR;
482 ret = putc(c, f->fp);
483 if (f->mode & IO_AUTOFLUSH) {
484 fflush(f->fp);
485 }
486 return ret;
487 }
488
489 long io_tell(IO *f) {
490 if (f->mode & IO_BUFFERED) {
491 if (f->mode & IO_BINARY) {
492 const long ret = ftell(f->fp);
493 if (ret == -1) {
494 return ret;
495 }
496 return ret - St_len(f->buf);
497 }
498 if (St_len(f->buf)) {
499 return f->told;
500 }
501 }
502 return ftell(f->fp);
503 }
504
505 int io_seek(IO *f, long off, enum io_whence w) {
506 if (f->mode & IO_BUFFERED) {
507 St_zero(f->buf);
508 }
509 f->dirct = DI_NONE;
510 return fseek(f->fp, off, w);
511 }
512
513 void io_clearerr(IO *f) {
514 clearerr(f->fp);
515 }