класс StringScanner

static VALUE
strscan_aref(VALUE self, VALUE idx)
{
    const char *name;
    struct strscanner *p;
    long i;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p))        return Qnil;

    switch (TYPE(idx)) {
        case T_SYMBOL:
            idx = rb_sym2str(idx);
            /* fall through */
        case T_STRING:
            if (!RTEST(p->regex)) return Qnil;
            RSTRING_GETMEM(idx, name, i);
            i = name_to_backref_number(&(p->regs), p->regex, name, name + i, rb_enc_get(idx));
            break;
        default:
            i = NUM2LONG(idx);
    }

    if (i < 0)
        i += p->regs.num_regs;
    if (i < 0)                 return Qnil;
    if (i >= p->regs.num_regs) return Qnil;
    if (p->regs.beg[i] == -1)  return Qnil;

    return extract_range(p,
                         adjust_register_position(p, p->regs.beg[i]),
                         adjust_register_position(p, p->regs.end[i]));
}

Возвращает захваченную подстроку или nil; см. Захваченные значения совпадения.

Когда есть захват:

scanner = StringScanner.new('Fri Dec 12 1975 14:39')
scanner.scan(/(?<wday>\w+) (?<month>\w+) (?<day>\d+) /)

• specifier ноль: возвращает всю совпавшую подстроку:

  scanner[0]         # => "Fri Dec 12 "
  scanner.pre_match  # => ""
  scanner.post_match # => "1975 14:39"
  

• specifier положительное целое число. возвращает n-й захват или nil , если он вне диапазона:

  scanner[1] # => "Fri"
  scanner[2] # => "Dec"
  scanner[3] # => "12"
  scanner[4] # => nil
  

• specifier отрицательное целое число. считает назад от последней подгруппы:

  scanner[-1] # => "12"
  scanner[-4] # => "Fri Dec 12 "
  scanner[-5] # => nil
  

• specifier символ или строка. возвращает именованную подгруппу или nil , если такой нет:

  scanner[:wday]  # => "Fri"
  scanner['wday'] # => "Fri"
  scanner[:month] # => "Dec"
  scanner[:day]   # => "12"
  scanner[:nope]  # => nil
  

Когда нет захватов, только [0] возвращает ненулевое %%%CODE_BLOCK_243%%:

scanner = StringScanner.new('foobarbaz')
scanner.exist?(/bar/)
scanner[0] # => "bar"
scanner[1] # => nil

При неудачном сопоставлении даже [0] возвращает nil:

scanner.scan(/nope/) # => nil
scanner[0]           # => nil
scanner[1]           # => nil

static VALUE
strscan_bol_p(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (CURPTR(p) > S_PEND(p)) return Qnil;
    if (p->curr == 0) return Qtrue;
    return (*(CURPTR(p) - 1) == '\n') ? Qtrue : Qfalse;
}

Возвращает, находится ли позиция в начале строки; то есть, в начале сохранённой строки или сразу после новой строки:

scanner = StringScanner.new(MULTILINE_TEXT)
scanner.string
# => "Go placidly amid the noise and haste,\nand remember what peace there may be in silence.\n"
scanner.pos                # => 0
scanner.beginning_of_line? # => true

scanner.scan_until(/,/)    # => "Go placidly amid the noise and haste,"
scanner.beginning_of_line? # => false

scanner.scan(/\n/)         # => "\n"
scanner.beginning_of_line? # => true

scanner.terminate
scanner.beginning_of_line? # => true

scanner.concat('x')
scanner.terminate
scanner.beginning_of_line? # => false

StringScanner#bol? является псевдонимом для StringScanner#beginning_of_line?.

static VALUE
strscan_captures(VALUE self)
{
    struct strscanner *p;
    int   i, num_regs;
    VALUE new_ary;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p))        return Qnil;

    num_regs = p->regs.num_regs;
    new_ary  = rb_ary_new2(num_regs);

    for (i = 1; i < num_regs; i++) {
        VALUE str;
        if (p->regs.beg[i] == -1)
            str = Qnil;
        else
            str = extract_range(p,
                                adjust_register_position(p, p->regs.beg[i]),
                                adjust_register_position(p, p->regs.end[i]));
        rb_ary_push(new_ary, str);
    }

    return new_ary;
}

Возвращает массив захваченных значений совпадения по индексам (1..) , если последнее попытка сопоставления прошла успешно, или nil в противном случае:

