def test_builder():
def add(space, m, n):
return space.newint(m + n)
signature = ['space', int, int]
builder = BuiltinFunctionBuilder(signature, add)
assert builder.make_source() == """\
@unroll_safe
def php_add(interp, args_w, w_this, thisclass):
nb_args = len(args_w)
space = interp.space
if nb_args != 2:
arguments_exactly(interp, fname, 2, nb_args, error_handler)
nb_args = 2 # constant below
arg0 = space
w_arg = args_w[0].deref_unique()
try:
arg1 = w_arg.as_int_arg(space)
except ConvertError:
raise argument_not(interp, "long", fname, 1, w_arg.tp, error_handler)
w_arg = args_w[1].deref_unique()
try:
arg2 = w_arg.as_int_arg(space)
except ConvertError:
raise argument_not(interp, "long", fname, 2, w_arg.tp, error_handler)
return (arg0, arg1, arg2)
"""
def incr(space, a, increment=1):
return space.newint(a + increment)
signature = ['space', 'reference', Optional(int)]
builder = BuiltinFunctionBuilder(signature, incr)
expected = """\
@unroll_safe
def php_incr(interp, args_w, w_this, thisclass):
nb_args = len(args_w)
space = interp.space
if nb_args < 1:
warn_at_least(space, fname, 1, nb_args)
if nb_args > 2:
warn_at_most(space, fname, 2, nb_args)
arg2 = default2
arg0 = space
w_arg = args_w[0]
arg1 = check_reference(space, w_arg, fname)
if nb_args > 1:
w_arg = args_w[1].deref_unique()
try:
arg2 = w_arg.as_int_arg(space)
except ConvertError:
raise argument_not(interp, "long", fname, 2, w_arg.tp, error_handler)
return (arg0, arg1, arg2)
"""
assert builder.make_source() == expected
def foo(space, fname, ctx=None):
pass
signature = ['space', FilenameArg(False), Optional(Nullable(StreamContextArg(False)))]
builder = BuiltinFunctionBuilder(signature, foo)
assert builder.make_source() == """\
def test_signature():
sig = BuiltinSignature(['space', int, int])
assert sig.php_indices == [0, 0, 1]
sig = BuiltinSignature(['space', 'reference', Optional(int)])
assert sig.php_indices == [0, 0, 1]
assert sig.min_args == 1
assert sig.max_args == 2
with py.test.raises(ValueError) as excinfo:
sig = BuiltinSignature([Optional(int), 'args_w'])
assert excinfo.value.args[0].startswith("Cannot combine")
return interp.space.wrap(filename)
@wrap_method(['interp', ThisUnwrapper(W_ReflectionClass)],
name='ReflectionClass::getStaticProperties')
def reflection_class_get_static_properties(interp, this):
static_property_values = []
for k, v in this.refl_klass.properties.items():
if v.is_static():
static_property_values.append(v.value)
return interp.space.new_array_from_list(static_property_values)
@wrap_method(
['interp', ThisUnwrapper(W_ReflectionClass),
Optional(int)],
name='ReflectionClass::getProperties')
def reflection_class_get_properties(interp, this, flags=0):
properties = []
for name in this.refl_klass.properties.keys():
reflection_prop = k_ReflectionProperty.call_args(
interp,
[interp.space.wrap(this.refl_klass.name),
interp.space.wrap(name)])
assert isinstance(reflection_prop, W_ReflectionProperty)
prop_flags = reflection_prop.flags
if flags == 0:
properties.append(reflection_prop)
elif flags & prop_flags:
properties.append(reflection_prop)
def _get_path(interp, this):
return this.path
def _set_handle(interp, this, w_value):
assert isinstance(w_value, W_DirResource)
this.handle = w_value
def _get_handle(interp, this):
return this.handle
@wrap(['interp', str, Optional(StreamContextArg(None))])
def dir(interp, directory, w_ctx=None):
space = interp.space
if w_ctx:
if not interp.space.is_resource(w_ctx):
interp.warn("dir() expects parameter 2 to be resource, %s given" %
interp.space.get_type_name(w_ctx.tp).lower())
return interp.space.w_Null
if directory == '':
return interp.space.w_False
if not os.path.isdir(directory):
warn_str = "dir(" + directory + \
"): failed to open dir: No such file or directory"
stream = rzlib.deflateInit(level=level, wbits=encoding)
bytes = rzlib.compress(stream, data)
bytes += rzlib.compress(stream, "", rzlib.Z_FINISH)
rzlib.deflateEnd(stream)
return bytes
def _decode(data, encoding):
stream = rzlib.inflateInit(wbits=encoding)
bytes, finished, unused = rzlib.decompress(stream, data,
rzlib.Z_FINISH)
rzlib.inflateEnd(stream)
return bytes
@wrap(['interp', str, Optional(int), Optional(int)])
def gzdeflate(interp, source, level=-1, encoding=ZLIB_ENCODING_RAW):
res = _encode(source, level, encoding)
return interp.space.wrap(res)
@wrap(['interp', str, Optional(int), Optional(int)])
def gzencode(interp, source, level=-1, encoding=ZLIB_ENCODING_GZIP):
res = _encode(source, level, encoding)
return interp.space.wrap(res)
@wrap(['interp', str, Optional(int), Optional(int)])
def gzcompress(interp, source, level=-1, encoding=ZLIB_ENCODING_DEFLATE):
res = _encode(source, level, encoding)
return interp.space.wrap(res)
return GetterSetter(self.getter, self.setter, self.name, klass,
self.accflags)
class W_ExceptionObject(W_InstanceObject):
def setup(self, interp):
self.traceback = interp.get_traceback()
def get_message(self, interp):
return self.getattr(interp, 'message', k_Exception)
@wrap_method([
'interp',
ThisUnwrapper(W_ExceptionObject),
Optional(str),
Optional(int),
Optional('object')
],
name='Exception::__construct')
def new_exception(interp, this, message='', code=0, w_previous=None):
this.setattr(interp, 'file', interp.space.wrap(this.traceback[0][0]),
k_Exception)
this.setattr(interp, 'message', interp.space.wrap(message), k_Exception)
this.setattr(interp, 'code', interp.space.wrap(code), k_Exception)
if w_previous is None:
w_previous = interp.space.w_Null
elif not k_Exception.is_parent_of(w_previous.klass):
interp.fatal("Wrong parameters for "
"Exception([string $exception [, long $code [, "
"Exception $previous = NULL]]])")
setter = self.setter
return GetterSetter(getter, setter, self.name, klass, self.accflags)
class W_ExceptionObject(W_InstanceObject):
def setup(self, interp):
self.traceback = interp.get_traceback()
def get_message(self, interp):
return self.getattr(interp, 'message', k_Exception)
@wrap_method([
'interp',
ThisUnwrapper(W_ExceptionObject),
Optional(str),
Optional(int),
Optional(Nullable('object'))
],
name='Exception::__construct')
def new_exception(interp, this, message='', code=0, w_previous=None):
space = interp.space
this.setattr(interp, 'file', space.wrap(this.traceback[0][0]), k_Exception)
this.setattr(interp, 'line', space.wrap(this.traceback[0][2]), k_Exception)
this.setattr(interp, 'message', space.wrap(message), k_Exception)
this.setattr(interp, 'code', space.wrap(code), k_Exception)
if w_previous is None:
w_previous = space.w_Null
elif not k_Exception.is_parent_of(w_previous.klass):
interp.fatal("Wrong parameters for "
"Exception([string $exception [, long $code [, "
val = self.space.str_w(w_buffer)
if self.prev is None:
interp.writestr(val, buffer=False)
else:
self.prev.write(val)
self.reset()
return True
def clean(self):
self.reset()
def get_contents(self):
return self.space.newstr(self.buffer.build())
@wrap(['interp', Optional(W_Root), Optional(int), Optional(int)])
def ob_start(interp, w_callback=None, chunk_size=4096, flags=112):
callback = None
name = 'default output handler'
if chunk_size < 0:
chunk_size = 0
if w_callback:
try:
callback = interp.space._get_callback(w_callback)
if isinstance(w_callback, W_StringObject):
name = interp.space.str_w(w_callback)
else:
name = 'Closure::__invoke'
except InvalidCallback as e:
interp.warn("ob_start(): %s" % e.msg)
@k_ReflectionClass.def_method(['interp', 'this'])
def getFileName(interp, this):
filename = rpath.realpath(this.refl_klass.decl.reflection.filename)
return interp.space.wrap(filename)
@k_ReflectionClass.def_method(['interp', 'this'])
def getStaticProperties(interp, this):
static_property_values = []
for k, v in this.refl_klass.properties.items():
if v.is_static():
static_property_values.append(v.value)
return interp.space.new_array_from_list(static_property_values)
@k_ReflectionClass.def_method(['interp', 'this', Optional(int)])
def getProperties(interp, this, flags=0):
properties = []
for name in this.refl_klass.properties.keys():
reflection_prop = k_ReflectionProperty.call_args(
interp, [interp.space.wrap(this.refl_klass.name),
interp.space.wrap(name)])
assert isinstance(reflection_prop, W_ReflectionProperty)
prop_flags = reflection_prop.flags
if flags == 0:
properties.append(reflection_prop)
elif flags & prop_flags:
properties.append(reflection_prop)
return interp.space.new_array_from_list(properties)
return space.w_True
def _fits_in_base(c, base):
if ord('0') <= ord(c) <= ord('9'):
if ord(c) - ord('0') < base:
return True
return False
if ord('a') <= ord(c) <= ord('z'):
if ord(c) - ord('a') < base - 10:
return True
return False
return False
@wrap(['space', W_Root, Optional(LongArg(None))])
def intval(space, w_obj, base=10):
""" Get the integer value of a variable"""
if w_obj.tp == space.tp_array:
if space.arraylen(w_obj) == 0:
return space.wrap(0)
return space.wrap(1)
elif w_obj.tp == space.tp_int:
return w_obj
elif w_obj.tp == space.tp_bool:
return space.as_number(w_obj)
elif w_obj.tp == space.tp_null:
return space.wrap(0)
elif w_obj.tp == space.tp_float:
try:
res = intmask(int(space.float_w(w_obj)))
from hippy.builtin import wrap, Optional
@wrap(['interp', str, Optional(str)], error=False)
def mb_strlen(interp, s, encoding='utf-8'):
encoding = encoding.lower()
if encoding != 'utf-8' and encoding != 'utf8':
interp.warn('mb_strlen(): Unsupported encoding "%s"' % encoding)
return interp.space.w_False
#
# special-case logic to handle UTF-8 the fast way
length = end = len(s)
i = 0
while i < end:
c = s[i]
if ord(c) < 0xc0:
i += 1
elif ord(c) < 0xe0:
length -= 1
i += 2
elif ord(c) < 0xf0:
length -= 2
i += 3
else:
length -= 3
i += 4
return interp.space.wrap(length)
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo), str],
name='SplFileInfo::__construct')
def construct(interp, this, file_name):
this.file_name = file_name
this.path_name = rpath.realpath(file_name)
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo)],
name='SplFileInfo::__toString')
def spl_toString(interp, this):
return interp.space.wrap(this.file_name)
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo), Optional(str)],
name='SplFileInfo::getBasename')
def get_basename(interp, this, suffix=''):
return _basename(interp.space, this.file_name, suffix)
def _extension(interp, filename):
name_split = filename.rsplit('.', 1)
if len(name_split) == 2:
filename, extension = name_split
else:
extension = ''
return interp.space.wrap(extension)
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo)],
(space.wrap("offset"), space.wrap(int(o))),
(space.wrap("timezone_id"), space.wrap(f))
])
))
i += 1
results.append((space.wrap(k), space.new_array_from_pairs(w_arr_x)))
return space.new_array_from_pairs(results)
@wrap_method(['space'], name='DateTimeZone::listAbbreviations',
flags=consts.ACC_STATIC)
def list_abbreviations(space):
return _abbreviations_list(space)
@wrap_method(['space', Optional(LongArg(None)), Optional(StringArg(None))],
name='DateTimeZone::listIdentifiers', flags=consts.ACC_STATIC)
def identifiers_list(space, what=2047, country=None):
return common.timezone_identifiers_list(space, what, country)
@wrap_method(['interp', ThisUnwrapper(W_DateTimeZone), Optional(int), Optional(int)],
name='DateTimeZone::getTransitions', error=False)
def get_transition(interp, this,
timestamp_begin=-sys.maxint - 1,
timestamp_end=sys.maxint):
return common.timezone_transitions_get(
interp, this, timestamp_begin, timestamp_end)
@wrap_method(['interp', ThisUnwrapper(W_DateTimeZone)],
[GetterSetterWrapper(_get_storage, _set_storage, 'storage', consts.ACC_PRIVATE)],
instance_class=W_SplArray,
implements=[k_IteratorAggregate, k_ArrayAccess])
k_ArrayIterator = def_class(
'ArrayIterator',
['__construct', 'offsetExists', 'offsetGet', 'offsetSet', 'offsetUnset',
'append', 'count',
'current', 'next', 'key', 'rewind', 'valid'],
[GetterSetterWrapper(_get_storage, _set_storage, 'storage', consts.ACC_PRIVATE)],
instance_class=W_ArrayIterator,
implements=[k_ArrayAccess, k_Iterator])
@k_ArrayObject.def_method(['interp', 'this', Optional(W_Root), Optional(int),
Optional(str)])
def __construct(interp, this, w_arr=None, flags=0,
iterator_class='ArrayIterator'):
if w_arr is None:
w_arr = interp.space.new_array_from_list([])
if (not isinstance(w_arr, W_InstanceObject) and
not isinstance(w_arr, W_ArrayObject)):
raise interp.throw("Passed variable is not an array or object, using "
"empty array instead", klass=k_InvalidArgumentException)
this.iterator_class = iterator_class
this.w_arr = w_arr
@k_ArrayIterator.def_method(['interp', 'this', Optional(W_Root)])
def __construct(interp, this, w_arr=None):
"""jakis komentarz"""
return space.wrap(w_imagick_res.writeImages(filename, adjoin))
"""
@wrap(['space', ImagickResourceArg(None),int,int])
def thumbnailImage(space, w_imagick_res,columns,rows):
""jakis komentarz""
return space.wrap(w_imagick_res.thumbnailImage(columns,rows))
"""
@wrap(['space', ImagickResourceArg(None), float])
def setImageOpacity(space, w_imagick_res, opacity):
"""jakis komentarz"""
return space.wrap(w_imagick_res.setImageOpacity(opacity))
@wrap(['space', ImagickResourceArg(None), int])
def setImageCompressionQuality(space, w_imagick_res, quality):
"""jakis komentarz"""
return space.wrap(w_imagick_res.setImageCompressionQuality(quality))
@wrap(['space', ImagickResourceArg(None), int, int, int, float, Optional(int)])
def resizeImage(space, w_imagick_res, columns, rows, filter, blur, bestfit=0):
"""jakis komentarz"""
return space.wrap(w_imagick_res.setImageCompressionQuality(columns, rows, filter, blur, bestfit))
import os
import posix
from hippy.builtin import LongArg, wrap, Optional, FilenameArg
from hippy.objects.base import W_Root
from hippy.objects.resources import W_Resource
from hippy.rpwd import getpwnam, getpwuid, initgroups
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import rposix
from rpython.rlib.rarithmetic import intmask
from collections import OrderedDict
@wrap(['space', str, Optional(int)], error=False)
def posix_access(space, fname, mode=0):
""" posix_access - Determine accessibility of a file
mode can be
'POSIX_F_OK': 0,
'POSIX_R_OK': 4,
'POSIX_W_OK': 2,
'POSIX_X_OK': 1,
"""
r = mode & 4 != 0
w = mode & 2 != 0
x = mode & 1 != 0
try:
res = os.path.isfile(fname)
if w:
res &= os.access(fname, os.W_OK)
if r:
res &= os.access(fname, os.R_OK)
if x:
from hippy.builtin import wrap
from hippy.builtin import Optional
from hippy.builtin import BoolArg
from hippy.objects.base import W_Root
from collections import OrderedDict
PHP_WHITESPACE = '\x0b\0'
@wrap(['interp', Optional(W_Root)])
def session_cache_expire(interp, w_new=None):
"""Return current cache expire"""
act = interp.session.cache_expire
space = interp.space
if not w_new:
return space.newint(act)
w_num = space.as_number(w_new)
interp.config.set_ini_w('session.cache_expire', w_num)
n = space.int_w(w_num)
interp.session.cache_expire = n
return space.newint(act)
@wrap(['interp', Optional(str)])
def session_cache_limiter(interp, limiter=None):
"""Get and/or set the current cache limiter"""
act = interp.session.cache_limiter
space = interp.space
if limiter is None:
return space.newstr(act)
if klass is not None:
return klass.constants_w.get(realname, None)
return None
@wrap(['space', str])
def constant(space, constname):
""" Returns the value of a constant"""
w_obj = _lookup_constant(space, constname)
if w_obj is None:
space.ec.warn("constant(): Couldn't find constant %s" % constname)
return space.w_Null
return w_obj
@wrap(['space', str, W_Root, Optional(bool)])
def define(space, name, w_obj, case_insensitive=False):
""" Defines a named constant"""
if name in space.ec.interpreter.constants:
space.ec.notice("Constant %s already defined" % name)
return space.w_False
space.ec.interpreter.constants[name] = w_obj
return space.w_True
@wrap(['space', str])
def defined(space, name):
""" Checks whether a given named constant exists"""
return space.newbool(_lookup_constant(space, name) is not None)
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)
s = StringBuilder(len(arg) + 2)
s.append("'")
for c in arg:
if c == "'":
s.append("'")
s.append("\\")
s.append("'")
s.append("'")
else:
s.append(c)
s.append("'")
return interp.space.wrap(s.build())
@wrap(['interp', str,
Optional('reference'),
Optional('reference')],
error=False,
name='exec')
def exec_(interp, cmd, r_output=None, r_return_var=None):
space = interp.space
if not cmd:
raise ExitFunctionWithError('Cannot execute a blank command')
if r_output is not None:
if not space.is_array(r_output.deref_temp()):
r_output.store(space.new_array_from_list([]))
w_output = r_output.deref_unique()
else:
w_output = None
try:
pfile = create_popen_file(cmd, 'r')
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo), str],
name='SplFileInfo::__construct')
def construct(interp, this, file_name):
this.file_name = file_name
this.path_name = rpath.realpath(file_name)
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo)],
name='SplFileInfo::__toString')
def spl_toString(interp, this):
return interp.space.wrap(this.file_name)
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo), Optional(str)],
name='SplFileInfo::getBasename')
def get_basename(interp, this, suffix=''):
return _basename(interp.space, this.file_name, suffix)
@wrap_method(['interp', ThisUnwrapper(W_SplFileInfo)],
name='SplFileInfo::getExtension')
def get_extension(interp, this):
path = this.file_name
filename = rpath.split(path)[1]
name_split = filename.rsplit('.', 1)
if len(name_split) == 2:
filename, extension = name_split
else:
extension = ''
def dns_get_mx():
""" Alias of getmxrr"""
return NotImplementedError()
def dns_get_record():
""" Fetch DNS Resource Records associated with a hostname"""
return NotImplementedError()
@wrap([
'interp',
StringArg(None),
Optional(int),
Optional('reference'),
Optional('reference'),
Optional(float)
],
error=False)
def fsockopen(interp,
hostname,
port=-1,
w_ref_errno=None,
w_ref_errstr=None,
timeout=-1):
""" Open Internet or Unix domain socket connection"""
space = interp.space
r = urlsplit(hostname)
host = r.host
from hippy.builtin import wrap, Optional
@wrap(['interp', str, str, str, Optional(str), Optional(str)])
def mail(interp, to, topic, content,
extra_headers=None, extra_params=None):
# XXXX dummy
return interp.space.w_True
'__construct', 'rewind', 'valid', 'key', 'current', 'next',
'getInnerIterator', 'beginIteration', 'endIteration',
'callHasChildren', 'callGetChildren', 'beginChildren', 'endChildren',
'nextElement'
],
constants=[
('LEAVES_ONLY', W_IntObject(LEAVES_ONLY)),
('SELF_FIRST', W_IntObject(SELF_FIRST)),
('CHILD_FIRST', W_IntObject(CHILD_FIRST)),
],
implements=[k_OuterIterator],
instance_class=W_RecursiveIteratorIterator)
@k_RecursiveIteratorIterator.def_method(
['interp', 'this', 'object', Optional(int)])
def __construct(interp, this, w_iter, mode=LEAVES_ONLY):
if w_iter.klass.is_iterable:
w_iter = interp.call_method(w_iter, 'getIterator', [])
if (not isinstance(w_iter, W_InstanceObject)
or not w_iter.klass.is_subclass_of_class_or_intf_name(
'RecursiveIterator')):
raise interp.throw(
"An instance of RecursiveIterator or "
"IteratorAggregate creating it is required",
klass=k_InvalidArgumentException)
this.w_iter = w_iter
this.mode = mode
this.in_iteration = False
this.stack = [RII_Node(this.w_iter)]
this.level = 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])
except ValueError:
return space.wrap(-rfloat.INFINITY)
@wrap(['space', float])
def log1p(space, d):
""" Base-10 logarithm"""
if d < 0:
return space.wrap(rfloat.NAN)
try:
return space.wrap(math.log1p(d))
except ValueError:
return space.wrap(-rfloat.INFINITY)
@wrap(['space', float, 'num_args', Optional(float)])
def log(space, x, num_args, b=0.0):
""" Base-10 logarithm"""
if x < 0:
return space.wrap(rfloat.NAN)
try:
if num_args == 2:
if b <= 0:
space.ec.warn("log(): base must be greater than 0")
return space.w_False
return space.wrap(math.log(x) / math.log(b))
return space.wrap(math.log(x))
except ValueError:
return space.wrap(-rfloat.INFINITY)
except ZeroDivisionError:
return space.wrap(rfloat.NAN)
k_ReflectionProperty = def_class('ReflectionProperty', [
'export', '__construct', 'getName', 'getValue', 'setValue',
'getDeclaringClass', "isPublic", "isPrivate", "isProtected", "isStatic",
"isDefault", "getModifiers", "__toString"
], [
GetterSetterWrapper(_get_name, _set_name, 'name', consts.ACC_PUBLIC),
GetterSetterWrapper(_get_class, _set_class, 'class', consts.ACC_PUBLIC)
], [('IS_STATIC', W_IntObject(IS_STATIC)),
('IS_PUBLIC', W_IntObject(IS_PUBLIC)),
('IS_PROTECTED', W_IntObject(IS_PROTECTED)),
('IS_PRIVATE', W_IntObject(IS_PRIVATE))],
instance_class=W_ReflectionProperty)
@k_ReflectionProperty.def_method(
['interp', W_Root, str, Optional(bool)], flags=consts.ACC_STATIC)
def export(interp, w_klass, name, return_string=False):
refl = k_ReflectionProperty.call_args(
interp, [w_klass, interp.space.wrap(name)])
result = refl.get_str()
if return_string:
return interp.space.wrap(result)
else:
interp.writestr(result)
interp.writestr('\n')
return interp.space.w_Null
@k_ReflectionProperty.def_method(['interp', 'this', W_Root, str])
def __construct(interp, this, w_class, property_name):
space = interp.space
from hippy.builtin_klass import k_Iterator
from hippy.builtin import ThisUnwrapper, Optional, wrap_method
from hippy.klass import def_class
from hippy.objects.base import W_Root
from hippy.objects.instanceobject import W_InstanceObject
from hippy import consts
class W_ApplevelArrayIterator(W_InstanceObject):
pass
@wrap_method(
['interp',
ThisUnwrapper(W_ApplevelArrayIterator),
Optional(W_Root)],
name='ArrayIterator::__construct')
def ArrayIterator_construct(interp, this, w_arr=None):
if w_arr is None:
w_arr = interp.space.new_array_from_list([])
this.setattr(interp, "storage", w_arr, k_ArrayIterator)
@wrap_method([], name='ArrayIterator::current')
def ArrayIterator_current():
pass
@wrap_method([], name='ArrayIterator::next')
def ArrayIterator_next():
pass
from hippy.builtin import (wrap_method, Optional, ThisUnwrapper, StringArg,
LongArg, BoolArg, InstanceUnwrapper,
handle_as_exception)
from hippy.klass import def_class
from hippy.builtin_klass import GetterSetterWrapper, k_Exception
from hippy.module.date import timelib
from hippy.module.date import W_DateTime, W_DateTimeZone
from hippy.module.date.dateinterval_klass import W_DateInterval, k_DateInterval
from hippy.module.date import common
@wrap_method([
'interp',
ThisUnwrapper(W_DateTime),
Optional(StringArg()),
Optional(InstanceUnwrapper(W_DateTimeZone, 'DateTimeZone'))
],
name='DateTime::__construct',
error_handler=handle_as_exception)
def construct(interp, this, format_string=None, w_datetimezone=None):
error = common.initialize_date(interp, 'DateTime::__construct', this,
format_string, w_datetimezone)
if error:
raise PHPException(
k_Exception.call_args(interp, [
interp.space.wrap("%s(): %s" %
('DateTime::__construct', error))
]))
""" This module contains various internal php functions
"""
from collections import OrderedDict
from hippy.builtin import wrap, W_Root, Optional
from hippy.klass import W_BoundMethod
from hippy.objects.instanceobject import W_InstanceObject
from hippy.error import VisibilityError
from rpython.rlib import jit
@wrap(['space', W_Root, Optional(bool), Optional('reference')])
def is_callable(space, w_name, syntax_only=False, w_callable_name=None):
assert w_callable_name is None
if syntax_only:
if space.is_str(w_name):
return space.w_True
if space.is_array(w_name):
if space.arraylen(w_name) != 2:
return space.w_False
w_item = space.getitem(w_name, space.wrap(0))
if (not isinstance(w_item, W_InstanceObject)
and not space.is_str(w_item)):
return space.w_False
w_name = space.getitem(w_name, space.wrap(1))
return space.wrap(space.is_str(w_name))
if isinstance(w_name, W_InstanceObject):
return space.w_True
return space.w_False
interp = space.ec.interpreter
w_callable = interp.space.get_callback(None, 0, w_name, False)