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

* transcode_data.h (rb_transcoding): rename fields.

Browse source 
readlen -> recognized_len.
  feedlen -> readagain_len.

* transcode.c: follow the field renaming.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@18481 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2008-08-11 01:06:21 +00:00
parent badd9f1efc
commit bd5bf3726c
3 changed files with 41 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

8
ChangeLog
View file

@ -1,3 +1,11 @@
Mon Aug 11 10:04:34 2008 Tanaka Akira <akr@fsij.org>
* transcode_data.h (rb_transcoding): rename fields.
readlen -> recognized_len.
feedlen -> readagain_len.
* transcode.c: follow the field renaming.
Sun Aug 10 22:34:55 2008 Tanaka Akira <akr@fsij.org> Sun Aug 10 22:34:55 2008 Tanaka Akira <akr@fsij.org>
* transcode.c (transcode_restartable0): invalid handling simplified. * transcode.c (transcode_restartable0): invalid handling simplified.

60
transcode.c
View file

@ -352,15 +352,15 @@ transcode_char_start(rb_transcoding *tc,
size_t *char_len_ptr) size_t *char_len_ptr)
{ {
const unsigned char *ptr; const unsigned char *ptr;
if (inchar_start - in_start < tc->readlen) { if (inchar_start - in_start < tc->recognized_len) {
MEMCPY(TRANSCODING_READBUF(tc) + tc->readlen, MEMCPY(TRANSCODING_READBUF(tc) + tc->recognized_len,
inchar_start, unsigned char, in_p - inchar_start); inchar_start, unsigned char, in_p - inchar_start);
ptr = TRANSCODING_READBUF(tc); ptr = TRANSCODING_READBUF(tc);
} }
else { else {
ptr = inchar_start - tc->readlen; ptr = inchar_start - tc->recognized_len;
} }
*char_len_ptr = tc->readlen + (in_p - inchar_start); *char_len_ptr = tc->recognized_len + (in_p - inchar_start);
return ptr; return ptr;
} }
@ -381,7 +381,7 @@ transcode_restartable0(const unsigned char **in_pos, unsigned char **out_pos,
{ {
const rb_transcoder *tr = tc->transcoder; const rb_transcoder *tr = tc->transcoder;
int unitlen = tr->input_unit_length; int unitlen = tr->input_unit_length;
int feedlen = 0; int readagain_len = 0;
const unsigned char *inchar_start; const unsigned char *inchar_start;
const unsigned char *in_p; const unsigned char *in_p;
@ -415,14 +415,14 @@ transcode_restartable0(const unsigned char **in_pos, unsigned char **out_pos,
do { \ do { \
tc->resume_position = (num); \ tc->resume_position = (num); \
if (0 < in_p - inchar_start) \ if (0 < in_p - inchar_start) \
MEMMOVE(TRANSCODING_READBUF(tc)+tc->readlen, \ MEMMOVE(TRANSCODING_READBUF(tc)+tc->recognized_len, \
inchar_start, unsigned char, in_p - inchar_start); \ inchar_start, unsigned char, in_p - inchar_start); \
*in_pos = in_p; \ *in_pos = in_p; \
*out_pos = out_p; \ *out_pos = out_p; \
tc->readlen += in_p - inchar_start; \ tc->recognized_len += in_p - inchar_start; \
if (feedlen) { \ if (readagain_len) { \
tc->readlen -= feedlen; \ tc->recognized_len -= readagain_len; \
tc->feedlen = feedlen; \ tc->readagain_len = readagain_len; \
} \ } \
tc->next_table = next_table; \ tc->next_table = next_table; \
tc->next_info = next_info; \ tc->next_info = next_info; \
@ -457,7 +457,7 @@ transcode_restartable0(const unsigned char **in_pos, unsigned char **out_pos,
continue; continue;
} }
tc->readlen = 0; tc->recognized_len = 0;
inchar_start = in_p; inchar_start = in_p;
next_table = tr->conv_tree_start; next_table = tr->conv_tree_start;
next_byte = (unsigned char)*in_p++; next_byte = (unsigned char)*in_p++;
@ -533,24 +533,24 @@ transcode_restartable0(const unsigned char **in_pos, unsigned char **out_pos,
break; break;
} }
case INVALID: case INVALID:
if (tc->readlen + (in_p - inchar_start) <= unitlen) { if (tc->recognized_len + (in_p - inchar_start) <= unitlen) {
while ((opt & PARTIAL_INPUT) && tc->readlen + (in_stop - inchar_start) < unitlen) { while ((opt & PARTIAL_INPUT) && tc->recognized_len + (in_stop - inchar_start) < unitlen) {
in_p = in_stop; in_p = in_stop;
SUSPEND(transcode_ibuf_empty, 8); SUSPEND(transcode_ibuf_empty, 8);
} }
if (tc->readlen + (in_stop - inchar_start) <= unitlen) { if (tc->recognized_len + (in_stop - inchar_start) <= unitlen) {
in_p = in_stop; in_p = in_stop;
} }
else { else {
in_p = inchar_start + (unitlen - tc->readlen); in_p = inchar_start + (unitlen - tc->recognized_len);
} }
} }
else { else {
int invalid_len; /* including the last byte which causes invalid */ int invalid_len; /* including the last byte which causes invalid */
int discard_len; int discard_len;
invalid_len = tc->readlen + (in_p - inchar_start); invalid_len = tc->recognized_len + (in_p - inchar_start);
discard_len = ((invalid_len - 1) / unitlen) * unitlen; discard_len = ((invalid_len - 1) / unitlen) * unitlen;
feedlen = invalid_len - discard_len; readagain_len = invalid_len - discard_len;
} }
goto invalid; goto invalid;
case UNDEF: case UNDEF:
@ -585,20 +585,20 @@ transcode_restartable(const unsigned char **in_pos, unsigned char **out_pos,
rb_transcoding *tc, rb_transcoding *tc,
const int opt) const int opt)
{ {
if (tc->feedlen) { if (tc->readagain_len) {
unsigned char *feed_buf = ALLOCA_N(unsigned char, tc->feedlen); unsigned char *readagain_buf = ALLOCA_N(unsigned char, tc->readagain_len);
const unsigned char *feed_pos = feed_buf; const unsigned char *readagain_pos = readagain_buf;
const unsigned char *feed_stop = feed_buf + tc->feedlen; const unsigned char *readagain_stop = readagain_buf + tc->readagain_len;
rb_transcoding_result_t res; rb_transcoding_result_t res;
MEMCPY(feed_buf, TRANSCODING_READBUF(tc) + tc->readlen, MEMCPY(readagain_buf, TRANSCODING_READBUF(tc) + tc->recognized_len,
unsigned char, tc->feedlen); unsigned char, tc->readagain_len);
tc->feedlen = 0; tc->readagain_len = 0;
res = transcode_restartable0(&feed_pos, out_pos, feed_stop, out_stop, tc, opt|PARTIAL_INPUT); res = transcode_restartable0(&readagain_pos, out_pos, readagain_stop, out_stop, tc, opt|PARTIAL_INPUT);
if (res != transcode_ibuf_empty) { if (res != transcode_ibuf_empty) {
MEMCPY(TRANSCODING_READBUF(tc) + tc->readlen + tc->feedlen, MEMCPY(TRANSCODING_READBUF(tc) + tc->recognized_len + tc->readagain_len,
feed_pos, unsigned char, feed_stop - feed_pos); readagain_pos, unsigned char, readagain_stop - readagain_pos);
tc->feedlen += feed_stop - feed_pos; tc->readagain_len += readagain_stop - readagain_pos;
return res; return res;
} }
} }
@ -635,8 +635,8 @@ rb_transcoding_open(const char *from, const char *to, int flags)
tc->flags = flags; tc->flags = flags;
memset(tc->stateful, 0, sizeof(tc->stateful)); memset(tc->stateful, 0, sizeof(tc->stateful));
tc->resume_position = 0; tc->resume_position = 0;
tc->readlen = 0; tc->recognized_len = 0;
tc->feedlen = 0; tc->readagain_len = 0;
if (sizeof(tc->readbuf.ary) < tr->max_input) { if (sizeof(tc->readbuf.ary) < tr->max_input) {
tc->readbuf.ptr = xmalloc(tr->max_input); tc->readbuf.ptr = xmalloc(tr->max_input);
} }

6
transcode_data.h
View file

@ -67,12 +67,12 @@ typedef struct rb_transcoding {
const BYTE_LOOKUP *next_table; const BYTE_LOOKUP *next_table;
VALUE next_info; VALUE next_info;
unsigned char next_byte; unsigned char next_byte;
int readlen; /* already interpreted */ int recognized_len; /* already interpreted */
int feedlen; /* not yet interpreted */ int readagain_len; /* not yet interpreted */
union { union {
unsigned char ary[8]; /* max_input <= sizeof(ary) */ unsigned char ary[8]; /* max_input <= sizeof(ary) */
unsigned char *ptr; /* length is max_input */ unsigned char *ptr; /* length is max_input */
} readbuf; /* readlen + feedlen used */ } readbuf; /* recognized_len + readagain_len used */
unsigned char stateful[256]; /* opaque data for stateful encoding */ unsigned char stateful[256]; /* opaque data for stateful encoding */
} rb_transcoding; } rb_transcoding;