scanner = StringScanner.new('Fri Dec 12 1975 14:39')
scanner.captures         # => nil

scanner.exist?(/(?<wday>\w+) (?<month>\w+) (?<day>\d+) /)
scanner.captures         # => ["Fri", "Dec", "12"]
scanner.values_at(*0..4) # => ["Fri Dec 12 ", "Fri", "Dec", "12", nil]

scanner.exist?(/Fri/)
scanner.captures         # => []

scanner.scan(/nope/)
scanner.captures         # => nil

static VALUE
strscan_get_charpos(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);

    return LONG2NUM(rb_enc_strlen(S_PBEG(p), CURPTR(p), rb_enc_get(p->str)));
}

вызов: charpos -> позиция_символа

Возвращает позицию символа (по умолчанию ноль), которая может отличаться от байтовой позиции, указанной методом pos:

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string # => "こんにちは"
scanner.getch  # => "こ" # 3-byte character.
scanner.getch  # => "ん" # 3-byte character.
put_situation(scanner)
# Situation:
#   pos:       6
#   charpos:   2
#   rest:      "にちは"
#   rest_size: 9

static VALUE
strscan_check(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 0, 1, 1);
}

Попытка сопоставить заданный pattern в начале целевой подстроки; не изменяет позиций.

Если сопоставление успешно:

• Возвращает совпавшую подстроку.

• Устанавливает все значения совпадения.

scanner = StringScanner.new('foobarbaz')
scanner.pos = 3
scanner.check('bar') # => "bar"
put_match_values(scanner)
# Basic match values:
#   matched?:       true
#   matched_size:   3
#   pre_match:      "foo"
#   matched  :      "bar"
#   post_match:     "baz"
# Captured match values:
#   size:           1
#   captures:       []
#   named_captures: {}
#   values_at:      ["bar", nil]
#   []:
#     [0]:          "bar"
#     [1]:          nil
# => 0..1
put_situation(scanner)
# Situation:
#   pos:       3
#   charpos:   3
#   rest:      "barbaz"
#   rest_size: 6

Если сопоставление не удалось:

• Возвращает nil.

• Очищает все значения совпадения.

scanner.check(/nope/)          # => nil
match_values_cleared?(scanner) # => true

static VALUE
strscan_check_until(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 0, 1, 0);
}

Попытка сопоставить заданный pattern где угодно (в любой позиции) в целевой подстроке; не изменяет позиции.

Если сопоставление успешно:

• Устанавливает все значения совпадения.

• Возвращает совпавшую подстроку, которая простирается от текущей позиции до конца совпавшей подстроки.

scanner = StringScanner.new('foobarbazbatbam')
scanner.pos = 6
scanner.check_until(/bat/) # => "bazbat"
put_match_values(scanner)
# Basic match values:
#   matched?:       true
#   matched_size:   3
#   pre_match:      "foobarbaz"
#   matched  :      "bat"
#   post_match:     "bam"
# Captured match values:
#   size:           1
#   captures:       []
#   named_captures: {}
#   values_at:      ["bat", nil]
#   []:
#     [0]:          "bat"
#     [1]:          nil
put_situation(scanner)
# Situation:
#   pos:       6
#   charpos:   6
#   rest:      "bazbatbam"
#   rest_size: 9

Если сопоставление не удалось:

• Очищает все значения совпадения.

• Возвращает nil.

scanner.check_until(/nope/)    # => nil
match_values_cleared?(scanner) # => true

static VALUE
strscan_concat(VALUE self, VALUE str)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    StringValue(str);
    rb_str_append(p->str, str);
    return self;
}

• Добавляет заданную more_string к сохранённой строке.

• Возвращает self.

• Не влияет на позиции или значения совпадения.

scanner = StringScanner.new('foo')
scanner.string           # => "foo"
scanner.terminate
scanner.concat('barbaz') # => #<StringScanner 3/9 "foo" @ "barba...">
scanner.string           # => "foobarbaz"
put_situation(scanner)
# Situation:
#   pos:       3
#   charpos:   3
#   rest:      "barbaz"
#   rest_size: 6

static VALUE
strscan_eos_p(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return EOS_P(p) ? Qtrue : Qfalse;
}

Возвращает, находится ли позиция в конце сохранённой строки:

