def load_str(fp, delim):
oldpos = fp.pos
length = fp.read_int_until(':', can_be_negative=False)
if length < 0:
raise SerializerError("integer overflow")
try:
i = fp.consume(length + 3) # quote, string, quote, semicolon
except SerializerError:
if len(fp.s) > fp.pos:
extra = len(fp.s) - fp.pos - length
if extra > 0:
fp.error_pos = fp.pos + length + 1
if extra > 1:
fp.error_pos += 2
else:
fp.error_pos = oldpos
raise
check_nonneg(i)
s = fp.s
if s[i] != '"':
raise SerializerError("'\"' expected")
i += 1
data = s[i: i + length]
i += length
if s[i] != '"':
raise SerializerError("'\"' expected")
i += 1
if s[i] != delim:
raise SerializerError("delim expected")
return data
def run_instr(self, space, name, num_args, bytecode, frame, pc):
args = ()
# Do not change these from * 256 to << 8, lshift has defined overflow
# semantics which cause it to not propogate the nonnegative-ness.
if num_args >= 1:
v = ord(bytecode.code[pc]) | (ord(bytecode.code[pc + 1]) * 256)
check_nonneg(v)
args += (v,)
pc += 2
if num_args >= 2:
v = ord(bytecode.code[pc]) | (ord(bytecode.code[pc + 1]) * 256)
check_nonneg(v)
args += (v,)
pc += 2
if num_args >= 3:
raise NotImplementedError
method = getattr(self, name)
try:
res = method(space, bytecode, frame, pc, *args)
except RaiseBreak as e:
if e.parent_interp is not self:
raise
frame.push(e.w_value)
res = None
if res is not None:
pc = res
return pc
def __init__(self, space, code, w_globals, outer_func):
if not we_are_translated():
assert type(self) == space.FrameClass, (
"use space.FrameClass(), not directly PyFrame()")
self = hint(self, access_directly=True, fresh_virtualizable=True)
assert isinstance(code, pycode.PyCode)
self.space = space
self.pycode = code
if code.frame_stores_global(w_globals):
self.getorcreatedebug().w_globals = w_globals
ncellvars = len(code.co_cellvars)
nfreevars = len(code.co_freevars)
size = code.co_nlocals + ncellvars + nfreevars + code.co_stacksize
# the layout of this list is as follows:
# | local vars | cells | stack |
self.locals_cells_stack_w = [None] * size
self.valuestackdepth = code.co_nlocals + ncellvars + nfreevars
make_sure_not_resized(self.locals_cells_stack_w)
check_nonneg(self.valuestackdepth)
#
if space.config.objspace.honor__builtins__:
self.builtin = space.builtin.pick_builtin(w_globals)
# regular functions always have CO_OPTIMIZED and CO_NEWLOCALS.
# class bodies only have CO_NEWLOCALS.
self.initialize_frame_scopes(outer_func, code)
def __init__(self, space, s):
self.space = space
self.s = s
self.pos = 0
self.error_pos = 0
self.next_reference_obj = -1
self._ref_numbers = []
check_nonneg(self.pos)
def __init__(self, deque):
self.space = deque.space
self.deque = deque
self.block = deque.rightblock
self.index = deque.rightindex
self.counter = deque.len
self.lock = deque.getlock()
check_nonneg(self.index)
def pat(self, index):
check_nonneg(index)
result = self.pattern[index]
# Check that we only return non-negative integers from this helper.
# It is possible that self.pattern contains negative integers
# (see set_charset() and set_bigcharset() in rsre_char.py)
# but they should not be fetched via this helper here.
assert result >= 0
return result
def __init__(self, pattern, match_start, end, flags):
# 'match_start' and 'end' must be known to be non-negative
# and they must not be more than len(string).
check_nonneg(match_start)
check_nonneg(end)
self.pattern = pattern
self.match_start = match_start
self.end = end
self.flags = flags
def get_subclass_of_correct_size(space, cls, w_type):
assert space.config.objspace.std.withmapdict
map = w_type.terminator
classes = memo_get_subclass_of_correct_size(space, cls)
if SUBCLASSES_MIN_FIELDS == SUBCLASSES_MAX_FIELDS:
return classes[0]
size = map.size_estimate()
debug.check_nonneg(size)
if size < len(classes):
return classes[size]
else:
return classes[len(classes)-1]
def __init__(self, space):
self.space = space
self.maxlen = sys.maxint
self.clear()
check_nonneg(self.leftindex)
check_nonneg(self.rightindex)
#
# lightweight locking: any modification to the content of the deque
# sets the lock to None. Taking an iterator sets it to a non-None
# value. The iterator can check if further modifications occurred
# by checking if the lock still has the same non-None value.
# (In CPython, this is implemented using d->state.)
self.lock = None
def __init__(self, space):
self.space = space
self.maxlen = sys.maxint
self.clear()
check_nonneg(self.leftindex)
check_nonneg(self.rightindex)
#
# lightweight locking: any modification to the content of the deque
# sets the lock to None. Taking an iterator sets it to a non-None
# value. The iterator can check if further modifications occurred
# by checking if the lock still has the same non-None value.
# (In CPython, this is implemented using d->state.)
self.lock = None
def __init__(self, pattern, match_start, end, flags):
# 'match_start' and 'end' must be known to be non-negative
# and they must not be more than len(string).
check_nonneg(match_start)
check_nonneg(end)
self.pattern = pattern
self.match_start = match_start
self.end = end
self.flags = flags
# check we don't get the old value of MAXREPEAT
# during the untranslated tests
if not we_are_translated():
assert 65535 not in pattern
def pp_expect_nonneg_int(self, startpos):
check_nonneg(startpos)
s = self.s
i = startpos
limit = len(s)
result = 0
while i < limit and s[i].isdigit():
result = result * 10 + (ord(s[i]) - 48)
i += 1
self.pos = i
result = intmask(result)
if result < 0:
result = 0 # integer overflow!
return result
def pp_expect_nonneg_int(self, startpos):
check_nonneg(startpos)
s = self.s
i = startpos
limit = len(s)
result = 0
while i < limit and s[i].isdigit():
result = result * 10 + (ord(s[i]) - 48)
i += 1
self.pos = i
result = intmask(result)
if result < 0:
result = 0 # integer overflow!
return result
def _preprocess(self, i=0):
check_nonneg(i)
s = self.s
nesting = 0
assert i >= 0
while True:
if i >= len(s):
return -1
tp = s[i]
if tp == 'b':
i += 4 # 'b:0;' or 'b:1;'
elif tp == 'i' or tp == 'd':
i = s.find(';', i + 1)
if i < 0:
return -1
i += 1
elif tp == 's': # 's:LEN:"....";'
length = self.pp_expect_nonneg_int(i + 2)
i = self.pos + length + 4
elif tp == 'N':
i += 2 # 'N;'
elif tp == 'a': # 'a:LEN:{....}'
i = s.find('{', i + 1)
if i < 0:
return -1
i += 1
nesting += 1
elif tp == 'O': # 'O:LEN:"....":LEN:{....}'
length = self.pp_expect_nonneg_int(i + 2)
i = self.pos + length + 4
i = s.find('{', i + 1)
if i < 0:
return -1
i += 1
nesting += 1
elif tp == '}':
nesting -= 1
i += 1
elif tp == 'R' or tp == 'r': # 'R:BACKREF;'
backref = self.pp_expect_nonneg_int(i + 2)
self._ref_numbers.append(backref)
i = self.pos + 1
else:
return -1
if nesting <= 0:
return i
def _preprocess(self, i=0):
check_nonneg(i)
s = self.s
nesting = 0
assert i >= 0
while True:
if i >= len(s):
return -1
tp = s[i]
if tp == 'b':
i += 4 # 'b:0;' or 'b:1;'
elif tp == 'i' or tp == 'd':
i = s.find(';', i + 1)
if i < 0:
return -1
i += 1
elif tp == 's': # 's:LEN:"....";'
length = self.pp_expect_nonneg_int(i + 2)
i = self.pos + length + 4
elif tp == 'N':
i += 2 # 'N;'
elif tp == 'a': # 'a:LEN:{....}'
i = s.find('{', i + 1)
if i < 0:
return -1
i += 1
nesting += 1
elif tp == 'O': # 'O:LEN:"....":LEN:{....}'
length = self.pp_expect_nonneg_int(i + 2)
i = self.pos + length + 4
i = s.find('{', i + 1)
if i < 0:
return -1
i += 1
nesting += 1
elif tp == '}':
nesting -= 1
i += 1
elif tp == 'R' or tp == 'r': # 'R:BACKREF;'
backref = self.pp_expect_nonneg_int(i + 2)
self._ref_numbers.append(backref)
i = self.pos + 1
else:
return -1
if nesting <= 0:
return i
def __init__(self, space, code, w_globals, outer_func):
if not we_are_translated():
assert type(self) == space.FrameClass, (
"use space.FrameClass(), not directly PyFrame()")
self = hint(self, access_directly=True, fresh_virtualizable=True)
assert isinstance(code, pycode.PyCode)
self.space = space
self.w_globals = w_globals
self.pycode = code
self.locals_stack_w = [None] * (code.co_nlocals + code.co_stacksize)
self.valuestackdepth = code.co_nlocals
make_sure_not_resized(self.locals_stack_w)
check_nonneg(self.valuestackdepth)
#
if space.config.objspace.honor__builtins__:
self.builtin = space.builtin.pick_builtin(w_globals)
# regular functions always have CO_OPTIMIZED and CO_NEWLOCALS.
# class bodies only have CO_NEWLOCALS.
self.initialize_frame_scopes(outer_func, code)
def __init__(self, space, code, w_globals, outer_func):
if not we_are_translated():
assert type(self) in (space.FrameClass, CPythonFrame), (
"use space.FrameClass(), not directly PyFrame()")
self = hint(self, access_directly=True, fresh_virtualizable=True)
assert isinstance(code, pycode.PyCode)
self.pycode = code
eval.Frame.__init__(self, space, w_globals)
self.locals_stack_w = [None] * (code.co_nlocals + code.co_stacksize)
self.valuestackdepth = code.co_nlocals
self.lastblock = None
make_sure_not_resized(self.locals_stack_w)
check_nonneg(self.valuestackdepth)
#
if space.config.objspace.honor__builtins__:
self.builtin = space.builtin.pick_builtin(w_globals)
# regular functions always have CO_OPTIMIZED and CO_NEWLOCALS.
# class bodies only have CO_NEWLOCALS.
self.initialize_frame_scopes(outer_func, code)
self.f_lineno = code.co_firstlineno
def str(self, index):
check_nonneg(index)
return ord(self._string[index])
def str(self, index):
check_nonneg(index)
return ord(self._unicodestr[index])
def g(x):
check_nonneg(x-1)
def str(self, index):
check_nonneg(index)
return ord(self._buffer.getitem(index))
def load_object(fp):
fp.next_reference_obj -= 1
needs_ref = (fp.next_reference_obj == 0)
#
fp.error_pos = fp.pos
try:
i = fp.consume(2)
except SerializerError:
i = fp.consume(1)
if fp.s[i] == '}':
fp.space.ec.notice("unserialize(): "
"Unexpected end of serialized data")
raise
s = fp.s
tp = s[i]
check_nonneg(i)
check_nonneg(fp.pos)
#
if tp == 'i':
if s[i + 1] != ':':
raise SerializerError("':' expected")
i = fp.read_int_until(';')
w_result = fp.space.wrap(i)
#
elif tp == 's':
if s[i + 1] != ':':
raise SerializerError("':' expected")
w_result = fp.space.newstr(load_str(fp, ';'))
#
elif tp == 'd':
if s[i + 1] != ':':
raise SerializerError("':' expected")
data = fp.read_substring_until(';')
if data == 'INF':
w_result = fp.space.wrap(rfloat.INFINITY)
elif data == '-INF':
w_result = fp.space.wrap(-rfloat.INFINITY)
elif data == 'NAN':
w_result = fp.space.wrap(rfloat.NAN)
else:
w_number, valid = convert_string_to_number(data)
if not valid:
raise SerializerError('bad double')
w_result = fp.space.newfloat(w_number.float_w(fp.space))
#
elif tp == 'b':
if s[i + 1] != ':':
raise SerializerError("':' expected")
i = fp.consume(2)
digit = s[i]
if digit == '0':
w_result = fp.space.w_False
elif digit == '1':
w_result = fp.space.w_True
else:
raise SerializerError('bad bool')
if s[i + 1] != ';':
raise SerializerError("';' expected")
#
elif tp == 'N':
if s[i + 1] != ';':
raise SerializerError("';' expected")
w_result = fp.space.w_Null
#
elif tp == 'a':
if s[i + 1] != ':':
raise SerializerError("':' expected")
length = fp.read_int_until(':', can_be_negative=False)
if length < 0:
raise SerializerError("integer overflow")
i = fp.consume(1)
if s[i] != '{':
raise SerializerError("'{' expected")
w_result = None
if needs_ref:
w_result = fp.space.empty_ref()
fp.save_reference(w_result)
# first try to load the array as a direct list
lst_w = []
expected = ['i', ':', '0', ';']
for n in range(length):
i = fp.pos
if i + len(expected) >= len(s):
break
for j in range(len(expected)):
if s[i] != expected[j]:
break
i += 1
else:
# ok, we got exactly 'i:N;' where N is the expected index
fp.pos = i
lst_w.append(load_object(fp))
# increment the expected counter
j = len(expected) - 2
while j >= 2:
if expected[j] != '9':
expected[j] = chr(ord(expected[j]) + 1)
break
expected[j] = '0'
j -= 1
else:
expected = ['i', ':', '1'] + expected[2:]
continue
break
else:
# we succeeded in loading the complete array as a list
n = length
_succeeded_as_a_list() # for tests
# fill in the remaining entries, if any, the slow way
w_array = fp.space.new_array_from_list(lst_w)
for n in range(n, length):
w_key = load_array_key(fp)
w_value = load_object(fp)
w_array = fp.space.setitem_maybe_inplace(w_array, w_key, w_value)
fp.expect_closing_brace()
if w_result is not None: # needs_ref
w_result.store(w_array, unique=True)
return w_result
else:
return w_array
#
elif tp == 'R':
if s[i + 1] != ':':
raise SerializerError("':' expected")
return load_reference(fp)
#
elif tp == 'r':
if s[i + 1] != ':':
raise SerializerError("':' expected")
return load_reference(fp).deref()
#
elif tp == 'O':
if s[i + 1] != ':':
raise SerializerError("':' expected")
klass_name = load_str(fp, ':')
space = fp.space
interp = space.ec.interpreter
klass = interp.lookup_class_or_intf(klass_name)
if klass is None:
klass = k_incomplete
w_instance = klass.get_empty_instance(space)
w_instance.setattr(interp, '__PHP_Incomplete_Class_Name',
space.wrap(klass_name), None)
else:
w_instance = klass.get_empty_instance(space)
w_result = w_instance
if needs_ref:
w_result = W_Reference(w_instance)
fp.save_reference(w_result)
count_attrs = fp.read_int_until(':') # negative value accepted :-(
i = fp.consume(1)
if s[i] != '{':
raise SerializerError("'{' expected")
attrs = {}
for i in xrange(count_attrs):
w_attr = load_array_key(fp)
w_value = load_object(fp)
attr_name = space.str_w(w_attr)
attrs[attr_name] = w_value
w_instance.setattr(interp, attr_name, w_value, None)
fp.expect_closing_brace()
w_instance.unserialize(space, attrs)
if '__wakeup' in klass.methods:
klass.methods['__wakeup'].method_func.call_args(space.ec.interpreter,
[], w_this=w_instance,
thisclass=klass)
return w_result
#
else:
if tp == '}':
fp.space.ec.notice("unserialize(): "
"Unexpected end of serialized data")
raise SerializerError('malformed input')
# this is for primitive types only; complex types 'return' above
if needs_ref:
w_result = W_Reference(w_result)
fp.save_reference(w_result)
return w_result
def f(x):
assert x >= 5
check_nonneg(x)
def str(self, index):
check_nonneg(index)
return ord(self._string[index])
def str(self, index):
check_nonneg(index)
return ord(self._unicodestr[index])
def load_object(fp):
fp.next_reference_obj -= 1
needs_ref = (fp.next_reference_obj == 0)
#
fp.error_pos = fp.pos
try:
i = fp.consume(2)
except SerializerError:
i = fp.consume(1)
if fp.s[i] == '}':
fp.space.ec.notice("unserialize(): "
"Unexpected end of serialized data")
raise
s = fp.s
tp = s[i]
check_nonneg(i)
check_nonneg(fp.pos)
#
if tp == 'i':
if s[i + 1] != ':':
raise SerializerError("':' expected")
i = fp.read_int_until(';')
w_result = fp.space.wrap(i)
#
elif tp == 's':
if s[i + 1] != ':':
raise SerializerError("':' expected")
w_result = fp.space.newstr(load_str(fp, ';'))
#
elif tp == 'd':
if s[i + 1] != ':':
raise SerializerError("':' expected")
data = fp.read_substring_until(';')
w_number, valid = convert_string_to_number(data)
if not valid:
raise SerializerError('bad double')
w_result = fp.space.newfloat(w_number.float_w(fp.space))
#
elif tp == 'b':
if s[i + 1] != ':':
raise SerializerError("':' expected")
i = fp.consume(2)
digit = s[i]
if digit == '0':
w_result = fp.space.w_False
elif digit == '1':
w_result = fp.space.w_True
else:
raise SerializerError('bad bool')
if s[i + 1] != ';':
raise SerializerError("';' expected")
#
elif tp == 'N':
if s[i + 1] != ';':
raise SerializerError("';' expected")
w_result = fp.space.w_Null
#
elif tp == 'a':
if s[i + 1] != ':':
raise SerializerError("':' expected")
length = fp.read_int_until(':', can_be_negative=False)
if length < 0:
raise SerializerError("integer overflow")
i = fp.consume(1)
if s[i] != '{':
raise SerializerError("'{' expected")
w_result = None
if needs_ref:
w_result = fp.space.empty_ref()
fp.save_reference(w_result)
# first try to load the array as a direct list
lst_w = []
expected = ['i', ':', '0', ';']
for n in range(length):
i = fp.pos
if i + len(expected) >= len(s):
break
for j in range(len(expected)):
if s[i] != expected[j]:
break
i += 1
else:
# ok, we got exactly 'i:N;' where N is the expected index
fp.pos = i
lst_w.append(load_object(fp))
# increment the expected counter
j = len(expected) - 2
while j >= 2:
if expected[j] != '9':
expected[j] = chr(ord(expected[j]) + 1)
break
expected[j] = '0'
j -= 1
else:
expected = ['i', ':', '1'] + expected[2:]
continue
break
else:
# we succeeded in loading the complete array as a list
n = length
_succeeded_as_a_list() # for tests
# fill in the remaining entries, if any, the slow way
w_array = fp.space.new_array_from_list(lst_w)
for n in range(n, length):
w_key = load_array_key(fp)
w_value = load_object(fp)
w_array = fp.space.setitem_maybe_inplace(w_array, w_key, w_value)
fp.expect_closing_brace()
if w_result is not None: # needs_ref
w_result.store(w_array, unique=True)
return w_result
else:
return w_array
#
elif tp == 'R':
if s[i + 1] != ':':
raise SerializerError("':' expected")
return load_reference(fp)
#
elif tp == 'r':
if s[i + 1] != ':':
raise SerializerError("':' expected")
return load_reference(fp).deref()
#
elif tp == 'O':
if s[i + 1] != ':':
raise SerializerError("':' expected")
klass_name = load_str(fp, ':')
space = fp.space
interp = space.ec.interpreter
klass = interp.lookup_class_or_intf(klass_name)
if klass is None:
klass = k_incomplete
w_instance = klass.get_empty_instance(space)
w_instance.setattr(interp, '__PHP_Incomplete_Class_Name',
space.wrap(klass_name), None)
else:
w_instance = klass.get_empty_instance(space)
w_result = w_instance
if needs_ref:
w_result = W_Reference(w_instance)
fp.save_reference(w_result)
count_attrs = fp.read_int_until(':') # negative value accepted :-(
i = fp.consume(1)
if s[i] != '{':
raise SerializerError("'{' expected")
attrs = {}
for i in xrange(count_attrs):
w_attr = load_array_key(fp)
w_value = load_object(fp)
attr_name = space.str_w(w_attr)
attrs[attr_name] = w_value
w_instance.setattr(interp, attr_name, w_value, None)
fp.expect_closing_brace()
w_instance.unserialize(space, attrs)
if '__wakeup' in klass.methods:
klass.methods['__wakeup'].method_func.call_args(space.ec.interpreter,
[], w_this=w_instance,
thisclass=klass)
return w_result
#
else:
if tp == '}':
fp.space.ec.notice("unserialize(): "
"Unexpected end of serialized data")
raise SerializerError('malformed input')
# this is for primitive types only; complex types 'return' above
if needs_ref:
w_result = W_Reference(w_result)
fp.save_reference(w_result)
return w_result
def str(self, index):
check_nonneg(index)
return rutf8.codepoint_at_pos(self._utf8, index)
def g(x):
check_nonneg(x - 1)
def f(x):
assert x >= 5
check_nonneg(x)
def str(self, index):
check_nonneg(index)
return ord(self._buffer.getitem(index))
