@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]