scanner = StringScanner.new('foobarbaz')
scanner.eos? # => false
pos = 3
scanner.eos? # => false
scanner.terminate
scanner.eos? # => true

static VALUE
strscan_exist_p(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 0, 0, 0);
}

Попытка сопоставить заданный pattern где угодно (в любой позиции) в целевой подстроке; не изменяет позиции.

Если сопоставление успешно:

• Возвращает смещение байтов: расстояние в байтах между текущей позицией и концом совпавшей подстроки.

• Устанавливает все значения совпадения.

scanner = StringScanner.new('foobarbazbatbam')
scanner.pos = 6
scanner.exist?(/bat/) # => 6
put_match_values(scanner)
# Basic match values:
#   matched?:       true
#   matched_size:   3
#   pre_match:      "foobarbaz"
#   matched  :      "bat"
#   post_match:     "bam"
# Captured match values:
#   size:           1
#   captures:       []
#   named_captures: {}
#   values_at:      ["bat", nil]
#   []:
#     [0]:          "bat"
#     [1]:          nil
put_situation(scanner)
# Situation:
#   pos:       6
#   charpos:   6
#   rest:      "bazbatbam"
#   rest_size: 9

Если сопоставление не удалось:

• Возвращает nil.

• Очищает все значения совпадения.

scanner.exist?(/nope/)         # => nil
match_values_cleared?(scanner) # => true

static VALUE
strscan_fixed_anchor_p(VALUE self)
{
    struct strscanner *p;
    p = check_strscan(self);
    return p->fixed_anchor_p ? Qtrue : Qfalse;
}

Возвращает, установлено ли свойство фиксированной точки.

static VALUE
strscan_get_byte(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    CLEAR_MATCH_STATUS(p);
    if (EOS_P(p))
        return Qnil;

    p->prev = p->curr;
    p->curr++;
    MATCHED(p);
    adjust_registers_to_matched(p);
    return extract_range(p,
                         adjust_register_position(p, p->regs.beg[0]),
                         adjust_register_position(p, p->regs.end[0]));
}

call-seq: get_byte -> байт_как_символ или nil

Возвращает следующий байт, если он доступен:

• Если позиция не находится в конце хранимой строки:

  • Возвращает следующий байт.

  • Увеличивает положение байта.

  • Корректирует положение символа.

  scanner = StringScanner.new(HIRAGANA_TEXT)
  # => #<StringScanner 0/15 @ "\xE3\x81\x93\xE3\x82...">
  scanner.string                                   # => "こんにちは"
  [scanner.get_byte, scanner.pos, scanner.charpos] # => ["\xE3", 1, 1]
  [scanner.get_byte, scanner.pos, scanner.charpos] # => ["\x81", 2, 2]
  [scanner.get_byte, scanner.pos, scanner.charpos] # => ["\x93", 3, 1]
  [scanner.get_byte, scanner.pos, scanner.charpos] # => ["\xE3", 4, 2]
  [scanner.get_byte, scanner.pos, scanner.charpos] # => ["\x82", 5, 3]
  [scanner.get_byte, scanner.pos, scanner.charpos] # => ["\x93", 6, 2]
  

• В противном случае возвращает nil, и не изменяет позиции.

  scanner.terminate
  [scanner.get_byte, scanner.pos, scanner.charpos] # => [nil, 15, 5]
  

static VALUE
strscan_getch(VALUE self)
{
    struct strscanner *p;
    long len;

    GET_SCANNER(self, p);
    CLEAR_MATCH_STATUS(p);
    if (EOS_P(p))
        return Qnil;

    len = rb_enc_mbclen(CURPTR(p), S_PEND(p), rb_enc_get(p->str));
    len = minl(len, S_RESTLEN(p));
    p->prev = p->curr;
    p->curr += len;
    MATCHED(p);
    adjust_registers_to_matched(p);
    return extract_range(p,
                         adjust_register_position(p, p->regs.beg[0]),
                         adjust_register_position(p, p->regs.end[0]));
}

call-seq: getch -> символ или nil

Возвращает следующий (возможно, многобайтный) символ, если он доступен:

