def _run_eval_string(source, filename, space, eval):
if eval:
cmd = 'eval'
else:
cmd = 'exec'
try:
if space is None:
from pypy.objspace.std.objspace import StdObjSpace
space = StdObjSpace()
pycode = compilecode(space, source, filename or '<string>', cmd)
mainmodule = ensure__main__(space)
w_globals = mainmodule.w_dict
space.setitem(w_globals, space.newtext('__builtins__'), space.builtin)
if filename is not None:
space.setitem(w_globals, space.newtext('__file__'), space.newtext(filename))
retval = pycode.exec_code(space, w_globals, w_globals)
if eval:
return retval
else:
return
except OperationError as operationerr:
operationerr.record_interpreter_traceback()
raise
def __init__(self, *args, **kwds):
StdObjSpace.__init__(self, *args, **kwds)
w_dict = self.newdict()
self.setitem(w_dict, self.wrap("__doc__"), self.wrap("""\
Exception that is raised when an operation revealing information on a tainted
object is performed."""))
self.w_TaintError = self.call_function(
self.w_type,
self.wrap("TaintError"),
self.newtuple([self.w_Exception]),
w_dict
)
w___pypy__ = self.getbuiltinmodule("__pypy__")
self.setattr(w___pypy__, self.wrap('taint'),
self.wrap(app_taint))
self.setattr(w___pypy__, self.wrap('is_tainted'),
self.wrap(app_is_tainted))
self.setattr(w___pypy__, self.wrap('untaint'),
self.wrap(app_untaint))
self.w_fn_taint_atomic_function = self.wrap(app_taint_atomic_function)
self.setattr(w___pypy__, self.wrap('taint_atomic'),
self.wrap(app_taint_atomic))
self.setattr(w___pypy__, self.wrap('TaintError'),
self.w_TaintError)
self.setattr(w___pypy__, self.wrap('_taint_debug'),
self.wrap(app_taint_debug))
self.setattr(w___pypy__, self.wrap('_taint_look'),
self.wrap(app_taint_look))
patch_space_in_place(self, 'taint', proxymaker)
# XXX may leak info, perfomance hit, what about taint bombs?
from pypy.objspace.std.typeobject import W_TypeObject
def taint_lookup(w_obj, name):
if isinstance(w_obj, W_Tainted):
w_obj = w_obj.w_obj
w_type = self.type(w_obj)
assert isinstance(w_type, W_TypeObject)
return w_type.lookup(name)
def taint_lookup_in_type_where(w_obj, name):
if isinstance(w_obj, W_Tainted):
w_type = w_obj.w_obj
else:
w_type = w_obj
assert isinstance(w_type, W_TypeObject)
return w_type.lookup_where(name)
self.lookup = taint_lookup
self.lookup_in_type_where = taint_lookup_in_type_where
def __init__(self, *args, **kwds):
StdObjSpace.__init__(self, *args, **kwds)
w_dict = self.newdict()
self.setitem(
w_dict, self.wrap("__doc__"),
self.wrap("""\
Exception that is raised when an operation revealing information on a tainted
object is performed."""))
self.w_TaintError = self.call_function(
self.w_type, self.wrap("TaintError"),
self.newtuple([self.w_Exception]), w_dict)
w___pypy__ = self.getbuiltinmodule("__pypy__")
self.setattr(w___pypy__, self.wrap('taint'), self.wrap(app_taint))
self.setattr(w___pypy__, self.wrap('is_tainted'),
self.wrap(app_is_tainted))
self.setattr(w___pypy__, self.wrap('untaint'), self.wrap(app_untaint))
self.w_fn_taint_atomic_function = self.wrap(app_taint_atomic_function)
self.setattr(w___pypy__, self.wrap('taint_atomic'),
self.wrap(app_taint_atomic))
self.setattr(w___pypy__, self.wrap('TaintError'), self.w_TaintError)
self.setattr(w___pypy__, self.wrap('_taint_debug'),
self.wrap(app_taint_debug))
self.setattr(w___pypy__, self.wrap('_taint_look'),
self.wrap(app_taint_look))
patch_space_in_place(self, 'taint', proxymaker)
# XXX may leak info, perfomance hit, what about taint bombs?
from pypy.objspace.std.typeobject import W_TypeObject
def taint_lookup(w_obj, name):
if isinstance(w_obj, W_Tainted):
w_obj = w_obj.w_obj
w_type = self.type(w_obj)
assert isinstance(w_type, W_TypeObject)
return w_type.lookup(name)
def taint_lookup_in_type_where(w_obj, name):
if isinstance(w_obj, W_Tainted):
w_type = w_obj.w_obj
else:
w_type = w_obj
assert isinstance(w_type, W_TypeObject)
return w_type.lookup_where(name)
self.lookup = taint_lookup
self.lookup_in_type_where = taint_lookup_in_type_where
def setup_class(cls):
init_extmodule_code()
conf = get_pypy_config()
conf.objspace.extmodules = 'testext.extmod'
old_sys_path[:] = sys.path[:]
sys.path.insert(0, str(udir))
space = StdObjSpace(conf)
cls.space = space
def wrap(self, x):
w_res = StdObjSpace.wrap(self, x)
self.dumper.dump_returned_wrapped(' wrap', w_res)
return w_res
def startup(self):
StdObjSpace.startup(self)
self.dumper.open()
def finish(self):
self.dumper.close()
StdObjSpace.finish(self)
def __init__(self, *args, **kwds):
self.dumper = Dumper(self)
StdObjSpace.__init__(self, *args, **kwds)
patch_space_in_place(self, 'dump', proxymaker)
def _freeze_(self):
# remove strange things from the caches of self.dumper
# before we annotate
self.dumper.close()
return StdObjSpace._freeze_(self)
def make_objspace(config):
from pypy.objspace.std.objspace import StdObjSpace
return StdObjSpace(config)
def get_entry_point(self, config):
global space1, space2, w_entry_point_1, w_entry_point_2
space1 = StdObjSpace(config)
space2 = StdObjSpace(config)
space1.setattr(space1.getbuiltinmodule('sys'),
space1.wrap('pypy_space'),
space1.wrap(1))
space2.setattr(space2.getbuiltinmodule('sys'),
space2.wrap('pypy_space'),
space2.wrap(2))
# manually imports app_main.py
filename = os.path.join(this_dir, 'app_main.py')
w_dict = space1.newdict()
space1.exec_(open(filename).read(), w_dict, w_dict)
w_entry_point_1 = space1.getitem(w_dict, space1.wrap('entry_point'))
w_dict = space2.newdict()
space2.exec_(open(filename).read(), w_dict, w_dict)
w_entry_point_2 = space2.getitem(w_dict, space2.wrap('entry_point'))
# sanity-check: call the entry point
res = entry_point(["pypy", "app_basic_example.py"])
assert res == 0
res = entry_point(["pypy", "--space2", "app_basic_example.py"])
assert res == 0
return entry_point, None, PyPyAnnotatorPolicy()
def get_entry_point(self, config):
global space1, space2, w_entry_point_1, w_entry_point_2
space1 = StdObjSpace(config)
space2 = StdObjSpace(config)
space1.setattr(space1.getbuiltinmodule("sys"), space1.wrap("pypy_space"), space1.wrap(1))
space2.setattr(space2.getbuiltinmodule("sys"), space2.wrap("pypy_space"), space2.wrap(2))
# manually imports app_main.py
filename = os.path.join(this_dir, "app_main.py")
w_dict = space1.newdict()
space1.exec_(open(filename).read(), w_dict, w_dict)
w_entry_point_1 = space1.getitem(w_dict, space1.wrap("entry_point"))
w_dict = space2.newdict()
space2.exec_(open(filename).read(), w_dict, w_dict)
w_entry_point_2 = space2.getitem(w_dict, space2.wrap("entry_point"))
return entry_point, None, PyPyAnnotatorPolicy()
w_typ.getdict()
print "*%s*" % typedef.name
for typedef in space.model.pythontypes:
w_typ = getattr(space, 'w_' + typedef.name)
w_typ.getdict()
print "*%s*" % typedef.name
#print w_typ.dict_w.keys()
space.builtin.get('file').getdict()
space.appexec([], """():
try:
raise ValueError
except ValueError:
pass
exec 'pass'
""")
# freeze caches?
print "cache build finished"
if __name__ == '__main__':
import autopath
from pypy.objspace.std.objspace import StdObjSpace
space = StdObjSpace()
buildcache(space)
def wrap(self, x):
w_res = StdObjSpace.wrap(self, x)
self.dumper.dump_returned_wrapped(' wrap', w_res)
return w_res
def finish(self):
self.dumper.close()
StdObjSpace.finish(self)
def startup(self):
StdObjSpace.startup(self)
self.dumper.open()
def _freeze_(self):
# remove strange things from the caches of self.dumper
# before we annotate
self.dumper.close()
return StdObjSpace._freeze_(self)
def __init__(self, *args, **kwds):
self.dumper = Dumper(self)
StdObjSpace.__init__(self, *args, **kwds)
patch_space_in_place(self, 'dump', proxymaker)
def run_module(module_name, args, space=None):
"""Implements PEP 338 'Executing modules as scripts', overwriting
sys.argv[1:] using `args` and executing the module `module_name`.
sys.argv[0] always is `module_name`.
Delegates the real work to the runpy module provided as the reference
implementation.
"""
if space is None:
from pypy.objspace.std.objspace import StdObjSpace
space = StdObjSpace()
argv = [module_name]
if args is not None:
argv.extend(args)
space.setitem(space.sys.w_dict, space.newtext('argv'), space.wrap(argv))
w_import = space.builtin.get('__import__')
runpy = space.call_function(w_import, space.newtext('runpy'))
w_run_module = space.getitem(runpy.w_dict, space.newtext('run_module'))
return space.call_function(w_run_module, space.newtext(module_name),
space.w_None, space.newtext('__main__'),
space.w_True)
def get_entry_point(self, config):
global space1, space2, w_entry_point_1, w_entry_point_2
space1 = StdObjSpace(config)
space2 = StdObjSpace(config)
space1.setattr(space1.getbuiltinmodule('sys'),
space1.wrap('pypy_space'),
space1.wrap(1))
space2.setattr(space2.getbuiltinmodule('sys'),
space2.wrap('pypy_space'),
space2.wrap(2))
# manually imports app_main.py
filename = os.path.join(this_dir, 'app_main.py')
w_dict = space1.newdict()
space1.exec_(open(filename).read(), w_dict, w_dict)
w_entry_point_1 = space1.getitem(w_dict, space1.wrap('entry_point'))
w_dict = space2.newdict()
space2.exec_(open(filename).read(), w_dict, w_dict)
w_entry_point_2 = space2.getitem(w_dict, space2.wrap('entry_point'))
return entry_point, None, PyPyAnnotatorPolicy()
