os

bufio.om (2996B)

---

 struct file {
 	a: *alloc;
 	fd: int;
 	buf: *byte;
 	r: int;
 	w: int;
 	cap: int;
 	eof: int;
 	noflush: int;
 }
 
 func fopen(fd: int, a: *alloc): *file {
 	var f: *file;
 
 	f = alloc(a, sizeof(*f)) as *file;
 
 	f.fd = fd;
 	f.a = a;
 	f.r = 0;
 	f.w = 0;
 	f.cap = 4096 * 16;
 	f.eof = 0;
 
 	f.buf = alloc(a, f.cap);
 
 	return f;
 }
 
 func fclose(f: *file): void {
 	fflush(f);
 
 	if (close(f.fd) != 0) {
 		die("write failed");
 	}
 
 	free(f.a, f.buf);
 
 	free(f.a, f as *byte);
 }
 
 func fflush(f: *file): void {
 	var ret: int;
 
 	loop {
 		if (f.r == f.w) {
 			f.r = 0;
 			f.w = 0;
 			return;
 		}
 
 		ret = write(f.fd, &f.buf[f.r], f.w - f.r);
 
 		if (ret < 0) {
 			die("write failed");
 		}
 
 		f.r = f.r + ret;
 	}
 }
 
 func ffill(f: *file): void {
 	var ret: int;
 
 	if (f.eof) {
 		return;
 	}
 
 	if (f.r == f.w) {
 		f.r = 0;
 		f.w = 0;
 	}
 
 	if (f.w == f.cap) {
 		die("out of space");
 	}
 
 	ret = read(f.fd, &f.buf[f.w], f.cap - f.w);
 
 	if (ret < 0) {
 		die("read failed");
 	}
 
 	if (ret == 0) {
 		f.eof = 1;
 	}
 
 	f.w = f.w + ret;
 }
 
 func fputc(f: *file, ch: int): void {
 	var b: byte;
 
 	if !f {
 		b = ch as byte;
 		if write(1, &b, 1) != 1 {
 			exit(3);
 		}
 		return;
 	}
 
 	if (f.w == f.cap) {
 		fflush(f);
 	}
 
 	f.buf[f.w] = ch as byte;
 	f.w = f.w + 1;
 
 	if (ch == '\n' && !f.noflush) {
 		fflush(f);
 	}
 }
 
 func fgetc(f: *file): int {
 	var ch: int;
 
 	if (f.r == f.w) {
 		ffill(f);
 	}
 
 	if (f.eof) {
 		return -1;
 	}
 
 	ch = f.buf[f.r] as int;
 
 	f.r = f.r + 1;
 
 	return ch;
 }
 
 func fgets(f: *file, buf: *byte, len: int): int {
 	var i: int;
 	var c: int;
 
 	if len == 1 {
 		buf[0] = 0 as byte;
 		return 0;
 	}
 
 	i = 0;
 	loop {
 		if i + 1 == len {
 			buf[i] = 0 as byte;
 			return i;
 		}
 
 		c = fgetc(f);
 		if c == -1 || c == '\n' {
 			buf[i] = 0 as byte;
 			return i;
 		}
 
 		buf[i] = c as byte;
 		i = i + 1;
 	}
 }
 
 func fputs(f: *file, s: *byte) {
 	var i: int;
 	i = 0;
 	loop {
 		if !s[i] {
 			break;
 		}
 		fputc(f, s[i] as int);
 		i = i + 1;
 	}
 }
 
 func fputb(f: *file, s: *byte, n: int) {
 	var i: int;
 	i = 0;
 	loop {
 		if i >= n {
 			break;
 		}
 		fputc(f, s[i] as int);
 		i = i + 1;
 	}
 }
 
 func fputd(out: *file, n: int) {
 	var a: int;
 
 	if (n < 0) {
 		fputc(out, '-');
 		a = -(n % 10);
 		n = n / -10;
 	} else {
 		a = n % 10;
 		n = n / 10;
 	}
 
 	if (n != 0) {
 		fputd(out, n);
 	}
 
 	fputc(out, '0' + a);
 }
 
 func fputh(out: *file, n: int) {
 	var d: int;
 
 	d = n & 15;
 
 	n = n >> 4;
 
 	if n {
 		fputh(out, n);
 	}
 
 	fputc(out, "0123456789abcdef"[d] as int);
 }
 
 func fseek(f: *file, off: int) {
 	f.r = 0;
 	f.w = 0;
 	f.eof = 0;
 	if lseek(f.fd, off, 0) != off {
 		die("invalid seek");
 	}
 }
 
 func freadall(f: *file, size: *int): *byte {
 	var i: int;
 	var cap: int;
 	var ret: *byte;
 	var tmp: *byte;
 	var ch: int;
 
 	i = 0;
 	cap = 0;
 	loop {
 		ch = fgetc(f);
 		if ch == -1 {
 			*size = i;
 			return ret;
 		}
 
 		if i == cap {
 			if cap == 0 {
 				cap = 4096;
 				ret = alloc(f.a, cap);
 			} else {
 				cap = cap * 2;
 				tmp = alloc(f.a, cap);
 				memcpy(tmp, ret, i);
 				free(f.a, ret);
 				ret = tmp;
 			}
 		}
 
 		ret[i] = ch as byte;
 		i = i + 1;
 	}
 }