From 4ad4e6c7f6d2fb414d22dd3e55801c85b02c1af7 Mon Sep 17 00:00:00 2001 From: zlg Date: Sat, 22 Dec 2018 01:23:35 -0800 Subject: Solve Exercise 8-2: fopen and fillbuf --- ch8/8-02_fopen-and-fillbuf.c | 101 ++++++++++++++++++++++++++++++++++++ ch8/8-02_stdlib-fopen-and-fillbuf.c | 33 ++++++++++++ ch8/8-02_syscalls.h | 47 +++++++++++++++++ 3 files changed, 181 insertions(+) create mode 100644 ch8/8-02_fopen-and-fillbuf.c create mode 100644 ch8/8-02_stdlib-fopen-and-fillbuf.c create mode 100644 ch8/8-02_syscalls.h diff --git a/ch8/8-02_fopen-and-fillbuf.c b/ch8/8-02_fopen-and-fillbuf.c new file mode 100644 index 0000000..e533da8 --- /dev/null +++ b/ch8/8-02_fopen-and-fillbuf.c @@ -0,0 +1,101 @@ +#include +#include +#include +#include +#include "8-02_syscalls.h" + +/* The C Programming Language: 2nd Edition + * + * Exercise 8-2: Rewrite `fopen` and `_fillbuf` with fields instead of explicit + * bit operations. Compare code size and execution speed. + * + * Notes: Fields, in this case, are struct fields. I implemented them as 1-bit + * integers to simulate bit fields via struct. + * + * The resulting binary of this file (plus the custom header) runs through this + * source file in about 0.001s. However, the binary is 1KB larger. + */ + +#define PERMS 0666 + +int getc(FILE *); + +int my__fillbuf(my_FILE *fp) { + int bufsize; + if (fp->flags._READ == 0) { + return EOF; + } + bufsize = (fp->flags._UNBUF != 0) ? 1 : BUFSIZ; + if (fp->base == NULL) { + if ((fp->base = (char *) calloc(bufsize, sizeof (char))) == NULL) { + return EOF; + } + } + fp->ptr = fp->base; + fp->cnt = read(fp->fd, fp->ptr, bufsize); + if (--fp->cnt < 0) { + if (fp->cnt == -1) { + fp->flags._EOF = 1; + } else { + fp->flags._ERR = 1; + } + fp->cnt = 0; + return EOF; + } + return (unsigned char) *fp->ptr++; +} + +my_FILE * my_fopen(char *name, char *mode) { + int fd; + my_FILE *fp; + if (*mode != 'r' && *mode != 'w' && *mode != 'a') { + return NULL; + } + for (fp = _iob; fp < _iob + FOPEN_MAX; fp++) { + if (fp->flags._READ == 0 && fp->flags._WRITE == 0) { + break; + } + } + if (fp >= _iob + FOPEN_MAX) { + return NULL; + } + if (*mode == 'w') { + fd = creat(name, PERMS); + } else if (*mode == 'a') { + if ((fd = open(name, O_WRONLY, 0)) == -1) { + fd = creat(name, PERMS); + } + lseek(fd, 0L, 2); + } else { + fd = open(name, O_RDONLY, 0); + } + if (fd == -1) { + return NULL; + } + fp->fd = fd; + fp->cnt = 0; + if (*mode == 'r') { + fp->flags._READ = 1; + } else { + fp->flags._WRITE = 1; + } + return fp; +} + +int main() { + my_FILE *fp = my_fopen("8-02_fopen-and-fillbuf.c", "r"); + if (fp != NULL) { + puts("We could read the file.\n"); + /* pro tip: don't declare this as 'unsigned' or you'll create an + * endless loop thanks to EOF typically being negative. Don't waste + * half an hour on a newbie mistake like I did. :) + */ + char c; + while ((c = my_getc(fp)) != EOF) { + putchar(c); + } + } else { + puts("Could not open file for reading."); + } + return 0; +} diff --git a/ch8/8-02_stdlib-fopen-and-fillbuf.c b/ch8/8-02_stdlib-fopen-and-fillbuf.c new file mode 100644 index 0000000..2219757 --- /dev/null +++ b/ch8/8-02_stdlib-fopen-and-fillbuf.c @@ -0,0 +1,33 @@ +#include +#include +#include +#include + +/* The C Programming Language: 2nd Edition + * + * Exercise 8-2: Rewrite `fopen` and `_fillbuf` with fields instead of explicit + * bit operations. Compare code size and execution speed. + * + * Notes: This file uses the standard library exclusively, in contrast to the + * partial replacement solution in the other 8-02 files. + * + * The resulting binary of this file executes in about 0.001s, just like the + * partial replacement solution. Its binary is 1KB smaller, however. + */ +int main() { + FILE *fp = fopen("8-02_fopen-and-fillbuf.c", "r"); + if (fp != NULL) { + puts("We could read the file.\n"); + /* pro tip: don't declare this as 'unsigned' or you'll create an + * endless loop thanks to EOF typically being negative. Don't waste + * half an hour on a newbie mistake like I did. :) + */ + char c; + while ((c = getc(fp)) != EOF) { + putchar(c); + } + } else { + puts("Could not open file for reading."); + } + return 0; +} diff --git a/ch8/8-02_syscalls.h b/ch8/8-02_syscalls.h new file mode 100644 index 0000000..728c5af --- /dev/null +++ b/ch8/8-02_syscalls.h @@ -0,0 +1,47 @@ +/* 8-02_syscalls.h + * + * A simpler stdio.h to aid in exercises 8-2 + */ + +long lseek(int fd, long offset, int origin); + +struct _flags { + unsigned int _READ : 1; + unsigned int _WRITE : 1; + unsigned int _UNBUF : 1; + unsigned int _EOF : 1; + unsigned int _ERR : 1; +} flags; + +typedef struct _iobuf { + int cnt; + char *ptr; + char *base; + struct _flags flags; + int fd; +} my_FILE; + +my_FILE _iob[FOPEN_MAX] = { + /* stdin is read-only */ + { 0, (char *) 0, (char *) 0, {1, 0, 0, 0, 0}, 0 }, + /* stdout is write only */ + { 0, (char *) 0, (char *) 0, {0, 1, 0, 0, 0}, 1 }, + /* stderr is written AND not buffered */ + { 0, (char *) 0, (char *) 0, {0, 1, 1, 0, 0}, 2 } +}; + +#define feof(p) (((p)->flags._EOF) != 0) +#define ferror(p) (((p)->flags._ERR) != 0) +#define fileno(p) ((p)->fd) +#define my_getc(p) (--(p)->cnt >= 0 ? (unsigned char) *(p)->ptr++ : my__fillbuf(p)) +#define getchar() getc(stdin) + +int my_fempty(struct _flags flags) { + if (!flags._READ && !flags._WRITE && !flags._UNBUF && !flags._EOF && !flags._ERR) { + return 1; + } else { + return 0; + } +} + +int my_fclose(my_FILE*); -- cgit v1.2.3-54-g00ecf