ref: dc4a648a71627db05ba1c24557c0ab7f80d348ed
dir: /src/ios.c/
#include "sl.h"
#include "timefuncs.h"
#define MOST_OF(x) ((x) - ((x)>>4))
sl_ios *ios_stdin = nil;
sl_ios *ios_stdout = nil;
sl_ios *ios_stderr = nil;
/* OS-level primitive wrappers */
void *
llt_memrchr(const void *s, int c, usize n)
{
const u8int *src = (const u8int*)s + n;
u8int uc = c;
while(--src >= (const u8int*)s)
if(*src == uc)
return (void *)src;
return nil;
}
#if !defined(__plan9__) && !defined(__macos__) && !defined(__dos__)
static int
_enonfatal(int err)
{
return err == 0 || err == EAGAIN || err == EINPROGRESS || err == EINTR || err == EWOULDBLOCK;
}
#define SLEEP_TIME 5//ms
#endif
// return error code, #bytes read in *nread
// these wrappers retry operations until success or a fatal error
static int
_os_read(int fd, u8int *buf, usize n, usize *nread)
{
ssize r;
while(1){
#if !defined(__plan9__) && !defined(__macos__) && !defined(__dos__)
errno = 0;
#endif
r = read(fd, buf, n);
if(r > -1){
*nread = (usize)r;
break;
}
#if defined(__plan9__) || defined(__macos__) || defined(__dos__)
return r;
#else
if(!_enonfatal(errno)){
*nread = 0;
return errno;
}
sleep_ms(SLEEP_TIME);
#endif
}
return 0;
}
static int
_os_read_all(int fd, u8int *buf, usize n, usize *nread)
{
usize got;
*nread = 0;
while(n > 0){
int err = _os_read(fd, buf, n, &got);
n -= got;
*nread += got;
buf += got;
if(err || got == 0)
return err;
}
return 0;
}
static int
_os_write(int fd, const void *buf, usize n, usize *nwritten)
{
ssize r;
while(1){
#if !defined(__plan9__) && !defined(__macos__) && !defined(__dos__)
errno = 0;
#endif
r = write(fd, buf, n);
if(r > -1){
*nwritten = (usize)r;
break;
}
#if defined(__plan9__) || defined(__macos__) || defined(__dos__)
return r;
#else
if(!_enonfatal(errno)){
*nwritten = 0;
return errno;
}
sleep_ms(SLEEP_TIME);
#endif
}
return 0;
}
static int
_os_write_all(int fd, const u8int *buf, usize n, usize *nwritten)
{
usize wrote;
*nwritten = 0;
while(n > 0){
wrote = 0;
int err = _os_write(fd, buf, n, &wrote);
n -= wrote;
*nwritten += wrote;
buf += wrote;
if(err)
return err;
}
return 0;
}
/* internal utility functions */
static u8int *
_buf_realloc(sl_ios *s, usize sz)
{
u8int *temp;
if((s->buf == nil || s->buf == &s->local[0]) && sz <= IOS_INLSIZE){
/* TODO: if we want to allow shrinking, see if the buffer shrank
down to this size, in which case we need to copy. */
s->buf = &s->local[0];
s->maxsize = IOS_INLSIZE;
s->ownbuf = true;
return s->buf;
}
if(sz <= s->maxsize)
return s->buf;
if(s->ownbuf && s->buf != &s->local[0]){
// if we own the buffer we're free to resize it
// always allocate 1 bigger in case user wants to add a NUL
// terminator after taking over the buffer
temp = MEM_REALLOC(s->buf, sz);
if(temp == nil)
return nil;
}else{
temp = MEM_ALLOC(sz);
if(temp == nil)
return nil;
s->ownbuf = true;
if(s->buf != nil)
memcpy(temp, s->buf, s->size);
}
s->buf = temp;
s->maxsize = sz;
return s->buf;
}
// write a block of data into the buffer at the current position, resizing
// if necessary. returns # written.
static usize
_write_grow(sl_ios *s, const void *data, usize n)
{
usize amt;
usize newsize;
if(n == 0)
return 0;
if(s->bpos + n > s->size){
if(s->bpos + n > s->maxsize){
/* TODO: here you might want to add a mechanism for limiting
the growth of the io. */
newsize = s->maxsize ? s->maxsize * 2 : 8;
while(s->bpos + n > newsize)
newsize *= 2;
if(_buf_realloc(s, newsize) == nil){
/* no more space; write as much as we can */
amt = s->maxsize - s->bpos;
if(amt > 0)
memcpy(&s->buf[s->bpos], data, amt);
s->bpos += amt;
s->size = s->maxsize;
return amt;
}
}
s->size = s->bpos + n;
}
memcpy(s->buf + s->bpos, data, n);
s->bpos += n;
return n;
}
/* interface functions, low level */
static usize
_ios_read(sl_ios *s, u8int *dest, usize n, bool all)
{
usize tot = 0;
usize got, avail;
if(s->state == bst_closed)
return 0;
while(n > 0){
avail = s->size - s->bpos;
if(avail > 0){
usize ncopy = avail >= n ? n : avail;
memcpy(dest, s->buf + s->bpos, ncopy);
s->bpos += ncopy;
if(ncopy >= n){
s->state = bst_rd;
return tot+ncopy;
}
}
if(s->bm == bm_mem || s->fd == -1){
// can't get any more data
s->state = bst_rd;
if(avail == 0)
s->_eof = true;
return avail;
}
dest += avail;
n -= avail;
tot += avail;
ios_flush(s);
s->bpos = s->size = 0;
s->state = bst_rd;
s->fpos = -1;
got = 0;
if(n > MOST_OF(s->maxsize)){
// doesn't fit comfortably in buffer; go direct
if(all)
_os_read_all(s->fd, dest, n, &got);
else
_os_read(s->fd, dest, n, &got);
tot += got;
if(got == 0)
s->_eof = true;
return tot;
}else{
// refill buffer
if(_os_read(s->fd, s->buf, s->maxsize, &got)){
s->_eof = true;
return tot;
}
if(got == 0){
s->_eof = true;
return tot;
}
s->size = got;
}
}
return tot;
}
usize
ios_read(sl_ios *s, void *dest, usize n)
{
return _ios_read(s, dest, n, 0);
}
// ensure at least n bytes are buffered if possible. returns # available.
static usize
ios_readprep(sl_ios *s, usize n)
{
if(s->state == bst_wr && s->bm != bm_mem){
ios_flush(s);
s->bpos = s->size = 0;
}
usize space = s->size - s->bpos;
s->state = bst_rd;
if(space >= n || s->bm == bm_mem || s->fd == -1)
return space;
if(s->maxsize < s->bpos+n){
// it won't fit. grow buffer or move data back.
if(n <= s->maxsize && space <= ((s->maxsize)>>2)){
if(space)
memmove(s->buf, s->buf+s->bpos, space);
s->size -= s->bpos;
s->bpos = 0;
}
else {
if(_buf_realloc(s, s->bpos + n) == nil)
return space;
}
}
usize got;
int result = _os_read(s->fd, s->buf+s->size, s->maxsize - s->size, &got);
if(result)
return space;
s->size += got;
return s->size - s->bpos;
}
static void
_write_update_pos(sl_ios *s)
{
if(s->bpos > s->ndirty)
s->ndirty = s->bpos;
if(s->bpos > s->size)
s->size = s->bpos;
}
usize
ios_write(sl_ios *s, const void *data, usize n)
{
if(s->readonly || s->state == bst_closed || n == 0)
return 0;
usize space;
usize wrote = 0;
if(s->state == bst_none)
s->state = bst_wr;
if(s->state == bst_rd){
if(!s->rereadable){
s->size = 0;
s->bpos = 0;
}
space = s->size - s->bpos;
}else{
space = s->maxsize - s->bpos;
}
if(s->bm == bm_mem){
wrote = _write_grow(s, data, n);
}else if(s->bm == bm_none){
s->fpos = -1;
_os_write_all(s->fd, data, n, &wrote);
return wrote;
}else if(n <= space){
if(s->bm == bm_line){
const char *nl;
if((nl = llt_memrchr(data, '\n', n)) != nil){
usize linesz = nl-(const char*)data+1;
s->bm = bm_block;
wrote += ios_write(s, data, linesz);
ios_flush(s);
s->bm = bm_line;
n -= linesz;
data = (const char*)data + linesz;
}
}
memcpy(s->buf + s->bpos, data, n);
s->bpos += n;
wrote += n;
}else{
s->state = bst_wr;
ios_flush(s);
if(n > MOST_OF(s->maxsize)){
_os_write_all(s->fd, data, n, &wrote);
return wrote;
}
return ios_write(s, data, n);
}
_write_update_pos(s);
return wrote;
}
soffset
ios_seek(sl_ios *s, soffset pos)
{
if(s->state == bst_closed)
return 0;
s->_eof = false;
if(s->bm == bm_mem){
if((usize)pos > s->size)
return -1;
s->bpos = pos;
}else{
ios_flush(s);
soffset fdpos = lseek(s->fd, pos, SEEK_SET);
if(fdpos == (soffset)-1)
return fdpos;
s->bpos = s->size = 0;
}
return 0;
}
soffset
ios_seek_end(sl_ios *s)
{
if(s->state == bst_closed)
return 0;
s->_eof = true;
if(s->bm == bm_mem){
s->bpos = s->size;
}else{
ios_flush(s);
soffset fdpos = lseek(s->fd, 0, SEEK_END);
if(fdpos == (soffset)-1)
return fdpos;
s->bpos = s->size = 0;
}
return 0;
}
soffset
ios_skip(sl_ios *s, soffset offs)
{
if(s->state == bst_closed)
return 0;
if(offs != 0){
if(offs > 0){
if(offs <= (soffset)(s->size-s->bpos)){
s->bpos += offs;
return 0;
}else if(s->bm == bm_mem){
// TODO: maybe grow buffer
return -1;
}
}else if(offs < 0){
if(-offs <= (soffset)s->bpos){
s->bpos += offs;
s->_eof = false;
return 0;
}else if(s->bm == bm_mem){
return -1;
}
}
ios_flush(s);
if(s->state == bst_wr)
offs += s->bpos;
else if(s->state == bst_rd)
offs -= s->size - s->bpos;
soffset fdpos = lseek(s->fd, offs, SEEK_CUR);
if(fdpos == (soffset)-1)
return fdpos;
s->bpos = s->size = 0;
s->_eof = false;
}
return 0;
}
soffset
ios_pos(sl_ios *s)
{
if(s->state == bst_closed)
return 0;
if(s->bm == bm_mem)
return (soffset)s->bpos;
soffset fdpos = s->fpos;
if(fdpos == (soffset)-1){
fdpos = lseek(s->fd, 0, SEEK_CUR);
if(fdpos == (soffset)-1)
return fdpos;
s->fpos = fdpos;
}
if(s->state == bst_wr)
fdpos += s->bpos;
else if(s->state == bst_rd)
fdpos -= s->size - s->bpos;
return fdpos;
}
int
ios_trunc(sl_ios *s, soffset size)
{
if(s->state == bst_closed || s->readonly || size < 0)
return -1;
if(s->bm == bm_mem){
if((usize)size == s->size)
return 0;
if((usize)size < s->size){
if(s->bpos > (usize)size)
s->bpos = size;
}else if(_buf_realloc(s, size) == nil)
return -1;
s->size = size;
return 0;
}
return ios_flush(s) == 0 ? ftruncate(s->fd, size) : -1;
}
bool
ios_eof(sl_ios *s)
{
if(s->state == bst_closed)
return true;
if(s->bm == bm_mem)
return s->_eof;
return s->fd == -1 || s->_eof;
}
int
ios_flush(sl_ios *s)
{
if(s->ndirty == 0 || s->bm == bm_mem || s->buf == nil)
return 0;
if(s->fd == -1)
return -1;
if(s->state == bst_rd){
if(lseek(s->fd, -(soffset)s->size, SEEK_CUR) == (soffset)-1){
// FIXME eh?
}
}
usize nw, ntowrite = s->ndirty;
s->fpos = -1;
int err = _os_write_all(s->fd, s->buf, ntowrite, &nw);
// todo: try recovering from some kinds of errors (e.g. retry)
if(s->state == bst_rd){
if(lseek(s->fd, s->size - nw, SEEK_CUR) == (soffset)-1){
// FIXME eh?
}
}else if(s->state == bst_wr){
if(s->bpos != nw && lseek(s->fd, (soffset)s->bpos - (soffset)nw, SEEK_CUR) == (soffset)-1){
// FIXME eh?
}
// now preserve the invariant that data to write
// begins at the beginning of the buffer, and s->size refers
// to how much valid file data is stored in the buffer.
if(s->size > s->ndirty){
usize delta = s->size - s->ndirty;
memmove(s->buf, s->buf + s->ndirty, delta);
}
s->size -= s->ndirty;
s->bpos = 0;
}
s->ndirty = 0;
if(err)
return err;
if(nw < ntowrite)
return -1;
return 0;
}
void
ios_close(sl_ios *s)
{
if(s->state == bst_closed)
return;
ios_flush(s);
if(s->fd != -1 && s->ownfd)
close(s->fd);
s->fd = -1;
if(s->buf != nil && s->ownbuf && s->buf != &s->local[0])
MEM_FREE(s->buf);
s->buf = nil;
s->size = s->maxsize = s->bpos = 0;
s->state = bst_closed;
}
void
ios_free(sl_ios *s)
{
MEM_FREE(s->loc.filename);
s->loc.filename = nil;
}
static void
_buf_init(sl_ios *s, ios_bm bm)
{
s->bm = bm;
if(s->bm == bm_mem || s->bm == bm_none){
s->buf = &s->local[0];
s->maxsize = IOS_INLSIZE;
}else{
s->buf = nil;
_buf_realloc(s, IOS_BUFSIZE);
}
s->size = s->bpos = 0;
}
u8int *
ios_takebuf(sl_ios *s, usize *psize)
{
u8int *buf;
ios_flush(s);
if(s->buf == &s->local[0] || s->buf == nil || (!s->ownbuf && s->size == s->maxsize)){
buf = MEM_ALLOC(s->size+1);
if(buf == nil)
return nil;
if(s->buf != nil)
memcpy(buf, s->buf, s->size);
}else if(s->size == s->maxsize){
buf = MEM_REALLOC(s->buf, s->size + 1);
if(buf == nil)
return nil;
}else{
buf = s->buf;
}
buf[s->size] = '\0';
*psize = s->size + 1;
/* empty io and reinitialize */
_buf_init(s, s->bm);
return buf;
}
int
ios_setbuf(sl_ios *s, u8int *buf, usize size, bool own)
{
ios_flush(s);
usize nvalid = size < s->size ? size : s->size;
if(nvalid > 0)
memcpy(buf, s->buf, nvalid);
if(s->bpos > nvalid){
// truncated
s->bpos = nvalid;
}
s->size = nvalid;
if(s->buf != nil && s->ownbuf && s->buf != &s->local[0])
MEM_FREE(s->buf);
s->buf = buf;
s->maxsize = size;
s->ownbuf = own;
return 0;
}
int
ios_bufmode(sl_ios *s, ios_bm mode)
{
// no fd; can only do mem-only buffering
if(s->fd == -1 && mode != bm_mem)
return -1;
s->bm = mode;
return 0;
}
void
ios_set_readonly(sl_ios *s)
{
if(s->readonly)
return;
ios_flush(s);
s->state = bst_none;
s->readonly = true;
}
static usize
ios_copy_(sl_ios *to, sl_ios *from, usize nbytes, bool all)
{
// FIXME(sigrid): ios doesn't really care about errors
// this needs a big fix everywhere
if(to->readonly || from->writeonly)
return 0;
usize total = 0, avail;
if(!ios_eof(from)){
do{
avail = ios_readprep(from, IOS_BUFSIZE/2);
if(avail == 0){
from->_eof = true;
break;
}
usize written, ntowrite;
ntowrite = (avail <= nbytes || all) ? avail : nbytes;
written = ios_write(to, from->buf+from->bpos, ntowrite);
// TODO: should this be +=written instead?
from->bpos += ntowrite;
total += written;
if(!all){
nbytes -= written;
if(nbytes == 0)
break;
}
if(written < ntowrite)
break;
}while(!ios_eof(from));
}
return total;
}
usize
ios_copy(sl_ios *to, sl_ios *from, usize nbytes)
{
return ios_copy_(to, from, nbytes, 0);
}
usize
ios_copyall(sl_ios *to, sl_ios *from)
{
return ios_copy_(to, from, 0, true);
}
#define LINE_CHUNK_SIZE 160
usize
ios_copyuntil(sl_ios *to, sl_ios *from, u8int delim)
{
usize total = 0, avail = from->size - from->bpos;
bool first = true;
if(!ios_eof(from)){
do{
if(avail == 0){
first = false;
avail = ios_readprep(from, LINE_CHUNK_SIZE);
}
usize written;
u8int *pd = memchr(from->buf+from->bpos, delim, avail);
if(pd == nil){
written = ios_write(to, from->buf+from->bpos, avail);
from->bpos += avail;
total += written;
avail = 0;
}else{
usize ntowrite = pd - (from->buf+from->bpos) + 1;
written = ios_write(to, from->buf+from->bpos, ntowrite);
from->bpos += ntowrite;
total += written;
return total;
}
}while(!ios_eof(from) && (first || avail >= LINE_CHUNK_SIZE));
}
from->_eof = true;
return total;
}
static void
_ios_init(sl_ios *s)
{
// put all fields in a sane initial state
memset(s, 0, sizeof(*s));
s->bm = bm_block;
s->state = bst_none;
s->fpos = -1;
s->fd = -1;
s->ownbuf = true;
s->loc.lineno = 1;
}
/* io object initializers. we do no allocation. */
sl_ios *
ios_file(sl_ios *s, char *fname, bool rd, bool wr, bool creat, bool trunc)
{
int fd;
if(!(rd || wr)) // must specify read and/or write
goto open_file_err;
int flags = wr ? (rd ? O_RDWR : O_WRONLY) : O_RDONLY;
if(trunc)
flags |= O_TRUNC;
#if defined(__plan9__)
fd = creat ? create(fname, flags, 0644) : open(fname, flags);
#else
if(creat)
flags |= O_CREAT;
fd = open(fname, flags, 0644);
#endif
s = ios_fd(s, fd, fname, true, true);
if(fd < 0)
goto open_file_err;
if(!wr && rd)
s->readonly = true;
if(wr && !rd)
s->writeonly = true;
return s;
open_file_err:
s->fd = -1;
return nil;
}
sl_ios *
ios_mem(sl_ios *s, usize initsize)
{
_ios_init(s);
s->bm = bm_mem;
s->loc.filename = MEM_STRDUP("");
_buf_realloc(s, initsize);
return s;
}
sl_ios *
ios_static_buffer(sl_ios *s, const u8int *buf, usize sz)
{
ios_mem(s, 0);
ios_setbuf(s, (u8int*)buf, sz, 0);
s->size = sz;
ios_set_readonly(s);
return s;
}
sl_ios *
ios_fd(sl_ios *s, int fd, const char *name, bool isfile, bool own)
{
_ios_init(s);
s->fd = fd;
if(isfile)
s->rereadable = true;
_buf_init(s, bm_block);
s->ownfd = own;
s->loc.filename = MEM_STRDUP(name);
return s;
}
void
ios_init_std(void)
{
ios_stdin = MEM_ALLOC(sizeof(sl_ios));
ios_fd(ios_stdin, STDIN_FILENO, "*stdin*", false, false);
ios_stdout = MEM_ALLOC(sizeof(sl_ios));
ios_fd(ios_stdout, STDOUT_FILENO, "*stdout*", false, false);
ios_stdout->bm = bm_line;
ios_stderr = MEM_ALLOC(sizeof(sl_ios));
ios_fd(ios_stderr, STDERR_FILENO, "*stderr*", false, false);
ios_stderr->bm = bm_none;
}
/* higher level interface */
int
ios_putc(sl_ios *s, int c)
{
char ch = c;
if(s->state == bst_wr && s->bpos < s->maxsize && s->bm != bm_none){
s->buf[s->bpos++] = ch;
_write_update_pos(s);
if(s->bm == bm_line && ch == '\n')
ios_flush(s);
return 1;
}
return ios_write(s, &ch, 1);
}
static void
ios_loc(sl_ios *s, u8int ch)
{
if(ch == '\n'){
s->loc.lineno++;
s->loc.colno = 0;
s->colnowait = 0;
}else if(s->colnowait > 0){
s->colnowait--;
}else{
s->loc.colno++;
if(ch & 0x80){
if((ch & 0xe0) == 0xc0)
s->colnowait = 1;
else if((ch & 0xf0) == 0xe0)
s->colnowait = 2;
else
s->colnowait = 3;
}
}
}
int
ios_getc(sl_ios *s)
{
u8int ch;
if(s->state == bst_rd && s->bpos < s->size)
ch = s->buf[s->bpos++];
else if(s->_eof || ios_read(s, &ch, 1) < 1)
return IOS_EOF;
ios_loc(s, ch);
return ch;
}
int
ios_peekc(sl_ios *s)
{
if(s->bpos < s->size)
return (u8int)s->buf[s->bpos];
if(s->_eof)
return IOS_EOF;
usize n = ios_readprep(s, 1);
if(n == 0)
return IOS_EOF;
return (u8int)s->buf[s->bpos];
}
int
ios_wait(sl_ios *s, double ws)
{
if(s->bpos < s->size)
return 1;
if(s->_eof)
return IOS_EOF;
#if defined(__plan9__) || defined(__macos__)
USED(ws);
return 1; // FIXME(sigrid): wait for input, but not too much
#else
struct timeval t, *pt = nil;
if(ws >= 0){
t.tv_sec = ws;
t.tv_usec = (long)((ws - t.tv_sec) * 1000000.0) % 1000000;
pt = &t;
}
fd_set f;
FD_ZERO(&f);
FD_SET(s->fd, &f);
int r;
while((r = select(s->fd+1, &f, nil, nil, pt)) == EINTR);
return r && FD_ISSET(s->fd, &f);
#endif
}
int
ios_getutf8(sl_ios *s, Rune *r)
{
int c;
usize i;
char buf[UTFmax];
for(i = 0; i < sizeof(buf); i++){
if((c = ios_getc(s)) == IOS_EOF){
s->_eof = true;
return IOS_EOF;
}
buf[i] = c;
if(fullrune(buf, i+1))
break;
}
chartorune(r, buf);
if(*r == Runeerror)
return 0;
if(*r == '\n')
s->loc.colno = 0;
else
s->loc.colno++;
return 1;
}
int
ios_pututf8(sl_ios *s, Rune r)
{
char buf[UTFmax];
return ios_write(s, buf, runetochar(buf, &r));
}
void
ios_purge(sl_ios *s)
{
if(s->state == bst_rd){
for(; s->bpos < s->size; s->bpos++)
ios_loc(s, s->buf[s->bpos]);
}
}
int
ios_vprintf(sl_ios *s, const char *format, va_list args)
{
char buf[256];
char *str;
int c;
if(s->state == bst_closed)
return -1;
/* skip allocations if no buffering needed */
if(s->bm == bm_none && (s->state == bst_none || s->state == bst_wr))
return vdprintf(s->fd, format, args);
if((c = vsnprintf(buf, sizeof(buf), format, args)) < nelem(buf))
str = buf;
else if(s->state == bst_none || s->state == bst_wr){
/* doesn't fit? prefer no allocations */
ios_flush(s);
return vdprintf(s->fd, format, args);
}else{
str = MEM_ALLOC(c+1);
c = vsnprintf(str, sizeof(c+1), format, args);
}
if(c > 0)
c = ios_write(s, str, c);
if(str != buf)
MEM_FREE(str);
return c;
}
int
ios_printf(sl_ios *s, const char *format, ...)
{
va_list args;
int c;
va_start(args, format);
c = ios_vprintf(s, format, args);
va_end(args);
return c;
}