def str_split__String_String_ANY(space, w_self, w_by, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
value = w_self._value
by = w_by._value
bylen = len(by)
if bylen == 0:
raise OperationError(space.w_ValueError, space.wrap("empty separator"))
res_w = []
start = 0
if bylen == 1 and maxsplit < 0:
# fast path: uses str.rfind(character) and str.count(character)
by = by[0] # annotator hack: string -> char
count = value.count(by)
res_w = [None] * (count + 1)
end = len(value)
while count >= 0:
assert end >= 0
prev = value.rfind(by, 0, end)
start = prev + 1
assert start >= 0
res_w[count] = sliced(space, value, start, end, w_self)
count -= 1
end = prev
else:
while maxsplit != 0:
next = value.find(by, start)
if next < 0:
break
res_w.append(sliced(space, value, start, next, w_self))
start = next + bylen
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
res_w.append(sliced(space, value, start, len(value), w_self))
return space.newlist(res_w)
def str_splitlines__String_ANY(space, w_self, w_keepends):
data = w_self._value
u_keepends = space.int_w(w_keepends) # truth value, but type checked
selflen = len(data)
strs_w = []
i = j = 0
while i < selflen:
# Find a line and append it
while i < selflen and data[i] != '\n' and data[i] != '\r':
i += 1
# Skip the line break reading CRLF as one line break
eol = i
i += 1
if i < selflen and data[i - 1] == '\r' and data[i] == '\n':
i += 1
if u_keepends:
eol = i
strs_w.append(sliced(space, data, j, eol))
j = i
if j < selflen:
strs_w.append(sliced(space, data, j, len(data)))
return space.newlist(strs_w)
def str_splitlines__String_ANY(space, w_self, w_keepends):
data = w_self._value
u_keepends = space.int_w(w_keepends) # truth value, but type checked
selflen = len(data)
strs_w = []
i = j = 0
while i < selflen:
# Find a line and append it
while i < selflen and data[i] != '\n' and data[i] != '\r':
i += 1
# Skip the line break reading CRLF as one line break
eol = i
i += 1
if i < selflen and data[i-1] == '\r' and data[i] == '\n':
i += 1
if u_keepends:
eol = i
strs_w.append(sliced(space, data, j, eol))
j = i
if j < selflen:
strs_w.append(sliced(space, data, j, len(data)))
return space.newlist(strs_w)
def str_rpartition__String_String(space, w_self, w_sub):
self = w_self._value
sub = w_sub._value
if not sub:
raise OperationError(space.w_ValueError, space.wrap("empty separator"))
pos = self.rfind(sub)
if pos == -1:
return space.newtuple([space.wrap(""), space.wrap(""), w_self])
else:
return space.newtuple(
[sliced(space, self, 0, pos, w_self), w_sub, sliced(space, self, pos + len(sub), len(self), w_self)]
)
def str_partition__StringSlice_String(space, w_self, w_sub):
self = w_self.str
sub = w_sub._value
if not sub:
raise OperationError(space.w_ValueError,
space.wrap("empty separator"))
pos = self.find(sub, w_self.start, w_self.stop)
if pos == -1:
return space.newtuple([w_self, space.wrap(''), space.wrap('')])
else:
return space.newtuple([sliced(space, self, w_self.start, pos),
w_sub,
sliced(space, self, pos+len(sub), w_self.stop)])
def str_partition__StringSlice_String(space, w_self, w_sub):
self = w_self.str
sub = w_sub._value
if not sub:
raise OperationError(space.w_ValueError, space.wrap("empty separator"))
pos = self.find(sub, w_self.start, w_self.stop)
if pos == -1:
return space.newtuple([w_self, space.wrap(''), space.wrap('')])
else:
return space.newtuple([
sliced(space, self, w_self.start, pos, w_self), w_sub,
sliced(space, self, pos + len(sub), w_self.stop, w_self)
])
def str_rpartition__String_String(space, w_self, w_sub):
self = w_self._value
sub = w_sub._value
if not sub:
raise OperationError(space.w_ValueError,
space.wrap("empty separator"))
pos = self.rfind(sub)
if pos == -1:
return space.newtuple([space.wrap(''), space.wrap(''), w_self])
else:
return space.newtuple([sliced(space, self, 0, pos, w_self),
w_sub,
sliced(space, self, pos+len(sub), len(self), w_self)])
def getslice__String_ANY_ANY(space, w_str, w_start, w_stop):
s = w_str._value
start, stop = normalize_simple_slice(space, len(s), w_start, w_stop)
if start == stop:
return W_StringObject.EMPTY
else:
return sliced(space, s, start, stop, w_str)
def str_rsplit__String_None_ANY(space, w_self, w_none, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
res_w = []
value = w_self._value
i = len(value)-1
while True:
# starting from the end, find the end of the next word
while i >= 0:
if not value[i].isspace():
break # found
i -= 1
else:
break # end of string, finished
# find the start of the word
# (more precisely, 'j' will be the space character before the word)
if maxsplit == 0:
j = -1 # take all the rest of the string
else:
j = i - 1
while j >= 0 and not value[j].isspace():
j -= 1
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
# the word is value[j+1:i+1]
j1 = j + 1
assert j1 >= 0
res_w.append(sliced(space, value, j1, i+1, w_self))
# continue to look from the character before the space before the word
i = j - 1
res_w.reverse()
return space.newlist(res_w)
def str_rsplit__String_None_ANY(space, w_self, w_none, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
res_w = []
value = w_self._value
i = len(value)-1
while True:
# starting from the end, find the end of the next word
while i >= 0:
if not value[i].isspace():
break # found
i -= 1
else:
break # end of string, finished
# find the start of the word
# (more precisely, 'j' will be the space character before the word)
if maxsplit == 0:
j = -1 # take all the rest of the string
else:
j = i - 1
while j >= 0 and not value[j].isspace():
j -= 1
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
# the word is value[j+1:i+1]
j1 = j + 1
assert j1 >= 0
res_w.append(sliced(space, value, j1, i+1, w_self))
# continue to look from the character before the space before the word
i = j - 1
res_w.reverse()
return space.newlist(res_w)
def str_split__String_None_ANY(space, w_self, w_none, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
res_w = []
value = w_self._value
length = len(value)
i = 0
while True:
# find the beginning of the next word
while i < length:
if not value[i].isspace():
break # found
i += 1
else:
break # end of string, finished
# find the end of the word
if maxsplit == 0:
j = length # take all the rest of the string
else:
j = i + 1
while j < length and not value[j].isspace():
j += 1
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
# the word is value[i:j]
res_w.append(sliced(space, value, i, j, w_self))
# continue to look from the character following the space after the word
i = j + 1
return space.newlist(res_w)
def getslice__String_ANY_ANY(space, w_str, w_start, w_stop):
s = w_str._value
start, stop = normalize_simple_slice(space, len(s), w_start, w_stop)
if start == stop:
return W_StringObject.EMPTY
else:
return sliced(space, s, start, stop, w_str)
def str_split__String_None_ANY(space, w_self, w_none, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
res_w = []
value = w_self._value
length = len(value)
i = 0
while True:
# find the beginning of the next word
while i < length:
if not value[i].isspace():
break # found
i += 1
else:
break # end of string, finished
# find the end of the word
if maxsplit == 0:
j = length # take all the rest of the string
else:
j = i + 1
while j < length and not value[j].isspace():
j += 1
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
# the word is value[i:j]
res_w.append(sliced(space, value, i, j, w_self))
# continue to look from the character following the space after the word
i = j + 1
return space.newlist(res_w)
def str_split__String_String_ANY(space, w_self, w_by, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
value = w_self._value
by = w_by._value
bylen = len(by)
if bylen == 0:
raise OperationError(space.w_ValueError, space.wrap("empty separator"))
res_w = []
start = 0
while maxsplit != 0:
next = value.find(by, start)
if next < 0:
break
res_w.append(sliced(space, value, start, next, w_self))
start = next + bylen
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
res_w.append(sliced(space, value, start, len(value), w_self))
return space.newlist(res_w)
def str_split__String_String_ANY(space, w_self, w_by, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
value = w_self._value
by = w_by._value
bylen = len(by)
if bylen == 0:
raise OperationError(space.w_ValueError, space.wrap("empty separator"))
res_w = []
start = 0
while maxsplit != 0:
next = value.find(by, start)
if next < 0:
break
res_w.append(sliced(space, value, start, next, w_self))
start = next + bylen
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
res_w.append(sliced(space, value, start, len(value), w_self))
return space.newlist(res_w)
def fn(space, w_self, w_by, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
res_w = []
value = w_self._value
end = len(value)
by = w_by._value
bylen = len(by)
if bylen == 0:
raise OperationError(space.w_ValueError, space.wrap("empty separator"))
while maxsplit != 0:
next = value.rfind(by, 0, end)
if next < 0:
break
res_w.append(sliced(space, value, next+bylen, end, w_self))
end = next
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
res_w.append(sliced(space, value, 0, end, w_self))
res_w.reverse()
return space.newlist(res_w)
def getitem__String_Slice(space, w_str, w_slice):
s = w_str._value
length = len(s)
start, stop, step, sl = w_slice.indices4(space, length)
if sl == 0:
return W_StringObject.EMPTY
elif step == 1:
assert start >= 0 and stop >= 0
return sliced(space, s, start, stop, w_str)
else:
str = "".join([s[start + i*step] for i in range(sl)])
return wrapstr(space, str)
def getitem__String_Slice(space, w_str, w_slice):
s = w_str._value
length = len(s)
start, stop, step, sl = w_slice.indices4(space, length)
if sl == 0:
return W_StringObject.EMPTY
elif step == 1:
assert start >= 0 and stop >= 0
return sliced(space, s, start, stop, w_str)
else:
str = "".join([s[start + i*step] for i in range(sl)])
return wrapstr(space, str)
def fn(space, w_self, w_by, w_maxsplit=-1):
maxsplit = space.int_w(w_maxsplit)
res_w = []
value = w_self._value
end = len(value)
by = w_by._value
bylen = len(by)
if bylen == 0:
raise OperationError(space.w_ValueError, space.wrap("empty separator"))
while maxsplit != 0:
next = value.rfind(by, 0, end)
if next < 0:
break
res_w.append(sliced(space, value, next+bylen, end, w_self))
end = next
maxsplit -= 1 # NB. if it's already < 0, it stays < 0
res_w.append(sliced(space, value, 0, end, w_self))
res_w.reverse()
return space.newlist(res_w)
def _strip_none(space, w_self, left, right):
"internal function called by str_xstrip methods"
u_self = w_self._value
lpos = 0
rpos = len(u_self)
if left:
#print "while %d < %d and -%s- in -%s-:"%(lpos, rpos, u_self[lpos],w_chars)
while lpos < rpos and u_self[lpos].isspace():
lpos += 1
if right:
while rpos > lpos and u_self[rpos - 1].isspace():
rpos -= 1
assert rpos >= lpos # annotator hint, don't remove
return sliced(space, u_self, lpos, rpos, w_self)
def _strip_none(space, w_self, left, right):
"internal function called by str_xstrip methods"
u_self = w_self._value
lpos = 0
rpos = len(u_self)
if left:
#print "while %d < %d and -%s- in -%s-:"%(lpos, rpos, u_self[lpos],w_chars)
while lpos < rpos and u_self[lpos].isspace():
lpos += 1
if right:
while rpos > lpos and u_self[rpos - 1].isspace():
rpos -= 1
assert rpos >= lpos # annotator hint, don't remove
return sliced(space, u_self, lpos, rpos, w_self)