1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
##
# String
#
# ISO 15.2.10
class String
include Comparable
##
# Calls the given block for each line
# and pass the respective line.
#
# ISO 15.2.10.5.15
def each_line(&block)
# expect that str.index accepts an Integer for 1st argument as a byte data
offset = 0
while(pos = self.index(0x0a, offset))
block.call(self[offset, pos + 1 - offset])
offset = pos + 1
end
block.call(self[offset, self.size - offset]) if self.size > offset
self
end
##
# Replace all matches of +pattern+ with +replacement+.
# Call block (if given) for each match and replace
# +pattern+ with the value of the block. Return the
# final value.
#
# ISO 15.2.10.5.18
def gsub(*args, &block)
if args.size == 2
split(args[0], -1).join(args[1])
elsif args.size == 1 && block
split(args[0], -1).join(block.call(args[0]))
else
raise ArgumentError, "wrong number of arguments"
end
end
##
# Replace all matches of +pattern+ with +replacement+.
# Call block (if given) for each match and replace
# +pattern+ with the value of the block. Modify
# +self+ with the final value.
#
# ISO 15.2.10.5.19
def gsub!(*args, &block)
str = self.gsub(*args, &block)
if str != self
self.replace(str)
self
else
nil
end
end
##
# Calls the given block for each match of +pattern+
# If no block is given return an array with all
# matches of +pattern+.
#
# ISO 15.2.10.5.32
def scan(reg, &block)
### *** TODO *** ###
unless Object.const_defined?(:Regexp)
raise NotImplementedError, "scan not available (yet)"
end
end
##
# Replace only the first match of +pattern+ with
# +replacement+. Call block (if given) for each
# match and replace +pattern+ with the value of the
# block. Return the final value.
#
# ISO 15.2.10.5.36
def sub(*args, &block)
if args.size == 2
split(args[0], 2).join(args[1])
elsif args.size == 1 && block
split(args[0], 2).join(block.call(args[0]))
else
raise ArgumentError, "wrong number of arguments"
end
end
##
# Replace only the first match of +pattern+ with
# +replacement+. Call block (if given) for each
# match and replace +pattern+ with the value of the
# block. Modify +self+ with the final value.
#
# ISO 15.2.10.5.37
def sub!(*args, &block)
str = self.sub(*args, &block)
if str != self
self.replace(str)
self
else
nil
end
end
##
# Call the given block for each character of
# +self+.
def each_char(&block)
pos = 0
while(pos < self.size)
block.call(self[pos])
pos += 1
end
self
end
##
# Call the given block for each byte of +self+.
def each_byte(&block)
bytes = self.bytes
pos = 0
while(pos < bytes.size)
block.call(bytes[pos])
pos += 1
end
self
end
##
# Modify +self+ by replacing the content of +self+
# at the position +pos+ with +value+.
def []=(pos, value)
b = self[0, pos]
a = self[pos+1..-1]
self.replace([b, value, a].join(''))
end
##
# ISO 15.2.10.5.3
def =~(re)
if re.respond_to? :to_str
raise TypeError, "type mismatch: String given"
end
re =~ self
end
##
# ISO 15.2.10.5.27
def match(re, &block)
re.match(self, &block)
end
end
##
# String is comparable
#
# ISO 15.2.10.3
module Comparable; end
class String
include Comparable
end
|
