kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* include/ruby/io.h (rb_io_t): rename crbuf to cbuf.

Browse source 
* io.c: follow the renaming.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@18874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2008-08-26 15:06:28 +00:00
parent c8dbd99790
commit 99a26ac164
3 changed files with 75 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ChangeLog
View file

@ -1,3 +1,9 @@
Wed Aug 27 00:05:55 2008 Tanaka Akira <akr@fsij.org>
* include/ruby/io.h (rb_io_t): rename crbuf to cbuf.
* io.c: follow the renaming.
Tue Aug 26 23:52:24 2008 Tanaka Akira <akr@fsij.org>
* include/ruby/encoding.h (rb_econv_elem_t): move to transcode.c

16
include/ruby/io.h
View file

@ -62,10 +62,10 @@ typedef struct rb_io_t {
} encs;
rb_econv_t *readconv;
char *crbuf; /* crbuf_off + crbuf_len <= crbuf_capa */
int crbuf_off;
int crbuf_len;
int crbuf_capa;
char *cbuf; /* cbuf_off + cbuf_len <= cbuf_capa */
int cbuf_off;
int cbuf_len;
int cbuf_capa;
rb_econv_t *writeconv;
VALUE writeconv_stateless;
@ -119,10 +119,10 @@ typedef struct rb_io_t {
fp->rbuf_len = 0;\
fp->rbuf_capa = 0;\
fp->readconv = NULL;\
fp->crbuf = NULL;\
fp->crbuf_off = 0;\
fp->crbuf_len = 0;\
fp->crbuf_capa = 0;\
fp->cbuf = NULL;\
fp->cbuf_off = 0;\
fp->cbuf_len = 0;\
fp->cbuf_capa = 0;\
fp->writeconv = NULL;\
fp->writeconv_stateless = Qnil;\
fp->writeconv_initialized = 0;\

122
io.c
View file

@ -1455,10 +1455,10 @@ make_readconv(rb_io_t *fptr)
fptr->readconv = rb_econv_open(sname, dname, &ecopts);
if (!fptr->readconv)
rb_exc_raise(rb_econv_open_exc(sname, dname, &ecopts));
fptr->crbuf_off = 0;
fptr->crbuf_len = 0;
fptr->crbuf_capa = 1024;
fptr->crbuf = ALLOC_N(char, fptr->crbuf_capa);
fptr->cbuf_off = 0;
fptr->cbuf_len = 0;
fptr->cbuf_capa = 1024;
fptr->cbuf = ALLOC_N(char, fptr->cbuf_capa);
}
}
@ -1469,28 +1469,28 @@ more_char(rb_io_t *fptr)
unsigned char *ds, *dp, *de;
rb_econv_result_t res;
int putbackable;
int crbuf_len0;
int cbuf_len0;
if (fptr->crbuf_len == fptr->crbuf_capa)
return 0; /* crbuf full */
if (fptr->crbuf_len == 0)
fptr->crbuf_off = 0;
else if (fptr->crbuf_off + fptr->crbuf_len == fptr->crbuf_capa) {
memmove(fptr->crbuf, fptr->crbuf+fptr->crbuf_off, fptr->crbuf_len);
fptr->crbuf_off = 0;
if (fptr->cbuf_len == fptr->cbuf_capa)
return 0; /* cbuf full */
if (fptr->cbuf_len == 0)
fptr->cbuf_off = 0;
else if (fptr->cbuf_off + fptr->cbuf_len == fptr->cbuf_capa) {
memmove(fptr->cbuf, fptr->cbuf+fptr->cbuf_off, fptr->cbuf_len);
fptr->cbuf_off = 0;
}
crbuf_len0 = fptr->crbuf_len;
cbuf_len0 = fptr->cbuf_len;
while (1) {
ss = sp = (const unsigned char *)fptr->rbuf + fptr->rbuf_off;
se = sp + fptr->rbuf_len;
ds = dp = (unsigned char *)fptr->crbuf + fptr->crbuf_off + fptr->crbuf_len;
de = (unsigned char *)fptr->crbuf + fptr->crbuf_capa;
ds = dp = (unsigned char *)fptr->cbuf + fptr->cbuf_off + fptr->cbuf_len;
de = (unsigned char *)fptr->cbuf + fptr->cbuf_capa;
res = rb_econv_convert(fptr->readconv, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_OUTPUT_FOLLOWED_BY_INPUT);
fptr->rbuf_off += sp - ss;
fptr->rbuf_len -= sp - ss;
fptr->crbuf_len += dp - ds;
fptr->cbuf_len += dp - ds;
putbackable = rb_econv_putbackable(fptr->readconv);
if (putbackable) {
@ -1501,7 +1501,7 @@ more_char(rb_io_t *fptr)
rb_econv_check_error(fptr->readconv);
if (crbuf_len0 != fptr->crbuf_len)
if (cbuf_len0 != fptr->cbuf_len)
return 0;
if (res == econv_finished)
@ -1512,10 +1512,10 @@ more_char(rb_io_t *fptr)
rb_thread_wait_fd(fptr->fd);
rb_io_check_closed(fptr);
if (io_fillbuf(fptr) == -1) {
ds = dp = (unsigned char *)fptr->crbuf + fptr->crbuf_off + fptr->crbuf_len;
de = (unsigned char *)fptr->crbuf + fptr->crbuf_capa;
ds = dp = (unsigned char *)fptr->cbuf + fptr->cbuf_off + fptr->cbuf_len;
de = (unsigned char *)fptr->cbuf + fptr->cbuf_capa;
res = rb_econv_convert(fptr->readconv, NULL, NULL, &dp, de, 0);
fptr->crbuf_len += dp - ds;
fptr->cbuf_len += dp - ds;
rb_econv_check_error(fptr->readconv);
}
}
@ -1524,29 +1524,29 @@ more_char(rb_io_t *fptr)
}
static VALUE
io_shift_crbuf(rb_io_t *fptr, int len, VALUE *strp)
io_shift_cbuf(rb_io_t *fptr, int len, VALUE *strp)
{
VALUE str;
if (NIL_P(*strp)) {
*strp = str = rb_str_new(fptr->crbuf+fptr->crbuf_off, len);
*strp = str = rb_str_new(fptr->cbuf+fptr->cbuf_off, len);
}
else {
size_t slen;
str = *strp;
slen = RSTRING_LEN(str);
rb_str_resize(str, RSTRING_LEN(str) + len);
memcpy(RSTRING_PTR(str)+slen, fptr->crbuf+fptr->crbuf_off, len);
memcpy(RSTRING_PTR(str)+slen, fptr->cbuf+fptr->cbuf_off, len);
}
fptr->crbuf_off += len;
fptr->crbuf_len -= len;
fptr->cbuf_off += len;
fptr->cbuf_len -= len;
OBJ_TAINT(str);
rb_enc_associate(str, fptr->encs.enc);
/* xxx: set coderange */
if (fptr->crbuf_len == 0)
fptr->crbuf_off = 0;
if (fptr->crbuf_off < fptr->crbuf_capa/2) {
memmove(fptr->crbuf, fptr->crbuf+fptr->crbuf_off, fptr->crbuf_len);
fptr->crbuf_off = 0;
if (fptr->cbuf_len == 0)
fptr->cbuf_off = 0;
if (fptr->cbuf_off < fptr->cbuf_capa/2) {
memmove(fptr->cbuf, fptr->cbuf+fptr->cbuf_off, fptr->cbuf_len);
fptr->cbuf_off = 0;
}
return str;
}
@ -1564,8 +1564,8 @@ read_all(rb_io_t *fptr, long siz, VALUE str)
VALUE str = rb_str_new(NULL, 0);
make_readconv(fptr);
while (1) {
if (fptr->crbuf_len) {
io_shift_crbuf(fptr, fptr->crbuf_len, &str);
if (fptr->cbuf_len) {
io_shift_cbuf(fptr, fptr->cbuf_len, &str);
}
if (more_char(fptr) == -1) {
return io_enc_str(str, fptr);
@ -1917,9 +1917,9 @@ appendline(rb_io_t *fptr, int delim, VALUE *strp, long *lp)
while (1) {
const char *p, *e;
int searchlen;
if (fptr->crbuf_len) {
p = fptr->crbuf+fptr->crbuf_off;
searchlen = fptr->crbuf_len;
if (fptr->cbuf_len) {
p = fptr->cbuf+fptr->cbuf_off;
searchlen = fptr->cbuf_len;
if (0 < limit && limit < searchlen)
searchlen = limit;
e = memchr(p, delim, searchlen);
@ -1928,8 +1928,8 @@ appendline(rb_io_t *fptr, int delim, VALUE *strp, long *lp)
*strp = str = rb_str_new(p, e-p+1);
else
rb_str_buf_cat(str, p, e-p+1);
fptr->crbuf_off += e-p+1;
fptr->crbuf_len -= e-p+1;
fptr->cbuf_off += e-p+1;
fptr->cbuf_len -= e-p+1;
limit -= e-p+1;
*lp = limit;
return delim;
@ -1939,8 +1939,8 @@ appendline(rb_io_t *fptr, int delim, VALUE *strp, long *lp)
*strp = str = rb_str_new(p, searchlen);
else
rb_str_buf_cat(str, p, searchlen);
fptr->crbuf_off += searchlen;
fptr->crbuf_len -= searchlen;
fptr->cbuf_off += searchlen;
fptr->cbuf_len -= searchlen;
limit -= searchlen;
if (limit == 0) {
@ -2450,34 +2450,34 @@ io_getc(rb_io_t *fptr, rb_encoding *enc)
make_readconv(fptr);
while (1) {
if (fptr->crbuf_len) {
if (fptr->cbuf_len) {
if (fptr->encs.enc)
r = rb_enc_precise_mbclen(fptr->crbuf+fptr->crbuf_off,
fptr->crbuf+fptr->crbuf_off+fptr->crbuf_len,
r = rb_enc_precise_mbclen(fptr->cbuf+fptr->cbuf_off,
fptr->cbuf+fptr->cbuf_off+fptr->cbuf_len,
fptr->encs.enc);
else
r = ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(1);
if (!MBCLEN_NEEDMORE_P(r))
break;
if (fptr->crbuf_len == fptr->crbuf_capa) {
if (fptr->cbuf_len == fptr->cbuf_capa) {
rb_raise(rb_eIOError, "too long character");
}
}
if (more_char(fptr) == -1) {
if (fptr->crbuf_len == 0)
if (fptr->cbuf_len == 0)
return Qnil;
/* return an incomplete character just before EOF */
return io_shift_crbuf(fptr, fptr->crbuf_len, &str);
return io_shift_cbuf(fptr, fptr->cbuf_len, &str);
}
}
if (MBCLEN_INVALID_P(r)) {
r = rb_enc_mbclen(fptr->crbuf+fptr->crbuf_off,
fptr->crbuf+fptr->crbuf_off+fptr->crbuf_len,
r = rb_enc_mbclen(fptr->cbuf+fptr->cbuf_off,
fptr->cbuf+fptr->cbuf_off+fptr->cbuf_len,
fptr->encs.enc);
return io_shift_crbuf(fptr, r, &str);
return io_shift_cbuf(fptr, r, &str);
}
return io_shift_crbuf(fptr, MBCLEN_CHARFOUND_LEN(r), &str);
return io_shift_cbuf(fptr, MBCLEN_CHARFOUND_LEN(r), &str);
}
if (io_fillbuf(fptr) < 0) {
@ -2813,17 +2813,17 @@ rb_io_ungetc(VALUE io, VALUE c)
if (NEED_READCONV(fptr)) {
make_readconv(fptr);
len = RSTRING_LEN(c);
if (fptr->crbuf_capa - fptr->crbuf_len < len)
if (fptr->cbuf_capa - fptr->cbuf_len < len)
rb_raise(rb_eIOError, "ungetc failed");
if (fptr->crbuf_off < len) {
MEMMOVE(fptr->crbuf+fptr->crbuf_capa-fptr->crbuf_len,
fptr->crbuf+fptr->crbuf_off,
char, fptr->crbuf_len);
fptr->crbuf_off = fptr->crbuf_capa-fptr->crbuf_len;
if (fptr->cbuf_off < len) {
MEMMOVE(fptr->cbuf+fptr->cbuf_capa-fptr->cbuf_len,
fptr->cbuf+fptr->cbuf_off,
char, fptr->cbuf_len);
fptr->cbuf_off = fptr->cbuf_capa-fptr->cbuf_len;
}
fptr->crbuf_off -= len;
fptr->crbuf_len += len;
MEMMOVE(fptr->crbuf+fptr->crbuf_off, RSTRING_PTR(c), char, len);
fptr->cbuf_off -= len;
fptr->cbuf_len += len;
MEMMOVE(fptr->cbuf+fptr->cbuf_off, RSTRING_PTR(c), char, len);
}
else {
io_ungetbyte(c, fptr);
@ -3076,9 +3076,9 @@ clear_readconv(rb_io_t *fptr)
rb_econv_close(fptr->readconv);
fptr->readconv = NULL;
}
if (fptr->crbuf) {
free(fptr->crbuf);
fptr->crbuf = NULL;
if (fptr->cbuf) {
free(fptr->cbuf);
fptr->cbuf = NULL;
}
}