Class: StringScanner
- Inherits:
-
Object
- Object
- StringScanner
- Defined in:
- strscan.c,
strscan.c
Overview
StringScanner provides for lexical scanning operations on a String. Here is an example of its usage:
s = StringScanner.new('This is an example string')
s.eos? # -> false
p s.scan(/\w+/) # -> "This"
p s.scan(/\w+/) # -> nil
p s.scan(/\s+/) # -> " "
p s.scan(/\s+/) # -> nil
p s.scan(/\w+/) # -> "is"
s.eos? # -> false
p s.scan(/\s+/) # -> " "
p s.scan(/\w+/) # -> "an"
p s.scan(/\s+/) # -> " "
p s.scan(/\w+/) # -> "example"
p s.scan(/\s+/) # -> " "
p s.scan(/\w+/) # -> "string"
s.eos? # -> true
p s.scan(/\s+/) # -> nil
p s.scan(/\w+/) # -> nil
Scanning a string means remembering the position of a scan pointer, which is just an index. The point of scanning is to move forward a bit at a time, so matches are sought after the scan pointer; usually immediately after it.
Given the string “test string”, here are the pertinent scan pointer positions:
t e s t s t r i n g
0 1 2 ... 1
0
When you #scan for a pattern (a regular expression), the match must occur at the character after the scan pointer. If you use #scan_until, then the match can occur anywhere after the scan pointer. In both cases, the scan pointer moves just beyond the last character of the match, ready to scan again from the next character onwards. This is demonstrated by the example above.
Method Categories
There are other methods besides the plain scanners. You can look ahead in the string without actually scanning. You can access the most recent match. You can modify the string being scanned, reset or terminate the scanner, find out or change the position of the scan pointer, skip ahead, and so on.
Advancing the Scan Pointer
-
#getch
-
#get_byte
-
#scan
-
#scan_until
-
#skip
-
#skip_until
Looking Ahead
-
#check
-
#check_until
-
#exist?
-
#match?
-
#peek
Finding Where we Are
-
#beginning_of_line? (#bol?)
-
#eos?
-
#rest?
-
#rest_size
-
#pos
Setting Where we Are
-
#reset
-
#terminate
-
#pos=
Match Data
-
#matched
-
#matched?
-
#matched_size
-
#pre_match
-
#post_match
Miscellaneous
-
<<
-
#concat
-
#string
-
#string=
-
#unscan
There are aliases to several of the methods.
Defined Under Namespace
Classes: Error
Class Method Summary collapse
-
.must_C_version ⇒ Object
This method is defined for backward compatibility.
Instance Method Summary collapse
-
#<< ⇒ Object
Appends
str
to the string being scanned. -
#[](n) ⇒ Object
Return the n-th subgroup in the most recent match.
-
#beginning_of_line? ⇒ Boolean
Returns
true
iff the scan pointer is at the beginning of the line. -
#charpos ⇒ Object
Returns the character position of the scan pointer.
-
#check(pattern) ⇒ Object
This returns the value that #scan would return, without advancing the scan pointer.
-
#check_until(pattern) ⇒ Object
This returns the value that #scan_until would return, without advancing the scan pointer.
-
#clear ⇒ Object
Equivalent to #terminate.
-
#concat ⇒ Object
Appends
str
to the string being scanned. -
#empty? ⇒ Boolean
Equivalent to #eos?.
-
#eos? ⇒ Boolean
Returns
true
if the scan pointer is at the end of the string. -
#exist?(pattern) ⇒ Boolean
Looks ahead to see if the
pattern
exists anywhere in the string, without advancing the scan pointer. -
#get_byte ⇒ Object
Scans one byte and returns it.
-
#getbyte ⇒ Object
Equivalent to #get_byte.
-
#getch ⇒ Object
Scans one character and returns it.
-
#inspect ⇒ Object
Returns a string that represents the StringScanner object, showing: - the current position - the size of the string - the characters surrounding the scan pointer.
-
#match?(pattern) ⇒ Boolean
Tests whether the given
pattern
is matched from the current scan pointer. -
#matched ⇒ Object
Returns the last matched string.
-
#matched? ⇒ Boolean
Returns
true
iff the last match was successful. -
#matched_size ⇒ Object
Returns the size of the most recent match (see #matched), or
nil
if there was no recent match. -
#peek(len) ⇒ Object
Extracts a string corresponding to
string[pos,len]
, without advancing the scan pointer. -
#peep ⇒ Object
Equivalent to #peek.
-
#pointer ⇒ Object
Returns the byte position of the scan pointer.
-
#pos=(n) ⇒ Object
Set the byte position of the scan pointer.
-
#pos ⇒ Object
Returns the byte position of the scan pointer.
-
#pos=(n) ⇒ Object
Set the byte position of the scan pointer.
-
#post_match ⇒ Object
Return the post-match (in the regular expression sense) of the last scan.
-
#pre_match ⇒ Object
Return the pre-match (in the regular expression sense) of the last scan.
-
#reset ⇒ Object
Reset the scan pointer (index 0) and clear matching data.
-
#rest ⇒ Object
Returns the “rest” of the string (i.e. everything after the scan pointer).
-
#rest? ⇒ Boolean
Returns true iff there is more data in the string.
-
#rest_size ⇒ Object
s.rest_size
is equivalent tos.rest.size
. -
#restsize ⇒ Object
s.restsize
is equivalent tos.rest_size
. -
#scan(pattern) ⇒ String
Tries to match with
pattern
at the current position. -
#scan_full(pattern, advance_pointer_p, return_string_p) ⇒ Object
Tests whether the given
pattern
is matched from the current scan pointer. -
#scan_until(pattern) ⇒ Object
Scans the string until the
pattern
is matched. -
#search_full(pattern, advance_pointer_p, return_string_p) ⇒ Object
Scans the string until the
pattern
is matched. -
#skip(pattern) ⇒ Object
Attempts to skip over the given
pattern
beginning with the scan pointer. -
#skip_until(pattern) ⇒ Object
Advances the scan pointer until
pattern
is matched and consumed. -
#string ⇒ Object
Returns the string being scanned.
-
#string=(str) ⇒ Object
Changes the string being scanned to
str
and resets the scanner. -
#terminate ⇒ Object
Set the scan pointer to the end of the string and clear matching data.
-
#unscan ⇒ Object
Set the scan pointer to the previous position.
Class Method Details
.must_C_version ⇒ Object
This method is defined for backward compatibility.
266 267 268 269 270 |
# File 'strscan.c', line 266
static VALUE
strscan_s_mustc(VALUE self)
{
return self;
}
|
Instance Method Details
#concat(str) ⇒ Object #<<(str) ⇒ Object
Appends str
to the string being scanned. This method does not affect scan pointer.
s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan(/Fri /)
s << " +1000 GMT"
s.string # -> "Fri Dec 12 1975 14:39 +1000 GMT"
s.scan(/Dec/) # -> "Dec"
359 360 361 362 363 364 365 366 367 368 |
# File 'strscan.c', line 359
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;
}
|
#[](n) ⇒ Object
Return the n-th subgroup in the most recent match.
s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan(/(\w+) (\w+) (\d+) /) # -> "Fri Dec 12 "
s[0] # -> "Fri Dec 12 "
s[1] # -> "Fri"
s[2] # -> "Dec"
s[3] # -> "12"
s.post_match # -> "1975 14:39"
s.pre_match # -> ""
987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 |
# File 'strscan.c', line 987
static VALUE
strscan_aref(VALUE self, VALUE idx)
{
struct strscanner *p;
long i;
GET_SCANNER(self, p);
if (! MATCHED_P(p)) return Qnil;
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, p->prev + p->regs.beg[i],
p->prev + p->regs.end[i]);
}
|
#beginning_of_line? ⇒ Boolean
Returns true
iff the scan pointer is at the beginning of the line.
s = StringScanner.new("test\ntest\n")
s.bol? # => true
s.scan(/te/)
s.bol? # => false
s.scan(/st\n/)
s.bol? # => true
s.terminate
s.bol? # => true
859 860 861 862 863 864 865 866 867 868 |
# File 'strscan.c', line 859
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;
}
|
#charpos ⇒ Object
Returns the character position of the scan pointer. In the 'reset' position, this value is zero. In the 'terminated' position (i.e. the string is exhausted), this value is the size of the string.
In short, it's a 0-based index into the string.
s = StringScanner.new("abc??def??ghi")
s.charpos # -> 0
s.scan_until(/??/) # -> "abc??"
s.pos # -> 5
s.charpos # -> 4
406 407 408 409 410 411 412 413 414 415 416 417 |
# File 'strscan.c', line 406
static VALUE
strscan_get_charpos(VALUE self)
{
struct strscanner *p;
VALUE substr;
GET_SCANNER(self, p);
substr = rb_funcall(p->str, id_byteslice, 2, INT2FIX(0), INT2NUM(p->curr));
return rb_str_length(substr);
}
|
#check(pattern) ⇒ Object
This returns the value that #scan would return, without advancing the scan pointer. The match register is affected, though.
s = StringScanner.new("Fri Dec 12 1975 14:39")
s.check /Fri/ # -> "Fri"
s.pos # -> 0
s.matched # -> "Fri"
s.check /12/ # -> nil
s.matched # -> nil
Mnemonic: it “checks” to see whether a #scan will return a value.
580 581 582 583 584 |
# File 'strscan.c', line 580
static VALUE
strscan_check(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 0, 1, 1);
}
|
#check_until(pattern) ⇒ Object
This returns the value that #scan_until would return, without advancing the scan pointer. The match register is affected, though.
s = StringScanner.new("Fri Dec 12 1975 14:39")
s.check_until /12/ # -> "Fri Dec 12"
s.pos # -> 0
s.matched # -> 12
Mnemonic: it “checks” to see whether a #scan_until will return a value.
674 675 676 677 678 |
# File 'strscan.c', line 674
static VALUE
strscan_check_until(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 0, 1, 0);
}
|
#clear ⇒ Object
Equivalent to #terminate. This method is obsolete; use #terminate instead.
308 309 310 311 312 313 |
# File 'strscan.c', line 308
static VALUE
strscan_clear(VALUE self)
{
rb_warning("StringScanner#clear is obsolete; use #terminate instead");
return strscan_terminate(self);
}
|
#concat(str) ⇒ Object #<<(str) ⇒ Object
Appends str
to the string being scanned. This method does not affect scan pointer.
s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan(/Fri /)
s << " +1000 GMT"
s.string # -> "Fri Dec 12 1975 14:39 +1000 GMT"
s.scan(/Dec/) # -> "Dec"
359 360 361 362 363 364 365 366 367 368 |
# File 'strscan.c', line 359
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;
}
|
#empty? ⇒ Boolean
Equivalent to #eos?. This method is obsolete, use #eos? instead.
893 894 895 896 897 898 |
# File 'strscan.c', line 893
static VALUE
strscan_empty_p(VALUE self)
{
rb_warning("StringScanner#empty? is obsolete; use #eos? instead");
return strscan_eos_p(self);
}
|
#eos? ⇒ Boolean
Returns true
if the scan pointer is at the end of the string.
s = StringScanner.new('test string')
p s.eos? # => false
s.scan(/test/)
p s.eos? # => false
s.terminate
p s.eos? # => true
880 881 882 883 884 885 886 887 |
# File 'strscan.c', line 880
static VALUE
strscan_eos_p(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
return EOS_P(p) ? Qtrue : Qfalse;
}
|
#exist?(pattern) ⇒ Boolean
Looks ahead to see if the pattern
exists anywhere in the string, without advancing the scan pointer. This predicates whether a #scan_until will return a value.
s = StringScanner.new('test string')
s.exist? /s/ # -> 3
s.scan /test/ # -> "test"
s.exist? /s/ # -> 2
s.exist? /e/ # -> nil
633 634 635 636 637 |
# File 'strscan.c', line 633
static VALUE
strscan_exist_p(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 0, 0, 0);
}
|
#get_byte ⇒ Object
Scans one byte and returns it. This method is not multibyte character sensitive. See also: #getch.
s = StringScanner.new('ab')
s.get_byte # => "a"
s.get_byte # => "b"
s.get_byte # => nil
$KCODE = 'EUC'
s = StringScanner.new("\244\242")
s.get_byte # => "\244"
s.get_byte # => "\242"
s.get_byte # => nil
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 |
# File 'strscan.c', line 755
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, p->prev + p->regs.beg[0],
p->prev + p->regs.end[0]);
}
|
#getbyte ⇒ Object
Equivalent to #get_byte. This method is obsolete; use #get_byte instead.
777 778 779 780 781 782 |
# File 'strscan.c', line 777
static VALUE
strscan_getbyte(VALUE self)
{
rb_warning("StringScanner#getbyte is obsolete; use #get_byte instead");
return strscan_get_byte(self);
}
|
#getch ⇒ Object
Scans one character and returns it. This method is multibyte character sensitive.
s = StringScanner.new("ab")
s.getch # => "a"
s.getch # => "b"
s.getch # => nil
$KCODE = 'EUC'
s = StringScanner.new("\244\242")
s.getch # => "\244\242" # Japanese hira-kana "A" in EUC-JP
s.getch # => nil
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 |
# File 'strscan.c', line 716
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));
if (p->curr + len > S_LEN(p)) {
len = S_LEN(p) - p->curr;
}
p->prev = p->curr;
p->curr += len;
MATCHED(p);
adjust_registers_to_matched(p);
return extract_range(p, p->prev + p->regs.beg[0],
p->prev + p->regs.end[0]);
}
|
#inspect ⇒ Object
Returns a string that represents the StringScanner object, showing:
-
the current position
-
the size of the string
-
the characters surrounding the scan pointer
s = StringScanner.new(“Fri Dec 12 1975 14:39”) s.inspect # -> ‘#<StringScanner 0/21 @ “Fri D…”>’ s.scan_until /12/ # -> “Fri Dec 12” s.inspect # -> ‘#<StringScanner 10/21 “…ec 12” @ “ 1975…”>’
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 |
# File 'strscan.c', line 1103
static VALUE
strscan_inspect(VALUE self)
{
struct strscanner *p;
char buf[BUFSIZE];
long len;
VALUE a, b;
p = check_strscan(self);
if (NIL_P(p->str)) {
len = snprintf(buf, BUFSIZE, "#<%s (uninitialized)>",
rb_class2name(CLASS_OF(self)));
return infect(rb_str_new(buf, len), p);
}
if (EOS_P(p)) {
len = snprintf(buf, BUFSIZE, "#<%s fin>",
rb_class2name(CLASS_OF(self)));
return infect(rb_str_new(buf, len), p);
}
if (p->curr == 0) {
b = inspect2(p);
len = snprintf(buf, BUFSIZE, "#<%s %ld/%ld @ %s>",
rb_class2name(CLASS_OF(self)),
p->curr, S_LEN(p),
RSTRING_PTR(b));
return infect(rb_str_new(buf, len), p);
}
a = inspect1(p);
b = inspect2(p);
len = snprintf(buf, BUFSIZE, "#<%s %ld/%ld %s @ %s>",
rb_class2name(CLASS_OF(self)),
p->curr, S_LEN(p),
RSTRING_PTR(a),
RSTRING_PTR(b));
return infect(rb_str_new(buf, len), p);
}
|
#match?(pattern) ⇒ Boolean
Tests whether the given pattern
is matched from the current scan pointer. Returns the length of the match, or nil
. The scan pointer is not advanced.
s = StringScanner.new('test string')
p s.match?(/\w+/) # -> 4
p s.match?(/\w+/) # -> 4
p s.match?(/\s+/) # -> nil
536 537 538 539 540 |
# File 'strscan.c', line 536
static VALUE
strscan_match_p(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 0, 0, 1);
}
|
#matched ⇒ Object
Returns the last matched string.
s = StringScanner.new('test string')
s.match?(/\w+/) # -> 4
s.matched # -> "test"
942 943 944 945 946 947 948 949 950 951 |
# File 'strscan.c', line 942
static VALUE
strscan_matched(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
if (! MATCHED_P(p)) return Qnil;
return extract_range(p, p->prev + p->regs.beg[0],
p->prev + p->regs.end[0]);
}
|
#matched? ⇒ Boolean
Returns true
iff the last match was successful.
s = StringScanner.new('test string')
s.match?(/\w+/) # => 4
s.matched? # => true
s.match?(/\d+/) # => nil
s.matched? # => false
926 927 928 929 930 931 932 933 |
# File 'strscan.c', line 926
static VALUE
strscan_matched_p(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
return MATCHED_P(p) ? Qtrue : Qfalse;
}
|
#matched_size ⇒ Object
Returns the size of the most recent match (see #matched), or nil
if there was no recent match.
s = StringScanner.new('test string')
s.check /\w+/ # -> "test"
s.matched_size # -> 4
s.check /\d+/ # -> nil
s.matched_size # -> nil
963 964 965 966 967 968 969 970 971 |
# File 'strscan.c', line 963
static VALUE
strscan_matched_size(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
if (! MATCHED_P(p)) return Qnil;
return INT2NUM(p->regs.end[0] - p->regs.beg[0]);
}
|
#peek(len) ⇒ Object
Extracts a string corresponding to string[pos,len]
, without advancing the scan pointer.
s = StringScanner.new('test string')
s.peek(7) # => "test st"
s.peek(7) # => "test st"
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 |
# File 'strscan.c', line 795
static VALUE
strscan_peek(VALUE self, VALUE vlen)
{
struct strscanner *p;
long len;
GET_SCANNER(self, p);
len = NUM2LONG(vlen);
if (EOS_P(p))
return infect(str_new(p, "", 0), p);
if (p->curr + len > S_LEN(p))
len = S_LEN(p) - p->curr;
return extract_beg_len(p, p->curr, len);
}
|
#peep ⇒ Object
Equivalent to #peek. This method is obsolete; use #peek instead.
816 817 818 819 820 821 |
# File 'strscan.c', line 816
static VALUE
strscan_peep(VALUE self, VALUE vlen)
{
rb_warning("StringScanner#peep is obsolete; use #peek instead");
return strscan_peek(self, vlen);
}
|
#pointer ⇒ Object
Returns the byte position of the scan pointer. In the ‘reset’ position, this value is zero. In the ‘terminated’ position (i.e. the string is exhausted), this value is the bytesize of the string.
In short, it’s a 0-based index into bytes of the string.
s = StringScanner.new('test string')
s.pos # -> 0
s.scan_until /str/ # -> "test str"
s.pos # -> 8
s.terminate # -> #<StringScanner fin>
s.pos # -> 11
384 385 386 387 388 389 390 391 |
# File 'strscan.c', line 384
static VALUE
strscan_get_pos(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
return INT2FIX(p->curr);
}
|
#pos=(n) ⇒ Object
Set the byte position of the scan pointer.
s = StringScanner.new('test string')
s.pos = 7 # -> 7
s.rest # -> "ring"
428 429 430 431 432 433 434 435 436 437 438 439 440 441 |
# File 'strscan.c', line 428
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 INT2NUM(i);
}
|
#pos ⇒ Object
Returns the byte position of the scan pointer. In the ‘reset’ position, this value is zero. In the ‘terminated’ position (i.e. the string is exhausted), this value is the bytesize of the string.
In short, it’s a 0-based index into bytes of the string.
s = StringScanner.new('test string')
s.pos # -> 0
s.scan_until /str/ # -> "test str"
s.pos # -> 8
s.terminate # -> #<StringScanner fin>
s.pos # -> 11
384 385 386 387 388 389 390 391 |
# File 'strscan.c', line 384
static VALUE
strscan_get_pos(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
return INT2FIX(p->curr);
}
|
#pos=(n) ⇒ Object
Set the byte position of the scan pointer.
s = StringScanner.new('test string')
s.pos = 7 # -> 7
s.rest # -> "ring"
428 429 430 431 432 433 434 435 436 437 438 439 440 441 |
# File 'strscan.c', line 428
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 INT2NUM(i);
}
|
#post_match ⇒ Object
Return the post-match (in the regular expression sense) of the last scan.
s = StringScanner.new('test string')
s.scan(/\w+/) # -> "test"
s.scan(/\s+/) # -> " "
s.pre_match # -> "test"
s.post_match # -> "string"
1035 1036 1037 1038 1039 1040 1041 1042 1043 |
# File 'strscan.c', line 1035
static VALUE
strscan_post_match(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
if (! MATCHED_P(p)) return Qnil;
return extract_range(p, p->prev + p->regs.end[0], S_LEN(p));
}
|
#pre_match ⇒ Object
Return the pre-match (in the regular expression sense) of the last scan.
s = StringScanner.new('test string')
s.scan(/\w+/) # -> "test"
s.scan(/\s+/) # -> " "
s.pre_match # -> "test"
s.post_match # -> "string"
1016 1017 1018 1019 1020 1021 1022 1023 1024 |
# File 'strscan.c', line 1016
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, p->prev + p->regs.beg[0]);
}
|
#reset ⇒ Object
Reset the scan pointer (index 0) and clear matching data.
275 276 277 278 279 280 281 282 283 284 |
# File 'strscan.c', line 275
static VALUE
strscan_reset(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
p->curr = 0;
CLEAR_MATCH_STATUS(p);
return self;
}
|
#rest ⇒ Object
Returns the “rest” of the string (i.e. everything after the scan pointer). If there is no more data (eos? = true), it returns ""
.
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 |
# File 'strscan.c', line 1049
static VALUE
strscan_rest(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
if (EOS_P(p)) {
return infect(str_new(p, "", 0), p);
}
return extract_range(p, p->curr, S_LEN(p));
}
|
#rest? ⇒ Boolean
Returns true iff there is more data in the string. See #eos?. This method is obsolete; use #eos? instead.
s = StringScanner.new('test string')
s.eos? # These two
s.rest? # are opposites.
908 909 910 911 912 913 914 915 |
# File 'strscan.c', line 908
static VALUE
strscan_rest_p(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
return EOS_P(p) ? Qfalse : Qtrue;
}
|
#rest_size ⇒ Object
s.rest_size
is equivalent to s.rest.size
.
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 |
# File 'strscan.c', line 1064
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_LEN(p) - p->curr;
return INT2FIX(i);
}
|
#restsize ⇒ Object
s.restsize
is equivalent to s.rest_size
. This method is obsolete; use #rest_size instead.
1082 1083 1084 1085 1086 1087 |
# File 'strscan.c', line 1082
static VALUE
strscan_restsize(VALUE self)
{
rb_warning("StringScanner#restsize is obsolete; use #rest_size instead");
return strscan_rest_size(self);
}
|
#scan(pattern) ⇒ String
Tries to match with pattern
at the current position. If there’s a match, the scanner advances the “scan pointer” and returns the matched string. Otherwise, the scanner returns nil
.
s = StringScanner.new('test string')
p s.scan(/\w+/) # -> "test"
p s.scan(/\w+/) # -> nil
p s.scan(/\s+/) # -> " "
p s.scan(/\w+/) # -> "string"
p s.scan(/./) # -> nil
519 520 521 522 523 |
# File 'strscan.c', line 519
static VALUE
strscan_scan(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 1, 1, 1);
}
|
#scan_full(pattern, advance_pointer_p, return_string_p) ⇒ Object
Tests whether the given pattern
is matched from the current scan pointer. Advances the scan pointer if advance_pointer_p
is true. Returns the matched string if return_string_p
is true. The match register is affected.
“full” means “#scan with full parameters”.
596 597 598 599 600 |
# File 'strscan.c', line 596
static VALUE
strscan_scan_full(VALUE self, VALUE re, VALUE s, VALUE f)
{
return strscan_do_scan(self, re, RTEST(s), RTEST(f), 1);
}
|
#scan_until(pattern) ⇒ Object
Scans the string until the pattern
is matched. Returns the substring up to and including the end of the match, advancing the scan pointer to that location. If there is no match, nil
is returned.
s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan_until(/1/) # -> "Fri Dec 1"
s.pre_match # -> "Fri Dec "
s.scan_until(/XYZ/) # -> nil
614 615 616 617 618 |
# File 'strscan.c', line 614
static VALUE
strscan_scan_until(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 1, 1, 0);
}
|
#search_full(pattern, advance_pointer_p, return_string_p) ⇒ Object
Scans the string until the pattern
is matched. Advances the scan pointer if advance_pointer_p
, otherwise not. Returns the matched string if return_string_p
is true, otherwise returns the number of bytes advanced. This method does affect the match register.
689 690 691 692 693 |
# File 'strscan.c', line 689
static VALUE
strscan_search_full(VALUE self, VALUE re, VALUE s, VALUE f)
{
return strscan_do_scan(self, re, RTEST(s), RTEST(f), 0);
}
|
#skip(pattern) ⇒ Object
Attempts to skip over the given pattern
beginning with the scan pointer. If it matches, the scan pointer is advanced to the end of the match, and the length of the match is returned. Otherwise, nil
is returned.
It’s similar to #scan, but without returning the matched string.
s = StringScanner.new('test string')
p s.skip(/\w+/) # -> 4
p s.skip(/\w+/) # -> nil
p s.skip(/\s+/) # -> 1
p s.skip(/\w+/) # -> 6
p s.skip(/./) # -> nil
559 560 561 562 563 |
# File 'strscan.c', line 559
static VALUE
strscan_skip(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 1, 0, 1);
}
|
#skip_until(pattern) ⇒ Object
Advances the scan pointer until pattern
is matched and consumed. Returns the number of bytes advanced, or nil
if no match was found.
Look ahead to match pattern
, and advance the scan pointer to the end of the match. Return the number of characters advanced, or nil
if the match was unsuccessful.
It’s similar to #scan_until, but without returning the intervening string.
s = StringScanner.new("Fri Dec 12 1975 14:39")
s.skip_until /12/ # -> 10
s #
655 656 657 658 659 |
# File 'strscan.c', line 655
static VALUE
strscan_skip_until(VALUE self, VALUE re)
{
return strscan_do_scan(self, re, 1, 0, 0);
}
|
#string ⇒ Object
Returns the string being scanned.
318 319 320 321 322 323 324 325 |
# File 'strscan.c', line 318
static VALUE
strscan_get_string(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
return p->str;
}
|
#string=(str) ⇒ Object
Changes the string being scanned to str
and resets the scanner. Returns str
.
333 334 335 336 337 338 339 340 341 342 343 |
# File 'strscan.c', line 333
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;
}
|
#terminate ⇒ Object #clear ⇒ Object
Set the scan pointer to the end of the string and clear matching data.
293 294 295 296 297 298 299 300 301 302 |
# File 'strscan.c', line 293
static VALUE
strscan_terminate(VALUE self)
{
struct strscanner *p;
GET_SCANNER(self, p);
p->curr = S_LEN(p);
CLEAR_MATCH_STATUS(p);
return self;
}
|
#unscan ⇒ Object
Set the scan pointer to the previous position. Only one previous position is remembered, and it changes with each scanning operation.
s = StringScanner.new('test string')
s.scan(/\w+/) # => "test"
s.unscan
s.scan(/../) # => "te"
s.scan(/\d/) # => nil
s.unscan # ScanError: unscan failed: previous match record not exist
834 835 836 837 838 839 840 841 842 843 844 845 |
# File 'strscan.c', line 834
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;
}
|