Ruby » Backport193

* win32/configure.bat: disable delayed expansion of enironment variable.

[Bug #5517] [ruby-core:40531]

Wed Dec 28 11:22:45 2011 Nobuyoshi Nakada <nobu@ruby-lang.org>

* lib/fileutils.rb (FileUtils::Entry_#entries): use utility method

* transcode.c (str_encode): about the extension of :fallback

option since 1.9.3.

Tue Oct 4 06:43:47 2011 Aaron Patterson <aaron@tenderlovemaking.com>

* ext/psych/lib/psych.rb: update psych version.

* io.c (argf_next_argv): open in default text mode.

[ruby-core:39234] [Bug #5268]

Mon Sep 5 15:06:55 2011 NARUSE, Yui <naruse@ruby-lang.org>

* test/rubygems/test_gem_security.rb

#define ECONV_DECORATOR_MASK 0x0000ff00

#define ECONV_NEWLINE_DECORATOR_MASK 0x00003f00

#define ECONV_UNIVERSAL_NEWLINE_DECORATOR 0x00000100

#define ECONV_CRLF_NEWLINE_DECORATOR 0x00001000

#define ECONV_XML_ATTR_QUOTE_DECORATOR 0x00100000

#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)

#else

#define ECONV_DEFAULT_NEWLINE_DECORATOR 0

#endif

extern int rb_w32_ustati64(const char *, struct stati64 *);

extern int rb_w32_access(const char *, int);

extern int rb_w32_uaccess(const char *, int);

#ifdef __BORLANDC__

extern int rb_w32_fstati64(int, struct stati64 *);

# endif

#endif

#define NEED_NEWLINE_DECORATOR_ON_READ(fptr) ((fptr)->mode & FMODE_TEXTMODE)

#define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) ((fptr)->mode & FMODE_TEXTMODE)

#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)

/* Windows */

# define DEFAULT_TEXTMODE FMODE_TEXTMODE

# define TEXTMODE_NEWLINE_DECORATOR_ON_WRITE ECONV_CRLF_NEWLINE_DECORATOR

#else

/* Unix */

# define DEFAULT_TEXTMODE 0

#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || NEED_NEWLINE_DECORATOR_ON_READ(fptr))

#define NEED_WRITECONV(fptr) (((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) || ((fptr)->encs.ecflags & (ECONV_DECORATOR_MASK|ECONV_STATEFUL_DECORATOR_MASK)))

#if !defined HAVE_SHUTDOWN && !defined shutdown

#define shutdown(a,b) 0

#endif

#if defined(_WIN32)

#define is_socket(fd, path) rb_w32_is_socket(fd)

#elif !defined(S_ISSOCK)

}

}

VALUE

rb_io_get_io(VALUE io)

fptr->writeconv_initialized = 1;

ecopts = fptr->encs.ecopts;

if (!fptr->encs.enc || (fptr->encs.enc == rb_ascii8bit_encoding() && !fptr->encs.enc2)) {

/* no encoding conversion */

return len;

}

static VALUE

do_writeconv(VALUE str, rb_io_t *fptr)

{

if (NEED_WRITECONV(fptr)) {

VALUE common_encoding = Qnil;

make_writeconv(fptr);

if (fptr->writeconv) {

if (!NIL_P(fptr->writeconv_asciicompat))

common_encoding = fptr->writeconv_asciicompat;

rb_raise(rb_eArgError, "ASCII incompatible string written for text mode IO without encoding conversion: %s",

rb_enc_name(rb_enc_get(str)));

}

}

else {

if (fptr->encs.enc2)

str = rb_econv_str_convert(fptr->writeconv, str, ECONV_PARTIAL_INPUT);

}

}

return str;

}

int ecflags;

VALUE ecopts;

const char *sname, *dname;

ecopts = fptr->encs.ecopts;