• Если позиция находится в начале символа:

  • Возвращает символ.

  • Увеличивает положение символа на 1.

  • Увеличивает положение байта на размер символа (в байтах).

  scanner = StringScanner.new(HIRAGANA_TEXT)
  scanner.string                                # => "こんにちは"
  [scanner.getch, scanner.pos, scanner.charpos] # => ["こ", 3, 1]
  [scanner.getch, scanner.pos, scanner.charpos] # => ["ん", 6, 2]
  [scanner.getch, scanner.pos, scanner.charpos] # => ["に", 9, 3]
  [scanner.getch, scanner.pos, scanner.charpos] # => ["ち", 12, 4]
  [scanner.getch, scanner.pos, scanner.charpos] # => ["は", 15, 5]
  [scanner.getch, scanner.pos, scanner.charpos] # => [nil, 15, 5]
  

• Если позиция находится внутри многобайтного символа (то есть не в начале), ведет себя как get_byte (возвращает 1-байтовый символ):

  scanner.pos = 1
  [scanner.getch, scanner.pos, scanner.charpos] # => ["\x81", 2, 2]
  [scanner.getch, scanner.pos, scanner.charpos] # => ["\x93", 3, 1]
  [scanner.getch, scanner.pos, scanner.charpos] # => ["ん", 6, 2]
  

• Если позиция находится в конце хранимой строки, возвращает nil и не изменяет позиции:

  scanner.terminate
  [scanner.getch, scanner.pos, scanner.charpos] # => [nil, 15, 5]
  

static VALUE
strscan_inspect(VALUE self)
{
    struct strscanner *p;
    VALUE a, b;

    p = check_strscan(self);
    if (NIL_P(p->str)) {
        a = rb_sprintf("#<%"PRIsVALUE" (uninitialized)>", rb_obj_class(self));
        return a;
    }
    if (EOS_P(p)) {
        a = rb_sprintf("#<%"PRIsVALUE" fin>", rb_obj_class(self));
        return a;
    }
    if (p->curr == 0) {
        b = inspect2(p);
        a = rb_sprintf("#<%"PRIsVALUE" %ld/%ld @ %"PRIsVALUE">",
                       rb_obj_class(self),
                       p->curr, S_LEN(p),
                       b);
        return a;
    }
    a = inspect1(p);
    b = inspect2(p);
    a = rb_sprintf("#<%"PRIsVALUE" %ld/%ld %"PRIsVALUE" @ %"PRIsVALUE">",
                   rb_obj_class(self),
                   p->curr, S_LEN(p),
                   a, b);
    return a;
}

Возвращает строковое представление self, которое может отображать:

1. Текущее положение.

2. Размер (в байтах) хранимой строки.

3. Подстроку, предшествующую текущему положению.

4. Подстроку, следующую за текущим положением (которая также является целевой подстрокой).

scanner = StringScanner.new("Fri Dec 12 1975 14:39")
scanner.pos = 11
scanner.inspect # => "#<StringScanner 11/21 \"...c 12 \" @ \"1975 ...\">"

Если в начале строки, элемент 4 выше (подстрока, следующая за текущим положением) опускается:

scanner.reset
scanner.inspect # => "#<StringScanner 0/21 @ \"Fri D...\">"

Если в конце строки, все элементы выше опускаются:

scanner.terminate
scanner.inspect # => "#<StringScanner fin>"

static VALUE
strscan_get_pos(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return INT2FIX(p->curr);
}

call-seq: pos -> byte_position

Возвращает целое число позиции байта, которая может отличаться от позиции символа:

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string  # => "こんにちは"
scanner.pos     # => 0
scanner.getch   # => "こ" # 3-byte character.
scanner.charpos # => 1
scanner.pos     # => 3

static VALUE
strscan_set_pos(VALUE self, VALUE v)
{
    struct strscanner *p;
    long i;

    GET_SCANNER(self, p);
    i = NUM2INT(v);
    if (i < 0) i += S_LEN(p);
    if (i < 0) rb_raise(rb_eRangeError, "index out of range");
    if (i > S_LEN(p)) rb_raise(rb_eRangeError, "index out of range");
    p->curr = i;
    return LONG2NUM(i);
}

call-seq: pos = n -> n pointer = n -> n

Устанавливает позицию байта и позицию символа; возвращает n.

Не влияет на значения совпадения.

Для неотрицательного n, устанавливает позицию в n:

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string  # => "こんにちは"
scanner.pos = 3 # => 3
scanner.rest    # => "んにちは"
scanner.charpos # => 1

Для отрицательного n, считает с конца сохранённой строки:

