ruby-changes:54840
From: naruse <ko1@a...>
Date: Wed, 13 Feb 2019 09:31:47 +0900 (JST)
Subject: [ruby-changes:54840] naruse:r66532: Release branch of Ruby 2.6
naruse 2018-12-25 07:13:36 +0900 (Tue, 25 Dec 2018) New Revision: 66532 https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=66532 Log: Release branch of Ruby 2.6 Added directories: branches/ruby_2_6/ Index: ruby_2_6/ext/ripper/tools/generate-param-macros.rb =================================================================== --- ruby_2_6/ext/ripper/tools/generate-param-macros.rb (nonexistent) +++ ruby_2_6/ext/ripper/tools/generate-param-macros.rb (revision 66532) @@ -0,0 +1,15 @@ https://github.com/ruby/ruby/blob/trunk/ruby_2_6/ext/ripper/tools/generate-param-macros.rb#L1 +# frozen_string_literal: true +off = true +ARGF.each do |line| + case line + when /RIPPER_PARAMS_DECL_BEGIN/ + off = false + when /RIPPER_PARAMS_DECL_END/ + exit + when /ripper/ + next if off + var = line.scan(/\w+/).last or next + base = var.sub(/ripper_/, '') + puts %"\#define #{base}\t\t(parser->ripper_#{base})" + end +end Property changes on: ruby_2_6/ext/ripper/tools/generate-param-macros.rb ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +LF \ No newline at end of property Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Index: ruby_2_6/ext/ripper/tools/strip.rb =================================================================== --- ruby_2_6/ext/ripper/tools/strip.rb (nonexistent) +++ ruby_2_6/ext/ripper/tools/strip.rb (revision 66532) @@ -0,0 +1,12 @@ https://github.com/ruby/ruby/blob/trunk/ruby_2_6/ext/ripper/tools/strip.rb#L1 +# frozen_string_literal: true +last_is_void = false +ARGF.each do |line| + case line + when /\A\s*\z/, /\A\#/ + puts unless last_is_void + last_is_void = true + else + print line + last_is_void = false + end +end Property changes on: ruby_2_6/ext/ripper/tools/strip.rb ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +LF \ No newline at end of property Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Index: ruby_2_6/ext/cgi/escape/escape.c =================================================================== --- ruby_2_6/ext/cgi/escape/escape.c (nonexistent) +++ ruby_2_6/ext/cgi/escape/escape.c (revision 66532) @@ -0,0 +1,422 @@ https://github.com/ruby/ruby/blob/trunk/ruby_2_6/ext/cgi/escape/escape.c#L1 +#include "ruby.h" +#include "ruby/encoding.h" + +RUBY_EXTERN unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow); +RUBY_EXTERN const char ruby_hexdigits[]; +RUBY_EXTERN const signed char ruby_digit36_to_number_table[]; +#define lower_hexdigits (ruby_hexdigits+0) +#define upper_hexdigits (ruby_hexdigits+16) +#define char_to_number(c) ruby_digit36_to_number_table[(unsigned char)(c)] + +static VALUE rb_cCGI, rb_mUtil, rb_mEscape; +static ID id_accept_charset; + +static void +html_escaped_cat(VALUE str, char c) +{ + switch (c) { + case '\'': + rb_str_cat_cstr(str, "'"); + break; + case '&': + rb_str_cat_cstr(str, "&"); + break; + case '"': + rb_str_cat_cstr(str, """); + break; + case '<': + rb_str_cat_cstr(str, "<"); + break; + case '>': + rb_str_cat_cstr(str, ">"); + break; + } +} + +static inline void +preserve_original_state(VALUE orig, VALUE dest) +{ + rb_enc_associate(dest, rb_enc_get(orig)); + + RB_OBJ_INFECT_RAW(dest, orig); +} + +static VALUE +optimized_escape_html(VALUE str) +{ + long i, len, beg = 0; + VALUE dest = 0; + const char *cstr; + + len = RSTRING_LEN(str); + cstr = RSTRING_PTR(str); + + for (i = 0; i < len; i++) { + switch (cstr[i]) { + case '\'': + case '&': + case '"': + case '<': + case '>': + if (!dest) { + dest = rb_str_buf_new(len); + } + + rb_str_cat(dest, cstr + beg, i - beg); + beg = i + 1; + + html_escaped_cat(dest, cstr[i]); + break; + } + } + + if (dest) { + rb_str_cat(dest, cstr + beg, len - beg); + preserve_original_state(str, dest); + return dest; + } + else { + return rb_str_dup(str); + } +} + +static VALUE +optimized_unescape_html(VALUE str) +{ + enum {UNICODE_MAX = 0x10ffff}; + rb_encoding *enc = rb_enc_get(str); + unsigned long charlimit = (strcasecmp(rb_enc_name(enc), "UTF-8") == 0 ? UNICODE_MAX : + strcasecmp(rb_enc_name(enc), "ISO-8859-1") == 0 ? 256 : + 128); + long i, len, beg = 0; + size_t clen, plen; + int overflow; + const char *cstr; + char buf[6]; + VALUE dest = 0; + + len = RSTRING_LEN(str); + cstr = RSTRING_PTR(str); + + for (i = 0; i < len; i++) { + unsigned long cc; + char c = cstr[i]; + if (c != '&') continue; + plen = i - beg; + if (++i >= len) break; + c = (unsigned char)cstr[i]; +#define MATCH(s) (len - i >= (int)rb_strlen_lit(s) && \ + memcmp(&cstr[i], s, rb_strlen_lit(s)) == 0 && \ + (i += rb_strlen_lit(s) - 1, 1)) + switch (c) { + case 'a': + ++i; + if (MATCH("pos;")) { + c = '\''; + } + else if (MATCH("mp;")) { + c = '&'; + } + else continue; + break; + case 'q': + ++i; + if (MATCH("uot;")) { + c = '"'; + } + else continue; + break; + case 'g': + ++i; + if (MATCH("t;")) { + c = '>'; + } + else continue; + break; + case 'l': + ++i; + if (MATCH("t;")) { + c = '<'; + } + else continue; + break; + case '#': + if (len - ++i >= 2 && ISDIGIT(cstr[i])) { + cc = ruby_scan_digits(&cstr[i], len-i, 10, &clen, &overflow); + } + else if ((cstr[i] == 'x' || cstr[i] == 'X') && len - ++i >= 2 && ISXDIGIT(cstr[i])) { + cc = ruby_scan_digits(&cstr[i], len-i, 16, &clen, &overflow); + } + else continue; + i += clen; + if (overflow || cc >= charlimit || cstr[i] != ';') continue; + if (!dest) { + dest = rb_str_buf_new(len); + } + rb_str_cat(dest, cstr + beg, plen); + if (charlimit > 256) { + rb_str_cat(dest, buf, rb_enc_mbcput((OnigCodePoint)cc, buf, enc)); + } + else { + c = (unsigned char)cc; + rb_str_cat(dest, &c, 1); + } + beg = i + 1; + continue; + default: + --i; + continue; + } + if (!dest) { + dest = rb_str_buf_new(len); + } + rb_str_cat(dest, cstr + beg, plen); + rb_str_cat(dest, &c, 1); + beg = i + 1; + } + + if (dest) { + rb_str_cat(dest, cstr + beg, len - beg); + preserve_original_state(str, dest); + return dest; + } + else { + return rb_str_dup(str); + } +} + +static unsigned char +url_unreserved_char(unsigned char c) +{ + switch (c) { + case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': + case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': + case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': + case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': + case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': + case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': + case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': + case '-': case '.': case '_': case '~': + return 1; + default: + break; + } + return 0; +} + +static VALUE +optimized_escape(VALUE str) +{ + long i, len, beg = 0; + VALUE dest = 0; + const char *cstr; + char buf[4] = {'%'}; + + len = RSTRING_LEN(str); + cstr = RSTRING_PTR(str); + + for (i = 0; i < len; ++i) { + const unsigned char c = (unsigned char)cstr[i]; + if (!url_unreserved_char(c)) { + if (!dest) { + dest = rb_str_buf_new(len); + } + + rb_str_cat(dest, cstr + beg, i - beg); + beg = i + 1; + + if (c == ' ') { + rb_str_cat_cstr(dest, "+"); + } + else { + buf[1] = upper_hexdigits[(c >> 4) & 0xf]; + buf[2] = upper_hexdigits[c & 0xf]; + rb_str_cat(dest, buf, 3); + } + } + } + + if (dest) { + rb_str_cat(dest, cstr + beg, len - beg); + preserve_original_state(str, dest); + return dest; + } + else { + return rb_str_dup(str); + } +} + +static VALUE +optimized_unescape(VALUE str, VALUE encoding) +{ + long i, len, beg = 0; + VALUE dest = 0; + const char *cstr; + rb_encoding *enc = rb_to_encoding(encoding); + int cr, origenc, encidx = rb_enc_to_index(enc); + + len = RSTRING_LEN(str); + cstr = RSTRING_PTR(str); + + for (i = 0; i < len; ++i) { + char buf[1]; + const char c = cstr[i]; + int clen = 0; + if (c == '%') { + if (i + 3 > len) break; + if (!ISXDIGIT(cstr[i+1])) continue; + if (!ISXDIGIT(cstr[i+2])) continue; + buf[0] = ((char_to_number(cstr[i+1]) << 4) + | char_to_number(cstr[i+2])); + clen = 2; + } + else if (c == '+') { + buf[0] = ' '; + } + else { + continue; + } + + if (!dest) { + dest = rb_str_buf_new(len); + } + + rb_str_cat(dest, cstr + beg, i - beg); + i += clen; + beg = i + 1; + + rb_str_cat(dest, buf, 1); + } + + if (dest) { + rb_str_cat(dest, cstr + beg, len - beg); + preserve_original_state(str, dest); + cr = ENC_CODERANGE_UNKNOWN; + } + else { + dest = rb_str_dup(str); + cr = ENC_CODERANGE(str); + } + origenc = rb_enc_get_index(str); + if (origenc != encidx) { + rb_enc_associate_index(dest, encidx); + if (!ENC_CODERANGE_CLEAN_P(rb_enc_str_coderange(dest))) { + rb_enc_associate_index(dest, origenc); + if (cr != ENC_CODERANGE_UNKNOWN) + ENC_CODERANGE_SET(dest, cr); + } + } + return dest; +} + +/* + * call-seq: + * CGI.escapeHTML(string) -> string + * + * Returns HTML-escaped string. + * + */ +static VALUE +cgiesc_escape_html(VALUE self, VALUE str) +{ + StringValue(str); + + if (rb_enc_str_asciicompat_p(str)) { + return optimized_escape_html(str); + } + else { + return rb_call_super(1, &str); + } +} + +/* + * call-seq: + * CGI.unescapeHTML(string) -> string + * + * Returns HTML-unescaped string. + * + */ +static VALUE +cgiesc_unescape_html(VALUE self, VALUE str) +{ + StringValue(str); + + if (rb_enc_str_asciicompat_p(str)) { + return optimized_unescape_html(str); + } + else { + return rb_call_super(1, &str); + } +} + +/* + * call-seq: + * CGI.escape(string) -> string + * + * Returns URL-escaped string. + * + */ +static VALUE +cgiesc_escape(VALUE self, VALUE str) +{ + StringValue(str); + + if (rb_enc_str_asciicompat_p(str)) { + return optimized_escape(str); + } + else { + return rb_call_super(1, &str); + } +} + +static VALUE +accept_charset(int argc, VALUE *argv, VALUE self) +{ + if (argc > 0) + return argv[0]; + return rb_cvar_get(CLASS_OF(self), id_accept_charset); +} + +/* + * call-seq: + * CGI.unescape(string, encoding=@@accept_charset) -> string + * + * Returns URL-unescaped string. + * + */ +static VALUE +cgiesc_unescape(int argc, VALUE *argv, VALUE self) +{ + VALUE str = (rb_check_arity(argc, 1, 2), argv[0]); + + StringValue(str); + + if (rb_enc_str_asciicompat_p(str)) { + VALUE enc = accept_charset(argc-1, argv+1, self); + return optimized_unescape(str, enc); + } + else { + return rb_call_super(argc, argv); + } +} + +void +Init_escape(void) +{ + id_accept_charset = rb_intern_const("@@accept_charset"); + InitVM(escape); +} + +void +InitVM_escape(void) +{ + rb_cCGI = rb_define_class("CGI", rb_cObject); + rb_mEscape = rb_define_module_under(rb_cCGI, "Escape"); + rb_mUtil = rb_define_module_under(rb_cCGI, "Util"); + rb_define_method(rb_mEscape, "escapeHTML", cgiesc_escape_html, 1); + rb_define_method(rb_mEscape, "unescapeHTML", cgiesc_unescape_html, 1); + rb_define_method(rb_mEscape, "escape", cgiesc_escape, 1); + rb_define_method(rb_mEscape, "unescape", cgiesc_unescape, -1); + rb_prepend_module(rb_mUtil, rb_mEscape); + rb_extend_object(rb_cCGI, rb_mEscape); +} Property changes on: ruby_2_6/ext/cgi/escape/escape.c ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +LF \ No newline at end of property Index: ruby_2_6/ext/io/console/buildgem.sh =================================================================== --- ruby_2_6/ext/io/console/buildgem.sh (nonexistent) +++ ruby_2_6/ext/io/console/buildgem.sh (revision 66532) @@ -0,0 +1,5 @@ https://github.com/ruby/ruby/blob/trunk/ruby_2_6/ext/io/console/buildgem.sh#L1 +#!/bin/sh -e +cd ${0%/*} +trap "mv depend.$$ depend" 0 2 +${RUBY-ruby} -i.$$ -pe 'exit if /^win32_vk/' depend +${GEM-gem} build io-console.gemspec Property changes on: ruby_2_6/ext/io/console/buildgem.sh ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +LF \ No newline at end of property Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Index: ruby_2_6/ext/ripper/eventids2.c =================================================================== --- ruby_2_6/ext/ripper/eventids2.c (nonexistent) +++ ruby_2_6/ext/ripper/eventids2.c (revision 66532) @@ -0,0 +1,307 @@ https://github.com/ruby/ruby/blob/trunk/ruby_2_6/ext/ripper/eventids2.c#L1 +enum { + tIGNORED_NL = tLAST_TOKEN + 1, + tCOMMENT, + tEMBDOC_BEG, + tEMBDOC, + tEMBDOC_END, + tHEREDOC_BEG, + tHEREDOC_END, + k__END__ +}; + +typedef struct { + ID ripper_id_backref; + ID ripper_id_backtick; + ID ripper_id_comma; + ID ripper_id_const; + ID ripper_id_cvar; + ID ripper_id_embexpr_beg; + ID ripper_id_embexpr_end; + ID ripper_id_embvar; + ID ripper_id_float; + ID ripper_id_gvar; + ID ripper_id_ident; + ID ripper_id_imaginary; + ID ripper_id_int; + ID ripper_id_ivar; + ID ripper_id_kw; + ID ripper_id_lbrace; + ID ripper_id_lbracket; + ID ripper_id_lparen; + ID ripper_id_nl; + ID ripper_id_op; + ID ripper_id_period; + ID ripper_id_rbrace; + ID ripper_id_rbracket; + ID ripper_id_rparen; + ID ripper_id_semicolon; + ID ripper_id_symbeg; + ID ripper_id_tstring_beg; + ID ripper_id_tstring_content; + ID ripper_id_tstring_end; + ID ripper_id_words_beg; + ID ripper_id_qwords_beg; + ID ripper_id_qsymbols_beg; + ID ripper_id_symbols_beg; + ID ripper_id_words_sep; + ID ripper_id_rational; + ID ripper_id_regexp_beg; + ID ripper_id_regexp_end; + ID ripper_id_label; + ID ripper_id_label_end; + ID ripper_id_tlambda; + ID ripper_id_tlambeg; + + ID ripper_id_ignored_nl; + ID ripper_id_comment; + ID ripper_id_embdoc_beg; + ID ripper_id_embdoc; + ID ripper_id_embdoc_end; + ID ripper_id_sp; + ID ripper_id_heredoc_beg; + ID ripper_id_heredoc_end; + ID ripper_id___end__; + ID ripper_id_CHAR; +} ripper_scanner_ids_t; + +static ripper_scanner_ids_t ripper_scanner_ids; + +#include "eventids2table.c" + +static void +ripper_init_eventids2(void) +{ +#define set_id2(name) ripper_scanner_ids.ripper_id_##name = rb_intern_const("on_"#name) + set_id2(backref); + set_id2(backtick); + set_id2(comma); + set_id2(const); + set_id2(cvar); + set_id2(embexpr_beg); + set_id2(embexpr_end); + set_id2(embvar); + set_id2(float); + set_id2(gvar); + set_id2(ident); + set_id2(imaginary); + set_id2(int); + set_id2(ivar); + set_id2(kw); + set_id2(lbrace); + set_id2(lbracket); + set_id2(lparen); + set_id2(nl); + set_id2(op); + set_id2(period); + set_id2(rbrace); + set_id2(rbracket); + set_id2(rparen); + set_id2(semicolon); + set_id2(symbeg); + set_id2(tstring_beg); + set_id2(tstring_content); + set_id2(tstring_end); + set_id2(words_beg); + set_id2(qwords_beg); + set_id2(qsymbols_beg); + set_id2(symbols_beg); + set_id2(words_sep); + set_id2(rational); + set_id2(regexp_beg); + set_id2(regexp_end); + set_id2(label); + set_id2(label_end); + set_id2(tlambda); + set_id2(tlambeg); + + set_id2(ignored_nl); + set_id2(comment); + set_id2(embdoc_beg); + set_id2(embdoc); + set_id2(embdoc_end); + set_id2(sp); + set_id2(heredoc_beg); + set_id2(heredoc_end); + set_id2(__end__); + set_id2(CHAR); +} + +STATIC_ASSERT(k__END___range, k__END__ < SHRT_MAX); +STATIC_ASSERT(ripper_scanner_ids_size, sizeof(ripper_scanner_ids) < SHRT_MAX); +#define O(member) (int)offsetof(ripper_scanner_ids_t, ripper_id_##member) + +static const struct token_assoc { + unsigned short token; + unsigned short id_offset; +} token_to_eventid[] = { + {' ', O(words_sep)}, + {'!', O(op)}, + {'%', O(op)}, + {'&', O(op)}, + {'*', O(op)}, + {'+', O(op)}, + {'-', O(op)}, + {'/', O(op)}, + {'<', O(op)}, + {'=', O(op)}, + {'>', O(op)}, + {'?', O(op)}, + {'^', O(op)}, + {'|', O(op)}, + {'~', O(op)}, + {':', O(op)}, + {',', O(comma)}, + {'.', O(period)}, + {';', O(semicolon)}, + {'`', O(backtick)}, + {'\n', O(nl)}, + {keyword_alias, O(kw)}, + {keyword_and, O(kw)}, + {keyword_begin, O(kw)}, + {keyword_break, O(kw)}, + {keyword_case, O(kw)}, + {keyword_class, O(kw)}, + {keyword_def, O(kw)}, + {keyword_defined, O(kw)}, + {keyword_do, O(kw)}, + {keyword_do_block, O(kw)}, + {keyword_do_cond, O(kw)}, + {keyword_else, O(kw)}, + {keyword_elsif, O(kw)}, + {keyword_end, O(kw)}, + {keyword_ensure, O(kw)}, + {keyword_false, O(kw)}, + {keyword_for, O(kw)}, + {keyword_if, O(kw)}, + {modifier_if, O(kw)}, + {keyword_in, O(kw)}, + {keyword_module, O(kw)}, + {keyword_next, O(kw)}, + {keyword_nil, O(kw)}, + {keyword_not, O(kw)}, + {keyword_or, O(kw)}, + {keyword_redo, O(kw)}, + {keyword_rescue, O(kw)}, + {modifier_rescue, O(kw)}, + {keyword_retry, O(kw)}, + {keyword_return, O(kw)}, + {keyword_self, O(kw)}, + {keyword_super, O(kw)}, + {keyword_then, O(kw)}, + {keyword_true, O(kw)}, + {keyword_undef, O(kw)}, + {keyword_unless, O(kw)}, + {modifier_unless, O(kw)}, + {keyword_until, O(kw)}, + {modifier_until, O(kw)}, + {keyword_when, O(kw)}, + {keyword_while, O(kw)}, + {modifier_while, O(kw)}, + {keyword_yield, O(kw)}, + {keyword__FILE__, O(kw)}, + {keyword__LINE__, O(kw)}, + {keyword__ENCODING__, O(kw)}, + {keyword_BEGIN, O(kw)}, + {keyword_END, O(kw)}, + {keyword_do_LAMBDA, O(kw)}, + {tAMPER, O(op)}, + {tANDOP, O(op)}, + {tAREF, O(op)}, + {tASET, O(op)}, + {tASSOC, O(op)}, + {tBACK_REF, O(backref)}, + {tCHAR, O(CHAR)}, + {tCMP, O(op)}, + {tCOLON2, O(op)}, + {tCOLON3, O(op)}, + {tCONSTANT, O(const)}, + {tCVAR, O(cvar)}, + {tDOT2, O(op)}, + {tDOT3, O(op)}, + {tEQ, O(op)}, + {tEQQ, O(op)}, + {tFID, O(ident)}, + {tFLOAT, O(float)}, + {tGEQ, O(op)}, + {tGVAR, O(gvar)}, + {tIDENTIFIER, O(ident)}, + {tIMAGINARY, O(imaginary)}, + {tINTEGER, O(int)}, + {tIVAR, O(ivar)}, + {tLBRACE, O(lbrace)}, + {tLBRACE_ARG, O(lbrace)}, + {'{', O(lbrace)}, + {'}', O(rbrace)}, + {tLBRACK, O(lbracket)}, + {'[', O(lbracket)}, + {']', O(rbracket)}, + {tLEQ, O(op)}, + {tLPAREN, O(lparen)}, + {tLPAREN_ARG, O(lparen)}, + {'(', O(lparen)}, + {')', O(rparen)}, + {tLSHFT, O(op)}, + {tMATCH, O(op)}, + {tNEQ, O(op)}, + {tNMATCH, O(op)}, + {tNTH_REF, O(backref)}, + {tOP_ASGN, O(op)}, + {tOROP, O(op)}, + {tPOW, O(op)}, + {tQWORDS_BEG, O(qwords_beg)}, + {tQSYMBOLS_BEG, O(qsymbols_beg)}, + {tSYMBOLS_BEG, O(symbols_beg)}, + {tRATIONAL, O(rational)}, + {tREGEXP_BEG, O(regexp_beg)}, + {tREGEXP_END, O(regexp_end)}, + {tRPAREN, O(rparen)}, + {tRSHFT, O(op)}, + {tSTAR, O(op)}, + {tDSTAR, O(op)}, + {tANDDOT, O(op)}, + {tSTRING_BEG, O(tstring_beg)}, + {tSTRING_CONTENT, O(tstring_content)}, + {tSTRING_DBEG, O(embexpr_beg)}, + {tSTRING_DEND, O(embexpr_end)}, + {tSTRING_DVAR, O(embvar)}, + {tSTRING_END, O(tstring_end)}, + {tSYMBEG, O(symbeg)}, + {tUMINUS, O(op)}, + {tUMINUS_NUM, O(op)}, + {tU (... truncated) -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/