From 5b21e94bebed90180d8ff63dad03b8b948361089 Mon Sep 17 00:00:00 2001 From: Takashi Kokubun Date: Thu, 21 Jul 2022 09:23:58 -0700 Subject: Expand tabs [ci skip] [Misc #18891] --- re.c | 1272 +++++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 636 insertions(+), 636 deletions(-) (limited to 're.c') diff --git a/re.c b/re.c index 0f0eba0552..7642dc3651 100644 --- a/re.c +++ b/re.c @@ -94,8 +94,8 @@ rb_memcicmp(const void *x, const void *y, long len) int tmp; while (len--) { - if ((tmp = casetable[(unsigned)*p1++] - casetable[(unsigned)*p2++])) - return tmp; + if ((tmp = casetable[(unsigned)*p1++] - casetable[(unsigned)*p2++])) + return tmp; } return 0; } @@ -107,9 +107,9 @@ rb_memsearch_ss(const unsigned char *xs, long m, const unsigned char *ys, long n const unsigned char *y; if ((y = memmem(ys, n, xs, m)) != NULL) - return y - ys; + return y - ys; else - return -1; + return -1; } #else static inline long @@ -121,26 +121,26 @@ rb_memsearch_ss(const unsigned char *xs, long m, const unsigned char *ys, long n VALUE hx, hy, mask = VALUE_MAX >> ((SIZEOF_VALUE - m) * CHAR_BIT); if (m > SIZEOF_VALUE) - rb_bug("!!too long pattern string!!"); + rb_bug("!!too long pattern string!!"); if (!(y = memchr(y, *x, n - m + 1))) - return -1; + return -1; /* Prepare hash value */ for (hx = *x++, hy = *y++; x < xe; ++x, ++y) { - hx <<= CHAR_BIT; - hy <<= CHAR_BIT; - hx |= *x; - hy |= *y; + hx <<= CHAR_BIT; + hy <<= CHAR_BIT; + hx |= *x; + hy |= *y; } /* Searching */ while (hx != hy) { - if (y == ye) - return -1; - hy <<= CHAR_BIT; - hy |= *y; - hy &= mask; - y++; + if (y == ye) + return -1; + hy <<= CHAR_BIT; + hy |= *y; + hy &= mask; + y++; } return y - ys - m; } @@ -155,13 +155,13 @@ rb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long n /* Preprocessing */ for (i = 0; i < 256; ++i) - qstable[i] = m + 1; + qstable[i] = m + 1; for (; x < xe; ++x) - qstable[*x] = xe - x; + qstable[*x] = xe - x; /* Searching */ for (; y + m <= ys + n; y += *(qstable + y[m])) { - if (*xs == *y && memcmp(xs, y, m) == 0) - return y - ys; + if (*xs == *y && memcmp(xs, y, m) == 0) + return y - ys; } return -1; } @@ -172,28 +172,28 @@ rb_memsearch_qs_utf8_hash(const unsigned char *x) register const unsigned int mix = 8353; register unsigned int h = *x; if (h < 0xC0) { - return h + 256; + return h + 256; } else if (h < 0xE0) { - h *= mix; - h += x[1]; + h *= mix; + h += x[1]; } else if (h < 0xF0) { - h *= mix; - h += x[1]; - h *= mix; - h += x[2]; + h *= mix; + h += x[1]; + h *= mix; + h += x[2]; } else if (h < 0xF5) { - h *= mix; - h += x[1]; - h *= mix; - h += x[2]; - h *= mix; - h += x[3]; + h *= mix; + h += x[1]; + h *= mix; + h += x[2]; + h *= mix; + h += x[3]; } else { - return h + 256; + return h + 256; } return (unsigned char)h; } @@ -207,15 +207,15 @@ rb_memsearch_qs_utf8(const unsigned char *xs, long m, const unsigned char *ys, l /* Preprocessing */ for (i = 0; i < 512; ++i) { - qstable[i] = m + 1; + qstable[i] = m + 1; } for (; x < xe; ++x) { - qstable[rb_memsearch_qs_utf8_hash(x)] = xe - x; + qstable[rb_memsearch_qs_utf8_hash(x)] = xe - x; } /* Searching */ for (; y + m <= ys + n; y += qstable[rb_memsearch_qs_utf8_hash(y+m)]) { - if (*xs == *y && memcmp(xs, y, m) == 0) - return y - ys; + if (*xs == *y && memcmp(xs, y, m) == 0) + return y - ys; } return -1; } @@ -227,8 +227,8 @@ rb_memsearch_wchar(const unsigned char *xs, long m, const unsigned char *ys, lon enum {char_size = 2}; for (n -= m; n >= 0; n -= char_size, y += char_size) { - if (x0 == *y && memcmp(x+1, y+1, m-1) == 0) - return y - ys; + if (x0 == *y && memcmp(x+1, y+1, m-1) == 0) + return y - ys; } return -1; } @@ -240,8 +240,8 @@ rb_memsearch_qchar(const unsigned char *xs, long m, const unsigned char *ys, lon enum {char_size = 4}; for (n -= m; n >= 0; n -= char_size, y += char_size) { - if (x0 == *y && memcmp(x+1, y+1, m-1) == 0) - return y - ys; + if (x0 == *y && memcmp(x+1, y+1, m-1) == 0) + return y - ys; } return -1; } @@ -253,32 +253,32 @@ rb_memsearch(const void *x0, long m, const void *y0, long n, rb_encoding *enc) if (m > n) return -1; else if (m == n) { - return memcmp(x0, y0, m) == 0 ? 0 : -1; + return memcmp(x0, y0, m) == 0 ? 0 : -1; } else if (m < 1) { - return 0; + return 0; } else if (m == 1) { - const unsigned char *ys = memchr(y, *x, n); + const unsigned char *ys = memchr(y, *x, n); - if (ys) - return ys - y; - else - return -1; + if (ys) + return ys - y; + else + return -1; } else if (LIKELY(rb_enc_mbminlen(enc) == 1)) { - if (m <= SIZEOF_VALUE) { - return rb_memsearch_ss(x0, m, y0, n); - } - else if (enc == rb_utf8_encoding()){ - return rb_memsearch_qs_utf8(x0, m, y0, n); - } + if (m <= SIZEOF_VALUE) { + return rb_memsearch_ss(x0, m, y0, n); + } + else if (enc == rb_utf8_encoding()){ + return rb_memsearch_qs_utf8(x0, m, y0, n); + } } else if (LIKELY(rb_enc_mbminlen(enc) == 2)) { - return rb_memsearch_wchar(x0, m, y0, n); + return rb_memsearch_wchar(x0, m, y0, n); } else if (LIKELY(rb_enc_mbminlen(enc) == 4)) { - return rb_memsearch_qchar(x0, m, y0, n); + return rb_memsearch_qchar(x0, m, y0, n); } return rb_memsearch_qs(x0, m, y0, n); } @@ -300,17 +300,17 @@ char_to_option(int c) switch (c) { case 'i': - val = ONIG_OPTION_IGNORECASE; - break; + val = ONIG_OPTION_IGNORECASE; + break; case 'x': - val = ONIG_OPTION_EXTEND; - break; + val = ONIG_OPTION_EXTEND; + break; case 'm': - val = ONIG_OPTION_MULTILINE; - break; + val = ONIG_OPTION_MULTILINE; + break; default: - val = 0; - break; + val = 0; + break; } return val; } @@ -338,17 +338,17 @@ rb_char_to_option_kcode(int c, int *option, int *kcode) *kcode = rb_ascii8bit_encindex(); return (*option = ARG_ENCODING_NONE); case 'e': - *kcode = ENCINDEX_EUC_JP; - break; + *kcode = ENCINDEX_EUC_JP; + break; case 's': - *kcode = ENCINDEX_Windows_31J; - break; + *kcode = ENCINDEX_Windows_31J; + break; case 'u': - *kcode = rb_utf8_encindex(); - break; + *kcode = rb_utf8_encindex(); + break; default: - *kcode = -1; - return (*option = char_to_option(c)); + *kcode = -1; + return (*option = char_to_option(c)); } *option = ARG_ENCODING_FIXED; return 1; @@ -358,13 +358,13 @@ static void rb_reg_check(VALUE re) { if (!RREGEXP_PTR(re) || !RREGEXP_SRC(re) || !RREGEXP_SRC_PTR(re)) { - rb_raise(rb_eTypeError, "uninitialized Regexp"); + rb_raise(rb_eTypeError, "uninitialized Regexp"); } } static void rb_reg_expr_str(VALUE str, const char *s, long len, - rb_encoding *enc, rb_encoding *resenc, int term) + rb_encoding *enc, rb_encoding *resenc, int term) { const char *p, *pend; int cr = ENC_CODERANGE_UNKNOWN; @@ -374,80 +374,80 @@ rb_reg_expr_str(VALUE str, const char *s, long len, p = s; pend = p + len; rb_str_coderange_scan_restartable(p, pend, enc, &cr); if (rb_enc_asciicompat(enc) && ENC_CODERANGE_CLEAN_P(cr)) { - while (p < pend) { - c = rb_enc_ascget(p, pend, &clen, enc); - if (c == -1) { - if (enc == resenc) { - p += mbclen(p, pend, enc); - } - else { - need_escape = 1; - break; - } - } - else if (c != term && rb_enc_isprint(c, enc)) { - p += clen; - } - else { - need_escape = 1; - break; - } - } + while (p < pend) { + c = rb_enc_ascget(p, pend, &clen, enc); + if (c == -1) { + if (enc == resenc) { + p += mbclen(p, pend, enc); + } + else { + need_escape = 1; + break; + } + } + else if (c != term && rb_enc_isprint(c, enc)) { + p += clen; + } + else { + need_escape = 1; + break; + } + } } else { - need_escape = 1; + need_escape = 1; } if (!need_escape) { - rb_str_buf_cat(str, s, len); + rb_str_buf_cat(str, s, len); } else { - int unicode_p = rb_enc_unicode_p(enc); - p = s; - while (poptions)) - rb_str_buf_cat2(str, opts); - if (RBASIC(re)->flags & REG_ENCODING_NONE) - rb_str_buf_cat2(str, "n"); + char opts[OPTBUF_SIZE]; + rb_reg_check(re); + if (*option_to_str(opts, RREGEXP_PTR(re)->options)) + rb_str_buf_cat2(str, opts); + if (RBASIC(re)->flags & REG_ENCODING_NONE) + rb_str_buf_cat2(str, "n"); } return str; } @@ -581,10 +581,10 @@ rb_reg_str_with_term(VALUE re, int term) len = RREGEXP_SRC_LEN(re); again: if (len >= 4 && ptr[0] == '(' && ptr[1] == '?') { - int err = 1; - ptr += 2; - if ((len -= 2) > 0) { - do { + int err = 1; + ptr += 2; + if ((len -= 2) > 0) { + do { opt = char_to_option((int )*ptr); if (opt != 0) { options |= opt; @@ -592,13 +592,13 @@ rb_reg_str_with_term(VALUE re, int term) else { break; } - ++ptr; - } while (--len > 0); - } - if (len > 1 && *ptr == '-') { - ++ptr; - --len; - do { + ++ptr; + } while (--len > 0); + } + if (len > 1 && *ptr == '-') { + ++ptr; + --len; + do { opt = char_to_option((int )*ptr); if (opt != 0) { options &= ~opt; @@ -606,65 +606,65 @@ rb_reg_str_with_term(VALUE re, int term) else { break; } - ++ptr; - } while (--len > 0); - } - if (*ptr == ')') { - --len; - ++ptr; - goto again; - } - if (*ptr == ':' && ptr[len-1] == ')') { - Regexp *rp; - VALUE verbose = ruby_verbose; - ruby_verbose = Qfalse; - - ++ptr; - len -= 2; + ++ptr; + } while (--len > 0); + } + if (*ptr == ')') { + --len; + ++ptr; + goto again; + } + if (*ptr == ':' && ptr[len-1] == ')') { + Regexp *rp; + VALUE verbose = ruby_verbose; + ruby_verbose = Qfalse; + + ++ptr; + len -= 2; err = onig_new(&rp, ptr, ptr + len, options, - enc, OnigDefaultSyntax, NULL); - onig_free(rp); - ruby_verbose = verbose; - } - if (err) { - options = RREGEXP_PTR(re)->options; - ptr = (UChar*)RREGEXP_SRC_PTR(re); - len = RREGEXP_SRC_LEN(re); - } + enc, OnigDefaultSyntax, NULL); + onig_free(rp); + ruby_verbose = verbose; + } + if (err) { + options = RREGEXP_PTR(re)->options; + ptr = (UChar*)RREGEXP_SRC_PTR(re); + len = RREGEXP_SRC_LEN(re); + } } if (*option_to_str(optbuf, options)) rb_str_buf_cat2(str, optbuf); if ((options & embeddable) != embeddable) { - optbuf[0] = '-'; - option_to_str(optbuf + 1, ~options); - rb_str_buf_cat2(str, optbuf); + optbuf[0] = '-'; + option_to_str(optbuf + 1, ~options); + rb_str_buf_cat2(str, optbuf); } rb_str_buf_cat2(str, ":"); if (rb_enc_asciicompat(enc)) { - rb_reg_expr_str(str, (char*)ptr, len, enc, NULL, term); - rb_str_buf_cat2(str, ")"); + rb_reg_expr_str(str, (char*)ptr, len, enc, NULL, term); + rb_str_buf_cat2(str, ")"); } else { - const char *s, *e; - char *paren; - ptrdiff_t n; - rb_str_buf_cat2(str, ")"); - rb_enc_associate(str, rb_usascii_encoding()); - str = rb_str_encode(str, rb_enc_from_encoding(enc), 0, Qnil); - - /* backup encoded ")" to paren */ - s = RSTRING_PTR(str); - e = RSTRING_END(str); - s = rb_enc_left_char_head(s, e-1, e, enc); - n = e - s; - paren = ALLOCA_N(char, n); - memcpy(paren, s, n); - rb_str_resize(str, RSTRING_LEN(str) - n); - - rb_reg_expr_str(str, (char*)ptr, len, enc, NULL, term); - rb_str_buf_cat(str, paren, n); + const char *s, *e; + char *paren; + ptrdiff_t n; + rb_str_buf_cat2(str, ")"); + rb_enc_associate(str, rb_usascii_encoding()); + str = rb_str_encode(str, rb_enc_from_encoding(enc), 0, Qnil); + + /* backup encoded ")" to paren */ + s = RSTRING_PTR(str); + e = RSTRING_END(str); + s = rb_enc_left_char_head(s, e-1, e, enc); + n = e - s; + paren = ALLOCA_N(char, n); + memcpy(paren, s, n); + rb_str_resize(str, RSTRING_LEN(str) - n); + + rb_reg_expr_str(str, (char*)ptr, len, enc, NULL, term); + rb_str_buf_cat(str, paren, n); } rb_enc_copy(str, re); @@ -710,7 +710,7 @@ static VALUE rb_reg_error_desc(VALUE str, int options, const char *err) { return rb_enc_reg_error_desc(RSTRING_PTR(str), RSTRING_LEN(str), - rb_enc_get(str), options, err); + rb_enc_get(str), options, err); } NORETURN(static void rb_reg_raise_str(VALUE str, int options, const char *err)); @@ -864,8 +864,8 @@ rb_reg_named_captures(VALUE re) static int onig_new_with_source(regex_t** reg, const UChar* pattern, const UChar* pattern_end, - OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax, - OnigErrorInfo* einfo, const char *sourcefile, int sourceline) + OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax, + OnigErrorInfo* einfo, const char *sourcefile, int sourceline) { int r; @@ -878,15 +878,15 @@ onig_new_with_source(regex_t** reg, const UChar* pattern, const UChar* pattern_e r = onig_compile_ruby(*reg, pattern, pattern_end, einfo, sourcefile, sourceline); if (r) { err: - onig_free(*reg); - *reg = NULL; + onig_free(*reg); + *reg = NULL; } return r; } static Regexp* make_regexp(const char *s, long len, rb_encoding *enc, int flags, onig_errmsg_buffer err, - const char *sourcefile, int sourceline) + const char *sourcefile, int sourceline) { Regexp *rp; int r; @@ -900,10 +900,10 @@ make_regexp(const char *s, long len, rb_encoding *enc, int flags, onig_errmsg_bu */ r = onig_new_with_source(&rp, (UChar*)s, (UChar*)(s + len), flags, - enc, OnigDefaultSyntax, &einfo, sourcefile, sourceline); + enc, OnigDefaultSyntax, &einfo, sourcefile, sourceline); if (r) { - onig_error_code_to_str((UChar*)err, r, &einfo); - return 0; + onig_error_code_to_str((UChar*)err, r, &einfo); + return 0; } return rp; } @@ -1072,7 +1072,7 @@ static void match_check(VALUE match) { if (!RMATCH(match)->regexp) { - rb_raise(rb_eTypeError, "uninitialized MatchData"); + rb_raise(rb_eTypeError, "uninitialized MatchData"); } } @@ -1089,7 +1089,7 @@ match_init_copy(VALUE obj, VALUE orig) rm = RMATCH(obj)->rmatch; if (rb_reg_region_copy(&rm->regs, RMATCH_REGS(orig))) - rb_memerror(); + rb_memerror(); if (RMATCH(orig)->rmatch->char_offset_num_allocated) { if (rm->char_offset_num_allocated < rm->regs.num_regs) { @@ -1098,7 +1098,7 @@ match_init_copy(VALUE obj, VALUE orig) } MEMCPY(rm->char_offset, RMATCH(orig)->rmatch->char_offset, struct rmatch_offset, rm->regs.num_regs); - RB_GC_GUARD(orig); + RB_GC_GUARD(orig); } return obj; @@ -1123,9 +1123,9 @@ match_regexp(VALUE match) match_check(match); regexp = RMATCH(match)->regexp; if (NIL_P(regexp)) { - VALUE str = rb_reg_nth_match(0, match); - regexp = rb_reg_regcomp(rb_reg_quote(str)); - RMATCH(match)->regexp = regexp; + VALUE str = rb_reg_nth_match(0, match); + regexp = rb_reg_regcomp(rb_reg_quote(str)); + RMATCH(match)->regexp = regexp; } return regexp; } @@ -1156,7 +1156,7 @@ match_names(VALUE match) { match_check(match); if (NIL_P(RMATCH(match)->regexp)) - return rb_ary_new_capa(0); + return rb_ary_new_capa(0); return rb_reg_names(RMATCH(match)->regexp); } @@ -1188,14 +1188,14 @@ static void name_to_backref_error(VALUE name) { rb_raise(rb_eIndexError, "undefined group name reference: % "PRIsVALUE, - name); + name); } static void backref_number_check(struct re_registers *regs, int i) { if (i < 0 || regs->num_regs <= i) - rb_raise(rb_eIndexError, "index %d out of matches", i); + rb_raise(rb_eIndexError, "index %d out of matches", i); } static int @@ -1209,10 +1209,10 @@ match_backref_number(VALUE match, VALUE backref) match_check(match); if (SYMBOL_P(backref)) { - backref = rb_sym2str(backref); + backref = rb_sym2str(backref); } else if (!RB_TYPE_P(backref, T_STRING)) { - return NUM2INT(backref); + return NUM2INT(backref); } name = StringValueCStr(backref); @@ -1250,7 +1250,7 @@ match_offset(VALUE match, VALUE n) backref_number_check(regs, i); if (BEG(i) < 0) - return rb_assoc_new(Qnil, Qnil); + return rb_assoc_new(Qnil, Qnil); update_char_offset(match); return rb_assoc_new(LONG2NUM(RMATCH(match)->rmatch->char_offset[i].beg), @@ -1309,7 +1309,7 @@ match_begin(VALUE match, VALUE n) backref_number_check(regs, i); if (BEG(i) < 0) - return Qnil; + return Qnil; update_char_offset(match); return LONG2NUM(RMATCH(match)->rmatch->char_offset[i].beg); @@ -1335,7 +1335,7 @@ match_end(VALUE match, VALUE n) backref_number_check(regs, i); if (BEG(i) < 0) - return Qnil; + return Qnil; update_char_offset(match); return LONG2NUM(RMATCH(match)->rmatch->char_offset[i].end); @@ -1377,7 +1377,7 @@ match_nth(VALUE match, VALUE n) long start = BEG(i), end = END(i); if (start < 0) - return Qnil; + return Qnil; return rb_str_subseq(RMATCH(match)->str, start, end - start); } @@ -1421,11 +1421,11 @@ match_nth_length(VALUE match, VALUE n) backref_number_check(regs, i); if (BEG(i) < 0) - return Qnil; + return Qnil; update_char_offset(match); const struct rmatch_offset *const ofs = - &RMATCH(match)->rmatch->char_offset[i]; + &RMATCH(match)->rmatch->char_offset[i]; return LONG2NUM(ofs->end - ofs->beg); } @@ -1461,11 +1461,11 @@ rb_match_nth_defined(int nth, VALUE match) regs = RMATCH_REGS(match); if (!regs) return FALSE; if (nth >= regs->num_regs) { - return FALSE; + return FALSE; } if (nth < 0) { - nth += regs->num_regs; - if (nth <= 0) return FALSE; + nth += regs->num_regs; + if (nth <= 0) return FALSE; } return (BEG(nth) != -1); } @@ -1489,7 +1489,7 @@ rb_backref_set_string(VALUE string, long pos, long len) { VALUE match = rb_backref_get(); if (NIL_P(match) || FL_TEST(match, MATCH_BUSY)) { - match = match_alloc(rb_cMatch); + match = match_alloc(rb_cMatch); } match_set_string(match, string, pos, len); rb_backref_set(match); @@ -1540,9 +1540,9 @@ static void reg_enc_error(VALUE re, VALUE str) { rb_raise(rb_eEncCompatError, - "incompatible encoding regexp match (%s regexp with %s string)", - rb_enc_name(rb_enc_get(re)), - rb_enc_name(rb_enc_get(str))); + "incompatible encoding regexp match (%s regexp with %s string)", + rb_enc_name(rb_enc_get(re)), + rb_enc_name(rb_enc_get(str))); } static inline int @@ -1550,7 +1550,7 @@ str_coderange(VALUE str) { int cr = ENC_CODERANGE(str); if (cr == ENC_CODERANGE_UNKNOWN) { - cr = rb_enc_str_coderange(str); + cr = rb_enc_str_coderange(str); } return cr; } @@ -1572,24 +1572,24 @@ rb_reg_prepare_enc(VALUE re, VALUE str, int warn) if (RREGEXP_PTR(re)->enc == enc) { } else if (cr == ENC_CODERANGE_7BIT && - RREGEXP_PTR(re)->enc == rb_usascii_encoding()) { - enc = RREGEXP_PTR(re)->enc; + RREGEXP_PTR(re)->enc == rb_usascii_encoding()) { + enc = RREGEXP_PTR(re)->enc; } else if (!rb_enc_asciicompat(enc)) { - reg_enc_error(re, str); + reg_enc_error(re, str); } else if (rb_reg_fixed_encoding_p(re)) { if ((!rb_enc_asciicompat(RREGEXP_PTR(re)->enc) || - cr != ENC_CODERANGE_7BIT)) { - reg_enc_error(re, str); - } - enc = RREGEXP_PTR(re)->enc; + cr != ENC_CODERANGE_7BIT)) { + reg_enc_error(re, str); + } + enc = RREGEXP_PTR(re)->enc; } else if (warn && (RBASIC(re)->flags & REG_ENCODING_NONE) && - enc != rb_ascii8bit_encoding() && - cr != ENC_CODERANGE_7BIT) { - rb_warn("historical binary regexp match /.../n against %s string", - rb_enc_name(enc)); + enc != rb_ascii8bit_encoding() && + cr != ENC_CODERANGE_7BIT) { + rb_warn("historical binary regexp match /.../n against %s string", + rb_enc_name(enc)); } return enc; } @@ -1612,11 +1612,11 @@ rb_reg_prepare_re0(VALUE re, VALUE str, onig_errmsg_buffer err) pattern = RREGEXP_SRC_PTR(re); unescaped = rb_reg_preprocess( - pattern, pattern + RREGEXP_SRC_LEN(re), enc, + pattern, pattern + RREGEXP_SRC_LEN(re), enc, &fixed_enc, err, 0); if (NIL_P(unescaped)) { - rb_raise(rb_eArgError, "regexp preprocess failed: %s", err); + rb_raise(rb_eArgError, "regexp preprocess failed: %s", err); } // inherit the timeout settings @@ -1626,11 +1626,11 @@ rb_reg_prepare_re0(VALUE re, VALUE str, onig_errmsg_buffer err) long len; RSTRING_GETMEM(unescaped, ptr, len); r = onig_new(®, (UChar *)ptr, (UChar *)(ptr + len), - reg->options, enc, - OnigDefaultSyntax, &einfo); + reg->options, enc, + OnigDefaultSyntax, &einfo); if (r) { - onig_error_code_to_str((UChar*)err, r, &einfo); - rb_reg_raise(pattern, RREGEXP_SRC_LEN(re), err, re); + onig_error_code_to_str((UChar*)err, r, &einfo); + rb_reg_raise(pattern, RREGEXP_SRC_LEN(re), err, re); } reg->timelimit = timelimit; @@ -1656,22 +1656,22 @@ rb_reg_adjust_startpos(VALUE re, VALUE str, long pos, int reverse) enc = rb_reg_prepare_enc(re, str, 0); if (reverse) { - range = -pos; + range = -pos; } else { - range = RSTRING_LEN(str) - pos; + range = RSTRING_LEN(str) - pos; } if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(str)) { - string = (UChar*)RSTRING_PTR(str); + string = (UChar*)RSTRING_PTR(str); - if (range > 0) { - p = onigenc_get_right_adjust_char_head(enc, string, string + pos, string + RSTRING_LEN(str)); - } - else { - p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, string, string + pos, string + RSTRING_LEN(str)); - } - return p - string; + if (range > 0) { + p = onigenc_get_right_adjust_char_head(enc, string, string + pos, string + RSTRING_LEN(str)); + } + else { + p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, string, string + pos, string + RSTRING_LEN(str)); + } + return p - string; } return pos; @@ -1693,8 +1693,8 @@ rb_reg_search_set_match(VALUE re, VALUE str, long pos, int reverse, int set_back RSTRING_GETMEM(str, start, len); range = start; if (pos > len || pos < 0) { - rb_backref_set(Qnil); - return -1; + rb_backref_set(Qnil); + return -1; } reg = rb_reg_prepare_re0(re, str, err); @@ -1703,35 +1703,35 @@ rb_reg_search_set_match(VALUE re, VALUE str, long pos, int reverse, int set_back MEMZERO(regs, struct re_registers, 1); if (!reverse) { - range += len; + range += len; } result = onig_search(reg, - (UChar*)start, - ((UChar*)(start + len)), - ((UChar*)(start + pos)), - ((UChar*)range), - regs, ONIG_OPTION_NONE); + (UChar*)start, + ((UChar*)(start + len)), + ((UChar*)(start + pos)), + ((UChar*)range), + regs, ONIG_OPTION_NONE); if (!tmpreg) RREGEXP(re)->usecnt--; if (tmpreg) { - if (RREGEXP(re)->usecnt) { - onig_free(reg); - } - else { - onig_free(RREGEXP_PTR(re)); - RREGEXP_PTR(re) = reg; - } + if (RREGEXP(re)->usecnt) { + onig_free(reg); + } + else { + onig_free(RREGEXP_PTR(re)); + RREGEXP_PTR(re) = reg; + } } if (result < 0) { - if (regs == ®i) - onig_region_free(regs, 0); - if (result == ONIG_MISMATCH) { - rb_backref_set(Qnil); - return result; - } - else { - onig_error_code_to_str((UChar*)err, (int)result); - rb_reg_raise(RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), err, re); - } + if (regs == ®i) + onig_region_free(regs, 0); + if (result == ONIG_MISMATCH) { + rb_backref_set(Qnil); + return result; + } + else { + onig_error_code_to_str((UChar*)err, (int)result); + rb_reg_raise(RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), err, re); + } } match = match_alloc(rb_cMatch); @@ -1740,7 +1740,7 @@ rb_reg_search_set_match(VALUE re, VALUE str, long pos, int reverse, int set_back if (copy_err) rb_memerror(); if (set_backref_str) { - RMATCH(match)->str = rb_str_new4(str); + RMATCH(match)->str = rb_str_new4(str); } RMATCH(match)->regexp = re; @@ -1778,53 +1778,53 @@ rb_reg_start_with_p(VALUE re, VALUE str) match = rb_backref_get(); if (!NIL_P(match)) { - if (FL_TEST(match, MATCH_BUSY)) { - match = Qnil; - } - else { - regs = RMATCH_REGS(match); - } + if (FL_TEST(match, MATCH_BUSY)) { + match = Qnil; + } + else { + regs = RMATCH_REGS(match); + } } if (NIL_P(match)) { - MEMZERO(regs, struct re_registers, 1); + MEMZERO(regs, struct re_registers, 1); } const char *ptr; long len; RSTRING_GETMEM(str, ptr, len); result = onig_match(reg, - (UChar*)(ptr), - ((UChar*)(ptr + len)), - (UChar*)(ptr), - regs, ONIG_OPTION_NONE); + (UChar*)(ptr), + ((UChar*)(ptr + len)), + (UChar*)(ptr), + regs, ONIG_OPTION_NONE); if (!tmpreg) RREGEXP(re)->usecnt--; if (tmpreg) { - if (RREGEXP(re)->usecnt) { - onig_free(reg); - } - else { - onig_free(RREGEXP_PTR(re)); - RREGEXP_PTR(re) = reg; - } + if (RREGEXP(re)->usecnt) { + onig_free(reg); + } + else { + onig_free(RREGEXP_PTR(re)); + RREGEXP_PTR(re) = reg; + } } if (result < 0) { - if (regs == ®i) - onig_region_free(regs, 0); - if (result == ONIG_MISMATCH) { - rb_backref_set(Qnil); - return false; - } - else { - onig_error_code_to_str((UChar*)err, (int)result); - rb_reg_raise(RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), err, re); - } + if (regs == ®i) + onig_region_free(regs, 0); + if (result == ONIG_MISMATCH) { + rb_backref_set(Qnil); + return false; + } + else { + onig_error_code_to_str((UChar*)err, (int)result); + rb_reg_raise(RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), err, re); + } } if (NIL_P(match)) { - int err; - match = match_alloc(rb_cMatch); - err = rb_reg_region_copy(RMATCH_REGS(match), regs); - onig_region_free(regs, 0); - if (err) rb_memerror(); + int err; + match = match_alloc(rb_cMatch); + err = rb_reg_region_copy(RMATCH_REGS(match), regs); + onig_region_free(regs, 0); + if (err) rb_memerror(); } RMATCH(match)->str = rb_str_new4(str); @@ -1843,11 +1843,11 @@ rb_reg_nth_defined(int nth, VALUE match) match_check(match); regs = RMATCH_REGS(match); if (nth >= regs->num_regs) { - return Qnil; + return Qnil; } if (nth < 0) { - nth += regs->num_regs; - if (nth <= 0) return Qnil; + nth += regs->num_regs; + if (nth <= 0) return Qnil; } return RBOOL(BEG(nth) != -1); } @@ -1863,11 +1863,11 @@ rb_reg_nth_match(int nth, VALUE match) match_check(match); regs = RMATCH_REGS(match); if (nth >= regs->num_regs) { - return Qnil; + return Qnil; } if (nth < 0) { - nth += regs->num_regs; - if (nth <= 0) return Qnil; + nth += regs->num_regs; + if (nth <= 0) return Qnil; } start = BEG(nth); if (start == -1) return Qnil; @@ -1963,7 +1963,7 @@ rb_reg_match_last(VALUE match) if (BEG(0) == -1) return Qnil; for (i=regs->num_regs-1; BEG(i) == -1 && i > 0; i--) - ; + ; if (i == 0) return Qnil; return rb_reg_nth_match(i, match); } @@ -2006,13 +2006,13 @@ match_array(VALUE match, int start) target = RMATCH(match)->str; for (i=start; inum_regs; i++) { - if (regs->beg[i] == -1) { - rb_ary_push(ary, Qnil); - } - else { - VALUE str = rb_str_subseq(target, regs->beg[i], regs->end[i]-regs->beg[i]); - rb_ary_push(ary, str); - } + if (regs->beg[i] == -1) { + rb_ary_push(ary, Qnil); + } + else { + VALUE str = rb_str_subseq(target, regs->beg[i], regs->end[i]-regs->beg[i]); + rb_ary_push(ary, str); + } } return ary; } @@ -2065,7 +2065,7 @@ name_to_backref_number(struct re_registers *regs, VALUE regexp, const char* name { if (NIL_P(regexp)) return -1; return onig_name_to_backref_number(RREGEXP_PTR(regexp), - (const unsigned char *)name, (const unsigned char *)name_end, regs); + (const unsigned char *)name, (const unsigned char *)name_end, regs); } #define NAME_TO_NUMBER(regs, re, name, name_ptr, name_end) \ @@ -2079,15 +2079,15 @@ namev_to_backref_number(struct re_registers *regs, VALUE re, VALUE name) int num; if (SYMBOL_P(name)) { - name = rb_sym2str(name); + name = rb_sym2str(name); } else if (!RB_TYPE_P(name, T_STRING)) { - return -1; + return -1; } num = NAME_TO_NUMBER(regs, re, name, - RSTRING_PTR(name), RSTRING_END(name)); + RSTRING_PTR(name), RSTRING_END(name)); if (num < 1) { - name_to_backref_error(name); + name_to_backref_error(name); } return num; } @@ -2101,10 +2101,10 @@ match_ary_subseq(VALUE match, long beg, long len, VALUE result) if (len == 0) return result; for (j = beg; j < end; j++) { - rb_ary_push(result, rb_reg_nth_match((int)j, match)); + rb_ary_push(result, rb_reg_nth_match((int)j, match)); } if (beg + len > j) { - rb_ary_resize(result, RARRAY_LEN(result) + (beg + len) - j); + rb_ary_resize(result, RARRAY_LEN(result) + (beg + len) - j); } return result; } @@ -2118,13 +2118,13 @@ match_ary_aref(VALUE match, VALUE idx, VALUE result) /* check if idx is Range */ switch (rb_range_beg_len(idx, &beg, &len, (long)num_regs, !NIL_P(result))) { case Qfalse: - if (NIL_P(result)) return rb_reg_nth_match(NUM2INT(idx), match); - rb_ary_push(result, rb_reg_nth_match(NUM2INT(idx), match)); - return result; + if (NIL_P(result)) return rb_reg_nth_match(NUM2INT(idx), match); + rb_ary_push(result, rb_reg_nth_match(NUM2INT(idx), match)); + return result; case Qnil: - return Qnil; + return Qnil; default: - return match_ary_subseq(match, beg, len, result); + return match_ary_subseq(match, beg, len, result); } } @@ -2164,37 +2164,37 @@ match_aref(int argc, VALUE *argv, VALUE match) rb_scan_args(argc, argv, "11", &idx, &length); if (NIL_P(length)) { - if (FIXNUM_P(idx)) { - return rb_reg_nth_match(FIX2INT(idx), match); - } - else { - int num = namev_to_backref_number(RMATCH_REGS(match), RMATCH(match)->regexp, idx); - if (num >= 0) { - return rb_reg_nth_match(num, match); - } - else { - return match_ary_aref(match, idx, Qnil); - } - } + if (FIXNUM_P(idx)) { + return rb_reg_nth_match(FIX2INT(idx), match); + } + else { + int num = namev_to_backref_number(RMATCH_REGS(match), RMATCH(match)->regexp, idx); + if (num >= 0) { + return rb_reg_nth_match(num, match); + } + else { + return match_ary_aref(match, idx, Qnil); + } + } } else { - long beg = NUM2LONG(idx); - long len = NUM2LONG(length); - long num_regs = RMATCH_REGS(match)->num_regs; - if (len < 0) { - return Qnil; - } - if (beg < 0) { - beg += num_regs; - if (beg < 0) return Qnil; - } - else if (beg > num_regs) { - return Qnil; - } - if (beg+len > num_regs) { - len = num_regs - beg; - } - return match_ary_subseq(match, beg, len, Qnil); + long beg = NUM2LONG(idx); + long len = NUM2LONG(length); + long num_regs = RMATCH_REGS(match)->num_regs; + if (len < 0) { + return Qnil; + } + if (beg < 0) { + beg += num_regs; + if (beg < 0) return Qnil; + } + else if (beg > num_regs) { + return Qnil; + } + if (beg+len > num_regs) { + len = num_regs - beg; + } + return match_ary_subseq(match, beg, len, Qnil); } } @@ -2234,18 +2234,18 @@ match_values_at(int argc, VALUE *argv, VALUE match) result = rb_ary_new2(argc); for (i=0; iregexp, argv[i]); - if (num >= 0) { - rb_ary_push(result, rb_reg_nth_match(num, match)); - } - else { - match_ary_aref(match, argv[i], result); - } - } + if (FIXNUM_P(argv[i])) { + rb_ary_push(result, rb_reg_nth_match(FIX2INT(argv[i]), match)); + } + else { + int num = namev_to_backref_number(RMATCH_REGS(match), RMATCH(match)->regexp, argv[i]); + if (num >= 0) { + rb_ary_push(result, rb_reg_nth_match(num, match)); + } + else { + match_ary_aref(match, argv[i], result); + } + } } return result; } @@ -2281,7 +2281,7 @@ match_to_s(VALUE match) static int match_named_captures_iter(const OnigUChar *name, const OnigUChar *name_end, - int back_num, int *back_refs, OnigRegex regex, void *arg) { + int back_num, int *back_refs, OnigRegex regex, void *arg) { struct MEMO *memo = MEMO_CAST(arg); VALUE hash = memo->v1; VALUE match = memo->v2; @@ -2293,15 +2293,15 @@ match_named_captures_iter(const OnigUChar *name, const OnigUChar *name_end, int found = 0; for (i = 0; i < back_num; i++) { - value = rb_reg_nth_match(back_refs[i], match); - if (RTEST(value)) { - rb_hash_aset(hash, key, value); - found = 1; - } + value = rb_reg_nth_match(back_refs[i], match); + if (RTEST(value)) { + rb_hash_aset(hash, key, value); + found = 1; + } } if (found == 0) { - rb_hash_aset(hash, key, Qnil); + rb_hash_aset(hash, key, Qnil); } return 0; @@ -2340,7 +2340,7 @@ match_named_captures(VALUE match) match_check(match); if (NIL_P(RMATCH(match)->regexp)) - return rb_hash_new(); + return rb_hash_new(); hash = rb_hash_new(); memo = MEMO_NEW(hash, match, 0); @@ -2427,7 +2427,7 @@ match_inspect(VALUE match) } else if (NIL_P(regexp)) { return rb_sprintf("#<%"PRIsVALUE": %"PRIsVALUE">", - cname, rb_reg_nth_match(0, match)); + cname, rb_reg_nth_match(0, match)); } names = ALLOCA_N(struct backref_name_tag, num_regs); @@ -2761,7 +2761,7 @@ unescape_nonascii(const char *p, const char *end, rb_encoding *enc, goto invalid_multibyte; } if ((chlen = MBCLEN_CHARFOUND_LEN(chlen)) > 1) { - /* include the previous backslash */ + /* include the previous backslash */ --p; ++chlen; goto multibyte; @@ -2787,17 +2787,17 @@ unescape_nonascii(const char *p, const char *end, rb_encoding *enc, case 'C': /* \C-X, \C-\M-X */ case 'M': /* \M-X, \M-\C-X, \M-\cX */ p = p-2; - if (enc == rb_usascii_encoding()) { - const char *pbeg = p; + if (enc == rb_usascii_encoding()) { + const char *pbeg = p; int byte = read_escaped_byte(&p, end, err); if (byte == -1) return -1; c = byte; - rb_str_buf_cat(buf, pbeg, p-pbeg); - } - else { - if (unescape_escaped_nonascii(&p, end, enc, buf, encp, err) != 0) - return -1; - } + rb_str_buf_cat(buf, pbeg, p-pbeg); + } + else { + if (unescape_escaped_nonascii(&p, end, enc, buf, encp, err) != 0) + return -1; + } break; case 'u': @@ -2865,10 +2865,10 @@ escape_asis: while (cont && (p < end)) { switch (c = *p++) { - default: + default: if (!(c & 0x80)) break; - --p; - /* fallthrough */ + --p; + /* fallthrough */ case '\\': chlen = rb_enc_precise_mbclen(p, end, enc); if (!MBCLEN_CHARFOUND_P(chlen)) { @@ -2950,7 +2950,7 @@ rb_reg_check_preprocess(VALUE str) RB_GC_GUARD(str); if (NIL_P(buf)) { - return rb_reg_error_desc(str, 0, err); + return rb_reg_error_desc(str, 0, err); } return Qnil; } @@ -2975,14 +2975,14 @@ rb_reg_preprocess_dregexp(VALUE ary, int options) char *p, *end; rb_encoding *src_enc; - src_enc = rb_enc_get(str); - if (options & ARG_ENCODING_NONE && - src_enc != ascii8bit) { - if (str_coderange(str) != ENC_CODERANGE_7BIT) - rb_raise(rb_eRegexpError, "/.../n has a non escaped non ASCII character in non ASCII-8BIT script"); - else - src_enc = ascii8bit; - } + src_enc = rb_enc_get(str); + if (options & ARG_ENCODING_NONE && + src_enc != ascii8bit) { + if (str_coderange(str) != ENC_CODERANGE_7BIT) + rb_raise(rb_eRegexpError, "/.../n has a non escaped non ASCII character in non ASCII-8BIT script"); + else + src_enc = ascii8bit; + } StringValue(str); p = RSTRING_PTR(str); @@ -3015,8 +3015,8 @@ rb_reg_preprocess_dregexp(VALUE ary, int options) static int rb_reg_initialize(VALUE obj, const char *s, long len, rb_encoding *enc, - int options, onig_errmsg_buffer err, - const char *sourcefile, int sourceline) + int options, onig_errmsg_buffer err, + const char *sourcefile, int sourceline) { struct RRegexp *re = RREGEXP(obj); VALUE unescaped; @@ -3025,14 +3025,14 @@ rb_reg_initialize(VALUE obj, const char *s, long len, rb_encoding *enc, rb_check_frozen(obj); if (FL_TEST(obj, REG_LITERAL)) - rb_raise(rb_eSecurityError, "can't modify literal regexp"); + rb_raise(rb_eSecurityError, "can't modify literal regexp"); if (re->ptr) rb_raise(rb_eTypeError, "already initialized regexp"); re->ptr = 0; if (rb_enc_dummy_p(enc)) { - errcpy(err, "can't make regexp with dummy encoding"); - return -1; + errcpy(err, "can't make regexp with dummy encoding"); + return -1; } unescaped = rb_reg_preprocess(s, s+len, enc, &fixed_enc, err, options); @@ -3040,15 +3040,15 @@ rb_reg_initialize(VALUE obj, const char *s, long len, rb_encoding *enc, return -1; if (fixed_enc) { - if ((fixed_enc != enc && (options & ARG_ENCODING_FIXED)) || + if ((fixed_enc != enc && (options & ARG_ENCODING_FIXED)) || (fixed_enc != a_enc && (options & ARG_ENCODING_NONE))) { - errcpy(err, "incompatible character encoding"); - return -1; - } + errcpy(err, "incompatible character encoding"); + return -1; + } if (fixed_enc != a_enc) { - options |= ARG_ENCODING_FIXED; - enc = fixed_enc; - } + options |= ARG_ENCODING_FIXED; + enc = fixed_enc; + } } else if (!(options & ARG_ENCODING_FIXED)) { enc = rb_usascii_encoding(); @@ -3056,15 +3056,15 @@ rb_reg_initialize(VALUE obj, const char *s, long len, rb_encoding *enc, rb_enc_associate((VALUE)re, enc); if ((options & ARG_ENCODING_FIXED) || fixed_enc) { - re->basic.flags |= KCODE_FIXED; + re->basic.flags |= KCODE_FIXED; } if (options & ARG_ENCODING_NONE) { re->basic.flags |= REG_ENCODING_NONE; } re->ptr = make_regexp(RSTRING_PTR(unescaped), RSTRING_LEN(unescaped), enc, - options & ARG_REG_OPTION_MASK, err, - sourcefile, sourceline); + options & ARG_REG_OPTION_MASK, err, + sourcefile, sourceline); if (!re->ptr) return -1; RB_GC_GUARD(unescaped); return 0; @@ -3075,14 +3075,14 @@ reg_set_source(VALUE reg, VALUE str, rb_encoding *enc) { rb_encoding *regenc = rb_enc_get(reg); if (regenc != enc) { - str = rb_enc_associate(rb_str_dup(str), enc = regenc); + str = rb_enc_associate(rb_str_dup(str), enc = regenc); } RB_OBJ_WRITE(reg, &RREGEXP(reg)->src, rb_fstring(str)); } static int rb_reg_initialize_str(VALUE obj, VALUE str, int options, onig_errmsg_buffer err, - const char *sourcefile, int sourceline) + const char *sourcefile, int sourceline) { int ret; rb_encoding *str_enc = rb_enc_get(str), *enc = str_enc; @@ -3097,7 +3097,7 @@ rb_reg_initialize_str(VALUE obj, VALUE str, int options, onig_errmsg_buffer err, } } ret = rb_reg_initialize(obj, RSTRING_PTR(str), RSTRING_LEN(str), enc, - options, err, sourcefile, sourceline); + options, err, sourcefile, sourceline); if (ret == 0) reg_set_source(obj, str, str_enc); return ret; } @@ -3132,7 +3132,7 @@ rb_reg_init_str(VALUE re, VALUE s, int options) onig_errmsg_buffer err = ""; if (rb_reg_initialize_str(re, s, options, err, NULL, 0) != 0) { - rb_reg_raise_str(s, options, err); + rb_reg_raise_str(s, options, err); } return re; @@ -3144,8 +3144,8 @@ rb_reg_init_str_enc(VALUE re, VALUE s, rb_encoding *enc, int options) onig_errmsg_buffer err = ""; if (rb_reg_initialize(re, RSTRING_PTR(s), RSTRING_LEN(s), - enc, options, err, NULL, 0) != 0) { - rb_reg_raise_str(s, options, err); + enc, options, err, NULL, 0) != 0) { + rb_reg_raise_str(s, options, err); } reg_set_source(re, s, enc); @@ -3167,7 +3167,7 @@ rb_enc_reg_new(const char *s, long len, rb_encoding *enc, int options) onig_errmsg_buffer err = ""; if (rb_reg_initialize(re, s, len, enc, options, err, NULL, 0) != 0) { - rb_enc_reg_raise(s, len, enc, options, err); + rb_enc_reg_raise(s, len, enc, options, err); } RB_OBJ_WRITE(re, &RREGEXP(re)->src, rb_fstring(rb_enc_str_new(s, len, enc))); @@ -3188,8 +3188,8 @@ rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline) if (!str) str = rb_str_new(0,0); if (rb_reg_initialize_str(re, str, options, err, sourcefile, sourceline) != 0) { - rb_set_errinfo(rb_reg_error_desc(str, options, err)); - return Qnil; + rb_set_errinfo(rb_reg_error_desc(str, options, err)); + return Qnil; } FL_SET(re, REG_LITERAL); rb_obj_freeze(re); @@ -3202,9 +3202,9 @@ VALUE rb_reg_regcomp(VALUE str) { if (reg_cache && RREGEXP_SRC_LEN(reg_cache) == RSTRING_LEN(str) - && ENCODING_GET(reg_cache) == ENCODING_GET(str) - && memcmp(RREGEXP_SRC_PTR(reg_cache), RSTRING_PTR(str), RSTRING_LEN(str)) == 0) - return reg_cache; + && ENCODING_GET(reg_cache) == ENCODING_GET(str) + && memcmp(RREGEXP_SRC_PTR(reg_cache), RSTRING_PTR(str), RSTRING_LEN(str)) == 0) + return reg_cache; return reg_cache = rb_reg_new_str(str, 0); } @@ -3330,7 +3330,7 @@ static VALUE reg_operand(VALUE s, int check) { if (SYMBOL_P(s)) { - return rb_sym2str(s); + return rb_sym2str(s); } else if (RB_TYPE_P(s, T_STRING)) { return s; @@ -3346,19 +3346,19 @@ reg_match_pos(VALUE re, VALUE *strp, long pos, VALUE* set_match) VALUE str = *strp; if (NIL_P(str)) { - rb_backref_set(Qnil); - return -1; + rb_backref_set(Qnil); + return -1; } *strp = str = reg_operand(str, TRUE); if (pos != 0) { - if (pos < 0) { - VALUE l = rb_str_length(str); - pos += NUM2INT(l); - if (pos < 0) { - return pos; - } - } - pos = rb_str_offset(str, pos); + if (pos < 0) { + VALUE l = rb_str_length(str); + pos += NUM2INT(l); + if (pos < 0) { + return pos; + } + } + pos = rb_str_offset(str, pos); } return rb_reg_search_set_match(re, str, pos, 0, 1, set_match); } @@ -3455,8 +3455,8 @@ rb_reg_eqq(VALUE re, VALUE str) str = reg_operand(str, FALSE); if (NIL_P(str)) { - rb_backref_set(Qnil); - return Qfalse; + rb_backref_set(Qnil); + return Qfalse; } start = rb_reg_search(re, str, 0, 0); return RBOOL(start >= 0); @@ -3481,13 +3481,13 @@ rb_reg_match2(VALUE re) VALUE line = rb_lastline_get(); if (!RB_TYPE_P(line, T_STRING)) { - rb_backref_set(Qnil); - return Qnil; + rb_backref_set(Qnil); + return Qnil; } start = rb_reg_search(re, line, 0, 0); if (start < 0) { - return Qnil; + return Qnil; } start = rb_str_sublen(line, start); return LONG2FIX(start); @@ -3537,20 +3537,20 @@ rb_reg_match_m(int argc, VALUE *argv, VALUE re) long pos; if (rb_scan_args(argc, argv, "11", &str, &initpos) == 2) { - pos = NUM2LONG(initpos); + pos = NUM2LONG(initpos); } else { - pos = 0; + pos = 0; } pos = reg_match_pos(re, &str, pos, &result); if (pos < 0) { - rb_backref_set(Qnil); - return Qnil; + rb_backref_set(Qnil); + return Qnil; } rb_match_busy(result); if (!NIL_P(result) && rb_block_given_p()) { - return rb_yield(result); + return rb_yield(result); } return result; } @@ -3590,16 +3590,16 @@ rb_reg_match_p(VALUE re, VALUE str, long pos) if (NIL_P(str)) return Qfalse; str = SYMBOL_P(str) ? rb_sym2str(str) : StringValue(str); if (pos) { - if (pos < 0) { - pos += NUM2LONG(rb_str_length(str)); - if (pos < 0) return Qfalse; - } - if (pos > 0) { - long len = 1; - const char *beg = rb_str_subpos(str, pos, &len); - if (!beg) return Qfalse; - pos = beg - RSTRING_PTR(str); - } + if (pos < 0) { + pos += NUM2LONG(rb_str_length(str)); + if (pos < 0) return Qfalse; + } + if (pos > 0) { + long len = 1; + const char *beg = rb_str_subpos(str, pos, &len); + if (!beg) return Qfalse; + pos = beg - RSTRING_PTR(str); + } } reg = rb_reg_prepare_re0(re, str, err); tmpreg = reg != RREGEXP_PTR(re); @@ -3607,25 +3607,25 @@ rb_reg_match_p(VALUE re, VALUE str, long pos) start = ((UChar*)RSTRING_PTR(str)); end = start + RSTRING_LEN(str); result = onig_search(reg, start, end, start + pos, end, - NULL, ONIG_OPTION_NONE); + NULL, ONIG_OPTION_NONE); if (!tmpreg) RREGEXP(re)->usecnt--; if (tmpreg) { - if (RREGEXP(re)->usecnt) { - onig_free(reg); - } - else { - onig_free(RREGEXP_PTR(re)); - RREGEXP_PTR(re) = reg; - } + if (RREGEXP(re)->usecnt) { + onig_free(reg); + } + else { + onig_free(RREGEXP_PTR(re)); + RREGEXP_PTR(re) = reg; + } } if (result < 0) { - if (result == ONIG_MISMATCH) { - return Qfalse; - } - else { - onig_error_code_to_str((UChar*)err, (int)result); - rb_reg_raise(RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), err, re); - } + if (result == ONIG_MISMATCH) { + return Qfalse; + } + else { + onig_error_code_to_str((UChar*)err, (int)result); + rb_reg_raise(RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), err, re); + } } return Qtrue; } @@ -3646,11 +3646,11 @@ str_to_option(VALUE str) if (NIL_P(str)) return -1; RSTRING_GETMEM(str, ptr, len); for (long i = 0; i < len; ++i) { - int f = char_to_option(ptr[i]); - if (!f) { - rb_raise(rb_eArgError, "unknown regexp option: %"PRIsVALUE, str); - } - flag |= f; + int f = char_to_option(ptr[i]); + if (!f) { + rb_raise(rb_eArgError, "unknown regexp option: %"PRIsVALUE, str); + } + flag |= f; } return flag; } @@ -3725,47 +3725,47 @@ rb_reg_initialize_m(int argc, VALUE *argv, VALUE self) rb_scan_args(argc, argv, "12:", &src, &opts, &n_flag, &kwargs); if (!NIL_P(kwargs)) { - static ID keywords[1]; - if (!keywords[0]) { - keywords[0] = rb_intern_const("timeout"); - } - rb_get_kwargs(kwargs, keywords, 0, 1, &timeout); + static ID keywords[1]; + if (!keywords[0]) { + keywords[0] = rb_intern_const("timeout"); + } + rb_get_kwargs(kwargs, keywords, 0, 1, &timeout); } if (RB_TYPE_P(src, T_REGEXP)) { - VALUE re = src; + VALUE re = src; - if (opts != Qnil) { - rb_warn("flags ignored"); - } - rb_reg_check(re); - flags = rb_reg_options(re); - str = RREGEXP_SRC(re); + if (opts != Qnil) { + rb_warn("flags ignored"); + } + rb_reg_check(re); + flags = rb_reg_options(re); + str = RREGEXP_SRC(re); } else { if (opts != Qundef) { - int f; - if (FIXNUM_P(opts)) flags = FIX2INT(opts); - else if ((f = str_to_option(opts)) >= 0) flags = f; - else if (!NIL_P(opts) && rb_bool_expected(opts, "ignorecase", FALSE)) - flags = ONIG_OPTION_IGNORECASE; - } + int f; + if (FIXNUM_P(opts)) flags = FIX2INT(opts); + else if ((f = str_to_option(opts)) >= 0) flags = f; + else if (!NIL_P(opts) && rb_bool_expected(opts, "ignorecase", FALSE)) + flags = ONIG_OPTION_IGNORECASE; + } if (n_flag != Qundef && !NIL_P(n_flag)) { - char *kcode = StringValuePtr(n_flag); - if (kcode[0] == 'n' || kcode[0] == 'N') { - enc = rb_ascii8bit_encoding(); - flags |= ARG_ENCODING_NONE; - } - else { + char *kcode = StringValuePtr(n_flag); + if (kcode[0] == 'n' || kcode[0] == 'N') { + enc = rb_ascii8bit_encoding(); + flags |= ARG_ENCODING_NONE; + } + else { rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "encoding option is ignored - %s", kcode); - } - } - str = StringValue(src); + } + } + str = StringValue(src); } if (enc && rb_enc_get(str) != enc) - rb_reg_init_str_enc(self, str, enc, flags); + rb_reg_init_str_enc(self, str, enc, flags); else - rb_reg_init_str(self, str, flags); + rb_reg_init_str(self, str, flags); regex_t *reg = RREGEXP_PTR(self); @@ -3791,19 +3791,19 @@ rb_reg_quote(VALUE str) send = s + RSTRING_LEN(str); while (s < send) { c = rb_enc_ascget(s, send, &clen, enc); - if (c == -1) { + if (c == -1) { s += mbclen(s, send, enc); - continue; - } - switch (c) { - case '[': case ']': case '{': case '}': - case '(': case ')': case '|': case '-': - case '*': case '.': case '\\': - case '?': case '+': case '^': case '$': - case ' ': case '#': - case '\t': case '\f': case '\v': case '\n': case '\r': - goto meta_found; - } + continue; + } + switch (c) { + case '[': case ']': case '{': case '}': + case '(': case ')': case '|': case '-': + case '*': case '.': case '\\': + case '?': case '+': case '^': case '$': + case ' ': case '#': + case '\t': case '\f': case '\v': case '\n': case '\r': + goto meta_found; + } s += clen; } tmp = rb_str_new3(str); @@ -3828,47 +3828,47 @@ rb_reg_quote(VALUE str) while (s < send) { c = rb_enc_ascget(s, send, &clen, enc); - if (c == -1) { - int n = mbclen(s, send, enc); + if (c == -1) { + int n = mbclen(s, send, enc); - while (n--) - *t++ = *s++; - continue; - } + while (n--) + *t++ = *s++; + continue; + } s += clen; - switch (c) { - case '[': case ']': case '{': case '}': - case '(': case ')': case '|': case '-': - case '*': case '.': case '\\': - case '?': case '+': case '^': case '$': - case '#': + switch (c) { + case '[': case ']': case '{': case '}': + case '(': case ')': case '|': case '-': + case '*': case '.': case '\\': + case '?': case '+': case '^': case '$': + case '#': t += rb_enc_mbcput('\\', t, enc); - break; - case ' ': + break; + case ' ': t += rb_enc_mbcput('\\', t, enc); t += rb_enc_mbcput(' ', t, enc); - continue; - case '\t': + continue; + case '\t': t += rb_enc_mbcput('\\', t, enc); t += rb_enc_mbcput('t', t, enc); - continue; - case '\n': + continue; + case '\n': t += rb_enc_mbcput('\\', t, enc); t += rb_enc_mbcput('n', t, enc); - continue; - case '\r': + continue; + case '\r': t += rb_enc_mbcput('\\', t, enc); t += rb_enc_mbcput('r', t, enc); - continue; - case '\f': + continue; + case '\f': t += rb_enc_mbcput('\\', t, enc); t += rb_enc_mbcput('f', t, enc); - continue; - case '\v': + continue; + case '\v': t += rb_enc_mbcput('\\', t, enc); t += rb_enc_mbcput('v', t, enc); - continue; - } + continue; + } t += rb_enc_mbcput(c, t, enc); } rb_str_resize(tmp, t - RSTRING_PTR(tmp)); @@ -3964,23 +3964,23 @@ rb_reg_s_union(VALUE self, VALUE args0) } } else { - int i; - VALUE source = rb_str_buf_new(0); - rb_encoding *result_enc; + int i; + VALUE source = rb_str_buf_new(0); + rb_encoding *result_enc; int has_asciionly = 0; rb_encoding *has_ascii_compat_fixed = 0; rb_encoding *has_ascii_incompat = 0; - for (i = 0; i < argc; i++) { - volatile VALUE v; - VALUE e = rb_ary_entry(args0, i); + for (i = 0; i < argc; i++) { + volatile VALUE v; + VALUE e = rb_ary_entry(args0, i); - if (0 < i) - rb_str_buf_cat_ascii(source, "|"); + if (0 < i) + rb_str_buf_cat_ascii(source, "|"); - v = rb_check_regexp_type(e); - if (!NIL_P(v)) { + v = rb_check_regexp_type(e); + if (!NIL_P(v)) { rb_encoding *enc = rb_enc_get(v); if (!rb_enc_asciicompat(enc)) { if (!has_ascii_incompat) @@ -3999,9 +3999,9 @@ rb_reg_s_union(VALUE self, VALUE args0) else { has_asciionly = 1; } - v = rb_reg_str_with_term(v, -1); - } - else { + v = rb_reg_str_with_term(v, -1); + } + else { rb_encoding *enc; StringValue(e); enc = rb_enc_get(e); @@ -4022,8 +4022,8 @@ rb_reg_s_union(VALUE self, VALUE args0) rb_raise(rb_eArgError, "incompatible encodings: %s and %s", rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc)); } - v = rb_reg_s_quote(Qnil, e); - } + v = rb_reg_s_quote(Qnil, e); + } if (has_ascii_incompat) { if (has_asciionly) { rb_raise(rb_eArgError, "ASCII incompatible encoding: %s", @@ -4038,8 +4038,8 @@ rb_reg_s_union(VALUE self, VALUE args0) if (i == 0) { rb_enc_copy(source, v); } - rb_str_append(source, v); - } + rb_str_append(source, v); + } if (has_ascii_incompat) { result_enc = has_ascii_incompat; @@ -4128,42 +4128,42 @@ rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp) while (s < e) { int c = ASCGET(s, e, &clen); - char *ss; + char *ss; - if (c == -1) { - s += mbclen(s, e, str_enc); - continue; - } - ss = s; + if (c == -1) { + s += mbclen(s, e, str_enc); + continue; + } + ss = s; s += clen; - if (c != '\\' || s == e) continue; + if (c != '\\' || s == e) continue; - if (!val) { - val = rb_str_buf_new(ss-p); - } + if (!val) { + val = rb_str_buf_new(ss-p); + } rb_enc_str_buf_cat(val, p, ss-p, str_enc); c = ASCGET(s, e, &clen); if (c == -1) { s += mbclen(s, e, str_enc); - rb_enc_str_buf_cat(val, ss, s-ss, str_enc); + rb_enc_str_buf_cat(val, ss, s-ss, str_enc); p = s; - continue; + continue; } s += clen; - p = s; - switch (c) { - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': + p = s; + switch (c) { + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': if (!NIL_P(regexp) && onig_noname_group_capture_is_active(RREGEXP_PTR(regexp))) { no = c - '0'; } else { continue; } - break; + break; case 'k': if (s < e && ASCGET(s, e, &clen) == '<') { @@ -4176,11 +4176,11 @@ rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp) name_end += c == -1 ? mbclen(name_end, e, str_enc) : clen; } if (name_end < e) { - VALUE n = rb_str_subseq(str, (long)(name - RSTRING_PTR(str)), - (long)(name_end - name)); - if ((no = NAME_TO_NUMBER(regs, regexp, n, name, name_end)) < 1) { - name_to_backref_error(n); - } + VALUE n = rb_str_subseq(str, (long)(name - RSTRING_PTR(str)), + (long)(name_end - name)); + if ((no = NAME_TO_NUMBER(regs, regexp, n, name, name_end)) < 1) { + name_to_backref_error(n); + } p = s = name_end + clen; break; } @@ -4193,38 +4193,38 @@ rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp) continue; case '0': - case '&': - no = 0; - break; + case '&': + no = 0; + break; - case '`': - rb_enc_str_buf_cat(val, RSTRING_PTR(src), BEG(0), src_enc); - continue; + case '`': + rb_enc_str_buf_cat(val, RSTRING_PTR(src), BEG(0), src_enc); + continue; - case '\'': - rb_enc_str_buf_cat(val, RSTRING_PTR(src)+END(0), RSTRING_LEN(src)-END(0), src_enc); - continue; + case '\'': + rb_enc_str_buf_cat(val, RSTRING_PTR(src)+END(0), RSTRING_LEN(src)-END(0), src_enc); + continue; - case '+': - no = regs->num_regs-1; - while (BEG(no) == -1 && no > 0) no--; - if (no == 0) continue; - break; + case '+': + no = regs->num_regs-1; + while (BEG(no) == -1 && no > 0) no--; + if (no == 0) continue; + break; - case '\\': - rb_enc_str_buf_cat(val, s-clen, clen, str_enc); - continue; + case '\\': + rb_enc_str_buf_cat(val, s-clen, clen, str_enc); + continue; - default: - rb_enc_str_buf_cat(val, ss, s-ss, str_enc); - continue; - } + default: + rb_enc_str_buf_cat(val, ss, s-ss, str_enc); + continue; + } - if (no >= 0) { - if (no >= regs->num_regs) continue; - if (BEG(no) == -1) continue; - rb_enc_str_buf_cat(val, RSTRING_PTR(src)+BEG(no), END(no)-BEG(no), src_enc); - } + if (no >= 0) { + if (no >= regs->num_regs) continue; + if (BEG(no) == -1) continue; + rb_enc_str_buf_cat(val, RSTRING_PTR(src)+BEG(no), END(no)-BEG(no), src_enc); + } } if (!val) return str; @@ -4268,7 +4268,7 @@ static void match_setter(VALUE val, ID _x, VALUE *_y) { if (!NIL_P(val)) { - Check_Type(val, T_MATCH); + Check_Type(val, T_MATCH); } rb_backref_set(val); } @@ -4319,7 +4319,7 @@ rb_reg_s_last_match(int argc, VALUE *argv, VALUE _) int n; if (NIL_P(match)) return Qnil; n = match_backref_number(match, argv[0]); - return rb_reg_nth_match(n, match); + return rb_reg_nth_match(n, match); } return match_getter(); } -- cgit v1.2.1