scanner.pos = -9 # => -9
scanner.pos      # => 6
scanner.rest     # => "にちは"
scanner.charpos  # => 2

static VALUE
strscan_post_match(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p)) return Qnil;
    return extract_range(p,
                         adjust_register_position(p, p->regs.end[0]),
                         S_LEN(p));
}

Возвращает подстроку, следующую за сопоставленной подстрокой с последней попытки сопоставления, если она была успешной, или nil в противном случае; см. Основные значения сопоставления:

scanner = StringScanner.new('foobarbaz')
scanner.post_match     # => nil

scanner.pos = 3
scanner.match?(/bar/)  # => 3
scanner.post_match     # => "baz"

scanner.match?(/nope/) # => nil
scanner.post_match     # => nil

static VALUE
strscan_pre_match(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p)) return Qnil;
    return extract_range(p,
                         0,
                         adjust_register_position(p, p->regs.beg[0]));
}

Возвращает подстроку, предшествующую сопоставленной подстроке с последней попытки сопоставления, если она была успешной, или nil в противном случае; см. Основные значения сопоставления:

scanner = StringScanner.new('foobarbaz')
scanner.pre_match      # => nil

scanner.pos = 3
scanner.exist?(/baz/)  # => 6
scanner.pre_match      # => "foobar" # Substring of entire string, not just target string.

scanner.exist?(/nope/) # => nil
scanner.pre_match      # => nil

static VALUE
strscan_reset(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    p->curr = 0;
    CLEAR_MATCH_STATUS(p);
    return self;
}

Устанавливает позицию байта и позицию символа в ноль и очищает значения совпадений; возвращает self:

scanner = StringScanner.new('foobarbaz')
scanner.exist?(/bar/)          # => 6
scanner.reset                  # => #<StringScanner 0/9 @ "fooba...">
put_situation(scanner)
# Situation:
#   pos:       0
#   charpos:   0
#   rest:      "foobarbaz"
#   rest_size: 9
# => nil
match_values_cleared?(scanner) # => true

static VALUE
strscan_rest(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (EOS_P(p)) {
        return str_new(p, "", 0);
    }
    return extract_range(p, p->curr, S_LEN(p));
}

Возвращает остальную часть сохранённой строки (всё после текущей позиции), которая является целевой подстрокой:

scanner = StringScanner.new('foobarbaz')
scanner.rest # => "foobarbaz"
scanner.pos = 3
scanner.rest # => "barbaz"
scanner.terminate
scanner.rest # => ""

static VALUE
strscan_rest_size(VALUE self)
{
    struct strscanner *p;
    long i;

    GET_SCANNER(self, p);
    if (EOS_P(p)) {
        return INT2FIX(0);
    }
    i = S_RESTLEN(p);
    return INT2FIX(i);
}

Возвращает размер (в байтах) rest сохранённой строки:

scanner = StringScanner.new('foobarbaz')
scanner.rest      # => "foobarbaz"
scanner.rest_size # => 9
scanner.pos = 3
scanner.rest      # => "barbaz"
scanner.rest_size # => 6
scanner.terminate
scanner.rest      # => ""
scanner.rest_size # => 0

static VALUE
strscan_scan(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 1, 1);
}

call-seq: scan(pattern) -> substring or nil

Попытка сопоставить заданный pattern в начале целевой подстроки.

Если сопоставление успешно:

• Возвращает сопоставленную подстроку.

• Увеличивает позицию байта на substring.bytesize, и может увеличить позицию символа.

• Устанавливает значения совпадений.

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string     # => "こんにちは"
scanner.pos = 6
scanner.scan(/に/) # => "に"
put_match_values(scanner)
# Basic match values:
#   matched?:       true
#   matched_size:   3
#   pre_match:      "こん"
#   matched  :      "に"
#   post_match:     "ちは"
# Captured match values:
#   size:           1
#   captures:       []
#   named_captures: {}
#   values_at:      ["に", nil]
#   []:
#     [0]:          "に"
#     [1]:          nil
put_situation(scanner)
# Situation:
#   pos:       9
#   charpos:   3
#   rest:      "ちは"
#   rest_size: 6

Если сопоставление не удалось:

• Возвращает nil.

• Не увеличивает позицию байта и символа.

• Очищает значения совпадений.

scanner.scan(/nope/)           # => nil
match_values_cleared?(scanner) # => true

