|
4223
|
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 }
|
