@wrap_method([
'interp',
ThisUnwrapper(W_DateTime),
Optional(InstanceUnwrapper(W_DateInterval, 'DateInterval'))
],
name='DateTime::add')
def add(interp, this, datetime_interval=None):
common.date_addsub(interp, this, datetime_interval, 1)
return this
@wrap_method([
'interp',
ThisUnwrapper(W_DateTime),
InstanceUnwrapper(W_DateTime, 'DateTime'),
Optional(BoolArg(None))
],
name='DateTime::diff')
def diff(interp, this, w_datetime, absolute=False):
null_ptr = lltype.nullptr(timelib.timelib_tzinfo.TO)
timelib.timelib_update_ts(this.timelib_time, null_ptr)
timelib.timelib_update_ts(w_datetime.timelib_time, null_ptr)
interval = W_DateInterval(k_DateInterval, [])
interval.time_diff = timelib.timelib_diff(this.timelib_time,
w_datetime.timelib_time)
if absolute:
interval.time_diff.c_invert = rffi.cast(rffi.INT, 0)
return self._label_parse(s, pos_p, pos_ue)
else:
self.path = s[pos_s:pos_ue]
return self
def _label_parse(self, s, pos_p, pos_ue):
pos_p += 1
if pos_ue != pos_p:
self.fragment = s[pos_p:pos_ue]
return self
def _just_path(self, s, pos_s):
return self._nohost(s, pos_s, pos_s + len(s))
@wrap(['space', StringArg(None), Optional(BoolArg(None))])
def base64_decode(space, data, strict=False):
res = b64_decode(data, strict)
if res is None:
return space.w_False
return space.wrap(res)
@wrap(['space', StringArg(None)])
def base64_encode(space, data):
res = b64_encode(data)
if res is None:
return space.w_False
return space.wrap(res[:-1])
@wrap(['interp', 'args_w'])
def var_dump(interp, args_w):
""" Dumps information about a variable"""
for w_x in args_w:
if w_x:
w_x = w_x.copy() # xxx ideally we should ask and get a
# unique object, but that's not supported
# so far
interp.writestr(w_x.var_dump(interp.space, indent='',
recursion={}))
return interp.space.w_Null
@wrap(['space', W_Root, Optional(BoolArg(None))])
def var_export(space, w_obj, ret=False):
""" Outputs or returns a parsable string representation of a variable"""
from hippy.objects.instanceobject import W_InstanceObject
from hippy.objects.arrayobject import W_ArrayObject
if isinstance(w_obj, W_ArrayObject):
suffix = 'array'
elif isinstance(w_obj, W_InstanceObject):
suffix = ')'
else:
suffix = ''
res = w_obj.var_export(space, '', {}, suffix=suffix)
if res:
if ret:
return space.newstr(res)
return space.newstr(n)
except rsocket.RSocketError:
return space.w_False
def header_register_callback():
""" Call a header function"""
return NotImplementedError()
def header_remove():
""" Remove previously set headers"""
return NotImplementedError()
@wrap(['interp', StringArg(None), Optional(BoolArg(None)), Optional(int)])
def header(interp, data, replace=True, response_code=0):
""" Send a raw HTTP header"""
assert response_code == 0
interp.header(data, replace)
def headers_list():
""" Returns a list of response headers sent(or ready to send)"""
return NotImplementedError()
@wrap(['space'])
def headers_sent(space):
""" Checks if or where headers have been sent"""
return space.wrap(space.ec.interpreter.any_output)
interp.warn("session_name() expects "
"parameter 1 to be string, resource given")
return space.w_Null
if name == '':
interp.warn("session_name(): session.name "
"cannot be a numeric or empty '%s'" % name)
return space.wrap(act)
if name != '\0':
interp.session.name = name
interp.config.set_ini_w('session.name', space.wrap(name))
return space.wrap(act)
@wrap(['space', Optional(BoolArg(None))])
def session_regenerate_id(space, delete_old_session=False):
"""Update the current session id with a newly generated one"""
if space.ec.interpreter.session.is_active():
space.ec.interpreter.session.create_id()
return space.w_True
return space.w_False
def session_register_shutdown():
"""Session shutdown function"""
pass
# removed in 5.4
def session_register():
from rpython.rlib import rpath
from hippy.builtin import wrap, Optional, BoolArg, StringArg
from hippy.objects.closureobject import W_ClosureObject
from hippy.objects.strobject import W_StringObject
from hippy.objects.base import W_Root
@wrap(['interp', W_Root, Optional(BoolArg()), Optional(BoolArg())],
error=False)
def spl_autoload_register(interp, w_autoload, throw=True, prepend=False):
autoload_func = interp.space.get_callback('spl_autoload_register',
0, w_autoload)
if autoload_func is None:
if throw:
interp.fatal("XXX spl_autoload_register(throw=True): implement me!")
return interp.space.w_False
#
pair = (w_autoload, autoload_func)
if prepend:
interp.autoload_stack.insert(0, pair)
else:
interp.autoload_stack.append(pair)
return interp.space.w_True
@wrap(['interp', W_Root], error=False)
def spl_autoload_unregister(interp, w_autoload):
# I'll go with space.eq_w() to compare with already-registered entries
for i in range(len(interp.autoload_stack)):
w_autoload1, _ = interp.autoload_stack[i]