static VALUE
strscan_scan_byte(VALUE self)
{
    struct strscanner *p;
    VALUE byte;

    GET_SCANNER(self, p);
    CLEAR_MATCH_STATUS(p);
    if (EOS_P(p))
        return Qnil;

    byte = INT2FIX((unsigned char)*CURPTR(p));
    p->prev = p->curr;
    p->curr++;
    MATCHED(p);
    adjust_registers_to_matched(p);
    return byte;
}

Сканирует один байт и возвращает его как целое число. Этот метод не чувствителен к многобайтовым символам. См. также: getch.

static VALUE
strscan_scan_until(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 1, 0);
}

call-seq: scan_until(pattern) -> substring or nil

Попытка сопоставления заданного pattern в любом месте (в любой позиции) целевой подстроки.

Если попытка сопоставления успешна:

• Устанавливает значения совпадений.

• Устанавливает позицию байта в конец сопоставленной подстроки; может скорректировать позицию символа.

• Возвращает сопоставленную подстроку.

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string           # => "こんにちは"
scanner.pos = 6
scanner.scan_until(/ち/) # => "にち"
put_match_values(scanner)
# Basic match values:
#   matched?:       true
#   matched_size:   3
#   pre_match:      "こんに"
#   matched  :      "ち"
#   post_match:     "は"
# Captured match values:
#   size:           1
#   captures:       []
#   named_captures: {}
#   values_at:      ["ち", nil]
#   []:
#     [0]:          "ち"
#     [1]:          nil
put_situation(scanner)
# Situation:
#   pos:       12
#   charpos:   4
#   rest:      "は"
#   rest_size: 3

Если попытка сопоставления не удалась:

• Очищает данные сопоставления.

• Возвращает nil.

• Не обновляет позиции.

scanner.scan_until(/nope/)     # => nil
match_values_cleared?(scanner) # => true

static VALUE
strscan_size(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p))        return Qnil;
    return INT2FIX(p->regs.num_regs);
}

Возвращает количество совпадений, если последняя попытка совпадения прошла успешно, nil в противном случае; см. Значения захваченных совпадений:

scanner = StringScanner.new('Fri Dec 12 1975 14:39')
scanner.size                        # => nil

pattern = /(?<wday>\w+) (?<month>\w+) (?<day>\d+) /
scanner.match?(pattern)
scanner.values_at(*0..scanner.size) # => ["Fri Dec 12 ", "Fri", "Dec", "12", nil]
scanner.size                        # => 4

scanner.match?(/nope/)              # => nil
scanner.size                        # => nil

static VALUE
strscan_skip(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 0, 1);
}

call-seq: skip(pattern) match_size or nil

Пытается сопоставить указанный pattern в начале целевого подстроки;

Если совпадение успешно:

• Увеличивает байтовый позицию на substring.bytesize, и может увеличить позицию символа.

• Устанавливает значения совпадения.

• Возвращает размер (в байтах) сопоставленной подстроки.

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string                  # => "こんにちは"
scanner.pos = 6
scanner.skip(/に/)              # => 3
put_match_values(scanner)
# Basic match values:
#   matched?:       true
#   matched_size:   3
#   pre_match:      "こん"
#   matched  :      "に"
#   post_match:     "ちは"
# Captured match values:
#   size:           1
#   captures:       []
#   named_captures: {}
#   values_at:      ["に", nil]
#   []:
#     [0]:          "に"
#     [1]:          nil
put_situation(scanner)
# Situation:
#   pos:       9
#   charpos:   3
#   rest:      "ちは"
#   rest_size: 6

scanner.skip(/nope/)            # => nil
match_values_cleared?(scanner)  # => true

static VALUE
strscan_skip_until(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 0, 0);
}

call-seq: skip_until(pattern) -> matched_substring_size or nil

Пытается сопоставить указанный pattern где угодно (в любой позиции) в целевой подстроке; не изменяет позиции.

Если попытка совпадения успешна:

• Устанавливает значения совпадения.

• Возвращает размер сопоставленной подстроки.

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string           # => "こんにちは"
scanner.pos = 6
scanner.skip_until(/ち/) # => 6
put_match_values(scanner)
# Basic match values:
#   matched?:       true
#   matched_size:   3
#   pre_match:      "こんに"
#   matched  :      "ち"
#   post_match:     "は"
# Captured match values:
#   size:           1
#   captures:       []
#   named_captures: {}
#   values_at:      ["ち", nil]
#   []:
#     [0]:          "ち"
#     [1]:          nil
put_situation(scanner)
# Situation:
#   pos:       12
#   charpos:   4
#   rest:      "は"
#   rest_size: 3