if (fptr->encs.enc2) {

sname = rb_enc_name(fptr->encs.enc2);

int cr;

if (NEED_READCONV(fptr)) {

io_setstrbuf(&str,0);

make_readconv(fptr, 0);

while (1) {

}

}

bytes = 0;

pos = 0;

rb_io_t *fptr;

long n, len;

VALUE length, str;

rb_scan_args(argc, argv, "02", &length, &str);

if (len == 0) return str;

READ_CHECK(fptr);

n = io_fread(str, 0, fptr);

if (n == 0) {

if (fptr->fd < 0) return Qnil;

rb_str_resize(str, 0);

long limit = *lp;

if (NEED_READCONV(fptr)) {

make_readconv(fptr, 0);

do {

const char *p, *e;

return EOF;

}

do {

long pending = READ_DATA_PENDING_COUNT(fptr);

if (pending > 0) {

if (NEED_READCONV(fptr)) {

rb_encoding *enc = io_read_encoding(fptr);

int needconv = rb_enc_mbminlen(enc) != 1;

make_readconv(fptr, 0);

do {

size_t cnt;

return FALSE;

}

do {

size_t cnt;

while ((cnt = READ_DATA_PENDING_COUNT(fptr)) > 0) {

}

else if (rs == rb_default_rs && limit < 0 && !NEED_READCONV(fptr) &&

rb_enc_asciicompat(enc = io_read_encoding(fptr))) {

return rb_io_getline_fast(fptr, enc, io);

}

else {

int rspara = 0;

int extra_limit = 16;

enc = io_read_encoding(fptr);

if (!NIL_P(rs)) {

VALUE str = Qnil;

rb_encoding *read_enc = io_read_encoding(fptr);

make_readconv(fptr, 0);

while (1) {

return str;

}

if (io_fillbuf(fptr) < 0) {

return Qnil;

}

READ_CHECK(fptr);

if (NEED_READCONV(fptr)) {

for (;;) {

make_readconv(fptr, 0);

for (;;) {

rb_yield(UINT2NUM(c));

}

}

enc = io_input_encoding(fptr);

for (;;) {

if (io_fillbuf(fptr) < 0) {

SafeStringValue(c);

}

if (NEED_READCONV(fptr)) {

len = RSTRING_LEN(c);

#if SIZEOF_LONG > SIZEOF_INT

if (len > INT_MAX)

MEMMOVE(fptr->cbuf.ptr+fptr->cbuf.off, RSTRING_PTR(c), char, len);

}

else {

io_ungetbyte(c, fptr);

}

return Qnil;

fptr->mode |= FMODE_BINMODE;

fptr->mode &= ~FMODE_TEXTMODE;

fptr->writeconv_pre_ecflags &= ~ECONV_NEWLINE_DECORATOR_MASK;

return io;

}

}

fptr->mode |= FMODE_BINMODE;

fptr->mode &= ~FMODE_TEXTMODE;

fptr->encs.enc = rb_ascii8bit_encoding();

fptr->encs.enc2 = NULL;

static const char*

rb_io_fmode_modestr(int fmode)

{

if (fmode & FMODE_APPEND) {

if ((fmode & FMODE_READWRITE) == FMODE_READWRITE) {

return MODE_BTMODE("a+", "ab+", "at+");

ecflags = (fmode & FMODE_READABLE) ?

MODE_BTMODE(ECONV_DEFAULT_NEWLINE_DECORATOR,

0, ECONV_UNIVERSAL_NEWLINE_DECORATOR) : 0;

ecopts = Qnil;

}

else {

ecflags = (fmode & FMODE_READABLE) ?

MODE_BTMODE(ECONV_DEFAULT_NEWLINE_DECORATOR,

0, ECONV_UNIVERSAL_NEWLINE_DECORATOR) : 0;

if (rb_io_extract_encoding_option(opthash, &enc, &enc2, &fmode)) {

if (has_enc) {

rb_raise(rb_eArgError, "encoding specified twice");

}

}

}

validate_enc_binmode(&fmode, ecflags, enc, enc2);

int fd;

struct sysopen_struct data;

data.fname = rb_str_encode_ospath(fname);

data.oflags = oflags;

data.perm = perm;

fptr->mode = fmode | FMODE_SYNC|FMODE_DUPLEX;

if (convconfig) {

fptr->encs = *convconfig;

}

}

fptr->pid = pid;

GetOpenFile(io, fptr);

fptr->encs.ecflags |= ECONV_DEFAULT_NEWLINE_DECORATOR;

fptr->stdio_file = f;

return io;

if (stdout_binmode) rb_io_binmode(rb_stdout);

}

fmode = FMODE_READABLE;

ARGF.current_file = prep_io(fr, fmode, rb_cFile, fn);

if (!NIL_P(write_io)) {

rb_io_set_write_io(ARGF.current_file, write_io);

fptr->encs.ecflags &= ~ECONV_NEWLINE_DECORATOR_MASK;

if (!ARGF.binmode) {

fptr->encs.ecflags |= ECONV_DEFAULT_NEWLINE_DECORATOR;

}

}

ARGF.next_p = 0;

}

else

enc = rb_to_encoding(v2);

ecflags = rb_econv_prepare_options(opt, &ecopts, ecflags);

}

else {

if (NIL_P(v1)) {

/* Set to default encodings */

rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2);

ecopts = Qnil;

}

else {

tmp = rb_check_string_type(v1);

if (!NIL_P(tmp) && rb_enc_asciicompat(rb_enc_get(tmp))) {

parse_mode_enc(RSTRING_PTR(tmp), &enc, &enc2, NULL);

ecflags = rb_econv_prepare_options(opt, &ecopts, ecflags);

}

else {

rb_io_ext_int_to_encs(rb_to_encoding(v1), NULL, &enc, &enc2);

ecopts = Qnil;

}

}

extract_binmode(opt, &fmode);

#if DEFAULT_TEXTMODE

fptr->mode &= ~FMODE_TEXTMODE;

#endif

fptr->mode |= fmode;

#if DEFAULT_TEXTMODE

fptr2->mode &= ~FMODE_TEXTMODE;

#endif

fptr2->mode |= fmode;

}

stp->dst_fd = dst_fd;

if (stp->src_offset == (off_t)-1 && src_fptr && src_fptr->rbuf.len) {

size_t len = src_fptr->rbuf.len;

VALUE str;

end

# Provided by Tom Talbott

def test_more_ordering

actual = [

"Head south from Phinney Ave N",

"Turn left at N 36th St",

"".encode("euc-jp", :undef => :replace, :replace => broken)

}

end

end

}

assert(c.ascii_only?, "should be ascii_only #{bug4557}")

end

#include "transcode_data.h"

#include <ctype.h>

/* VALUE rb_cEncoding = rb_define_class("Encoding", rb_cObject); */

VALUE rb_eUndefinedConversionError;

VALUE rb_eInvalidByteSequenceError;

return -1;

tr = load_transcoder_entry(entry);

return rb_econv_add_transcoder_at(ec, tr, n);

}

* # [#<Encoding:UTF-8>, #<Encoding:EUC-JP>]]

*

* p Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP", universal_newline: true)

* #=> [[#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>],

* # [#<Encoding:UTF-8>, #<Encoding:EUC-JP>],

* # "universal_newline"]

*

* p Encoding::Converter.search_convpath("ISO-8859-1", "UTF-32BE", universal_newline: true)

* #=> [[#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>],

* # "universal_newline",

* # [#<Encoding:UTF-8>, #<Encoding:UTF-32BE>]]

* :undef => nil # raise error on undefined conversion (default)

* :undef => :replace # replace undefined conversion

* :replace => string # replacement string ("?" or "\uFFFD" if not specified)

* :universal_newline => true # decorator for converting CRLF and CR to LF

* :crlf_newline => true # decorator for converting LF to CRLF

* :cr_newline => true # decorator for converting LF to CR

return result;

}

static VALUE

econv_result_to_symbol(rb_econv_result_t res)

{

rb_define_method(rb_cEncodingConverter, "last_error", econv_last_error, 0);

rb_define_method(rb_cEncodingConverter, "replacement", econv_get_replacement, 0);

rb_define_method(rb_cEncodingConverter, "replacement=", econv_set_replacement, 1);

rb_define_const(rb_cEncodingConverter, "INVALID_MASK", INT2FIX(ECONV_INVALID_MASK));

rb_define_const(rb_cEncodingConverter, "INVALID_REPLACE", INT2FIX(ECONV_INVALID_REPLACE));

int keep = 0;

#define open_null(fd) \

(((nullfd < 0) ? \

((nullfd == (fd)) ? (keep = 1) : dup2(nullfd, fd)), \

(fd))

if (fileno(stdout) < 0) {

stdout->_file = open_null(1);

}

if (fileno(stderr) < 0) {

stderr->_file = open_null(2);

}

if (nullfd >= 0 && !keep) close(nullfd);

setvbuf(stderr, NULL, _IONBF, 0);

}

return -1;

}

return _write(fd, buf, size);

}

}

return numaddr;

}