Если попытка совпадения не удалась:

• Очищает значения совпадения.

• Возвращает nil.

scanner.skip_until(/nope/)     # => nil
match_values_cleared?(scanner) # => true

static VALUE
strscan_get_string(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return p->str;
}

Возвращает хранимую строку:

scanner = StringScanner.new('foobar')
scanner.string # => "foobar"
scanner.concat('baz')
scanner.string # => "foobarbaz"

static VALUE
strscan_set_string(VALUE self, VALUE str)
{
    struct strscanner *p = check_strscan(self);

    StringValue(str);
    p->str = str;
    p->curr = 0;
    CLEAR_MATCH_STATUS(p);
    return str;
}

Заменяет хранимую строку на заданную other_string:

• Устанавливает обе позиции в ноль.

• Очищает значения совпадения.

• Возвращает other_string.

scanner = StringScanner.new('foobar')
scanner.scan(/foo/)
put_situation(scanner)
# Situation:
#   pos:       3
#   charpos:   3
#   rest:      "bar"
#   rest_size: 3
match_values_cleared?(scanner) # => false

scanner.string = 'baz'         # => "baz"
put_situation(scanner)
# Situation:
#   pos:       0
#   charpos:   0
#   rest:      "baz"
#   rest_size: 3
match_values_cleared?(scanner) # => true

static VALUE
strscan_terminate(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    p->curr = S_LEN(p);
    CLEAR_MATCH_STATUS(p);
    return self;
}

call-seq: terminate -> self

Устанавливает сканер на конец строки; возвращает self:

• Устанавливает обе позиции на конец потока.

• Очищает значения совпадения.

scanner = StringScanner.new(HIRAGANA_TEXT)
scanner.string                 # => "こんにちは"
scanner.scan_until(/に/)
put_situation(scanner)
# Situation:
#   pos:       9
#   charpos:   3
#   rest:      "ちは"
#   rest_size: 6
match_values_cleared?(scanner) # => false

scanner.terminate              # => #<StringScanner fin>
put_situation(scanner)
# Situation:
#   pos:       15
#   charpos:   5
#   rest:      ""
#   rest_size: 0
match_values_cleared?(scanner) # => true

static VALUE
strscan_unscan(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p))
        rb_raise(ScanError, "unscan failed: previous match record not exist");
    p->curr = p->prev;
    CLEAR_MATCH_STATUS(p);
    return self;
}

Устанавливает позицию на значение, предшествующее последней успешной попытке сопоставления:

scanner = StringScanner.new('foobarbaz')
scanner.scan(/foo/)
put_situation(scanner)
# Situation:
#   pos:       3
#   charpos:   3
#   rest:      "barbaz"
#   rest_size: 6
scanner.unscan
# => #<StringScanner 0/9 @ "fooba...">
put_situation(scanner)
# Situation:
#   pos:       0
#   charpos:   0
#   rest:      "foobarbaz"
#   rest_size: 9

Вызывает исключение, если значения совпадения очищены:

scanner.scan(/nope/)           # => nil
match_values_cleared?(scanner) # => true
scanner.unscan                 # Raises StringScanner::Error.

static VALUE
strscan_values_at(int argc, VALUE *argv, VALUE self)
{
    struct strscanner *p;
    long i;
    VALUE new_ary;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p))        return Qnil;

    new_ary = rb_ary_new2(argc);
    for (i = 0; i<argc; i++) {
        rb_ary_push(new_ary, strscan_aref(self, argv[i]));
    }

    return new_ary;
}

Возвращает массив захваченных подстрок или nil при отсутствии таковых.

Для каждого specifier, возвращаемая подстрока [specifier]; см. [].

scanner = StringScanner.new('Fri Dec 12 1975 14:39')
pattern = /(?<wday>\w+) (?<month>\w+) (?<day>\d+) /
scanner.match?(pattern)
scanner.values_at(*0..3)               # => ["Fri Dec 12 ", "Fri", "Dec", "12"]
scanner.values_at(*%i[wday month day]) # => ["Fri", "Dec", "12"]