def maywarn(err, repo_type='Mercurial'):
if not err:
return
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("version")
log.WARNING('Errors getting %s information: %s' % (repo_type, err))
from rpython.rtyper.lltypesystem.lloperation import LL_OPERATIONS
from rpython.tool.ansi_print import AnsiLogger
from rpython.translator.backendopt import graphanalyze
log = AnsiLogger("canraise")
class RaiseAnalyzer(graphanalyze.BoolGraphAnalyzer):
ignore_exact_class = None
def do_ignore_memory_error(self):
self.ignore_exact_class = MemoryError
def analyze_simple_operation(self, op, graphinfo):
try:
canraise = LL_OPERATIONS[op.opname].canraise
return bool(canraise) and canraise != (self.ignore_exact_class,)
except KeyError:
log.WARNING("Unknown operation: %s" % op.opname)
return True
def analyze_external_call(self, fnobj, seen=None):
return getattr(fnobj, 'canraise', True)
analyze_exceptblock = None # don't call this
def analyze_exceptblock_in_graph(self, graph, block, seen=None):
if self.ignore_exact_class is not None:
from rpython.translator.backendopt.ssa import DataFlowFamilyBuilder
dff = DataFlowFamilyBuilder(graph)
variable_families = dff.get_variable_families()
The Translator is a glue class putting together the various pieces of the
translation-related code. It can be used for interactive testing of the
translator; see pypy/bin/translatorshell.py.
"""
import sys
import types
from rpython.translator import simplify
from rpython.flowspace.model import FunctionGraph, checkgraph, Block
from rpython.flowspace.objspace import build_flow
from rpython.tool.ansi_print import AnsiLogger
from rpython.tool.sourcetools import nice_repr_for_func
from rpython.config.translationoption import get_platform
log = AnsiLogger("flowgraph")
class TranslationContext(object):
FLOWING_FLAGS = {
'verbose': False,
'list_comprehension_operations': False, # True, - not super-tested
}
def __init__(self, config=None, **flowing_flags):
if config is None:
from rpython.config.translationoption import get_combined_translation_config
config = get_combined_translation_config(translating=True)
# ZZZ should go away in the end
for attr in ['verbose', 'list_comprehension_operations']:
if attr in flowing_flags:
""" Module for keeping detailed information about
times of certain driver parts
"""
import time
import py
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("Timer")
class Timer(object):
def __init__(self, timer=time.time):
self.events = []
self.next_even = None
self.timer = timer
self.t0 = None
def start_event(self, event):
now = self.timer()
if self.t0 is None:
self.t0 = now
self.next_event = event
self.start_time = now
def end_event(self, event):
assert self.next_event == event
now = self.timer()
self.events.append((event, now - self.start_time))
self.next_event = None
self.tk = now
def create_log():
"""Make and return a log for the sandbox to use, if needed."""
from rpython.tool.ansi_print import AnsiLogger
return AnsiLogger("sandlib")
#! /usr/bin/env python
# Run this script to rebuild all caches from the *.ctc.py files.
import os, sys
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), '..', '..')))
import py
_dirpath = os.path.dirname(__file__) or os.curdir
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("ctypes_config_cache")
def rebuild_one(name):
filename = os.path.join(_dirpath, name)
d = {'__file__': filename}
path = sys.path[:]
try:
sys.path.insert(0, _dirpath)
execfile(filename, d)
finally:
sys.path[:] = path
def try_rebuild():
size = 32 if sys.maxint <= 2**32 else 64
# remove the files '_*_size_.py'
left = {}
for p in os.listdir(_dirpath):
if p.startswith('_') and (p.endswith('_%s_.py' % size) or
from rpython.translator.translator import TranslationContext
from rpython.translator.tool.taskengine import SimpleTaskEngine
from rpython.translator.goal import query
from rpython.translator.goal.timing import Timer
from rpython.annotator.listdef import s_list_of_strings
from rpython.annotator import policy as annpolicy
from rpython.tool.udir import udir
from rpython.rlib.debug import debug_start, debug_print, debug_stop
from rpython.rlib.entrypoint import secondary_entrypoints,\
annotated_jit_entrypoints
import py
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("translation")
def taskdef(deps,
title,
new_state=None,
expected_states=[],
idemp=False,
earlycheck=None):
def decorator(taskfunc):
taskfunc.task_deps = deps
taskfunc.task_title = title
taskfunc.task_newstate = None
taskfunc.task_expected_states = expected_states
taskfunc.task_idempotent = idemp
taskfunc.task_earlycheck = earlycheck
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("gctransform")
"""
Utilities to manipulate graphs (vertices and edges, not control flow graphs).
Convention:
'vertices' is a set of vertices (or a dict with vertices as keys);
'edges' is a dict mapping vertices to a list of edges with its source.
Note that we can usually use 'edges' as the set of 'vertices' too.
"""
from rpython.tool.ansi_print import AnsiLogger
from rpython.tool.identity_dict import identity_dict
log = AnsiLogger('graphlib')
class Edge:
def __init__(self, source, target):
self.source = source
self.target = target
def __repr__(self):
return '%r -> %r' % (self.source, self.target)
def make_edge_dict(edge_list):
"Put a list of edges in the official dict format."
edges = {}
for edge in edge_list:
edges.setdefault(edge.source, []).append(edge)
edges.setdefault(edge.target, [])
return edges
from rpython.rtyper.lltypesystem import lltype
from rpython.rtyper.rmodel import inputconst
from rpython.tool.ansi_print import AnsiLogger
from rpython.translator.simplify import get_graph
log = AnsiLogger("backendopt")
def graph_operations(graph):
for block in graph.iterblocks():
for op in block.operations:
yield op
def all_operations(graphs):
for graph in graphs:
for block in graph.iterblocks():
for op in block.operations:
yield op
def annotate(translator, func, result, args):
args = [arg.concretetype for arg in args]
graph = translator.rtyper.annotate_helper(func, args)
fptr = lltype.functionptr(lltype.FuncType(args, result.concretetype),
func.__name__,
graph=graph)
c = inputconst(lltype.typeOf(fptr), fptr)
return c
return (isinstance(other, DummyValueBuilder)
and self.rtyper is other.rtyper and self.TYPE == other.TYPE)
def __ne__(self, other):
return not (self == other)
@property
def ll_dummy_value(self):
TYPE = self.TYPE
try:
return self.rtyper.cache_dummy_values[TYPE]
except KeyError:
# generate a dummy ptr to an immortal placeholder struct/array
if TYPE._is_varsize():
p = lltype.malloc(TYPE, 1, immortal=True)
else:
p = lltype.malloc(TYPE, immortal=True)
self.rtyper.cache_dummy_values[TYPE] = p
return p
# logging/warning
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("rtyper")
def warning(msg):
log.WARNING(msg)
from rpython.translator.backendopt import graphanalyze
from rpython.rtyper.lltypesystem import lltype
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("finalizer")
class FinalizerError(Exception):
"""__del__() is used for lightweight RPython destructors,
but the FinalizerAnalyzer found that it is not lightweight.
The set of allowed operations is restrictive for a good reason
- it's better to be safe. Specifically disallowed operations:
* anything that escapes self
* anything that can allocate
"""
class FinalizerAnalyzer(graphanalyze.BoolGraphAnalyzer):
""" Analyzer that determines whether a finalizer is lightweight enough
so it can be called without all the complicated logic in the garbage
collector.
"""
ok_operations = ['ptr_nonzero', 'ptr_eq', 'ptr_ne', 'free', 'same_as',
'direct_ptradd', 'force_cast', 'track_alloc_stop',
'raw_free', 'adr_eq', 'adr_ne',
'debug_print']
def analyze_light_finalizer(self, graph):
if getattr(graph.func, '_must_be_light_finalizer_', False):
self._must_be_light = graph
from rpython.flowspace.model import (FunctionGraph, Constant, Variable)
from rpython.rlib import rstackovf
from rpython.rlib.objectmodel import (ComputedIntSymbolic, CDefinedIntSymbolic,
Symbolic)
# intmask is used in an exec'd code block
from rpython.rlib.rarithmetic import (ovfcheck, is_valid_int, intmask,
r_uint, r_longlong, r_ulonglong, r_longlonglong)
from rpython.rtyper.lltypesystem import lltype, llmemory, lloperation, llheap
from rpython.rtyper import rclass
from rpython.tool.ansi_print import AnsiLogger
# by default this logger's output is disabled.
# e.g. tests can then switch on logging to get more help
# for failing tests
log = AnsiLogger('llinterp')
log.output_disabled = True
class LLException(Exception):
def __init__(self, *args):
"NOT_RPYTHON"
Exception.__init__(self, *args)
def __str__(self):
etype = self.args[0]
#evalue = self.args[1]
if len(self.args) > 2:
f = cStringIO.StringIO()
original_type, original_value, original_tb = self.args[2]
traceback.print_exception(original_type, original_value, original_tb,
from rpython.jit.metainterp import history
from rpython.tool.udir import udir
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger('jitcodewriter')
class JitPolicy(object):
def __init__(self, jithookiface=None):
self.unsafe_loopy_graphs = set()
self.supports_floats = False
self.supports_longlong = False
self.supports_singlefloats = False
self.jithookiface = jithookiface
def set_supports_floats(self, flag):
self.supports_floats = flag
def set_supports_longlong(self, flag):
self.supports_longlong = flag
def set_supports_singlefloats(self, flag):
self.supports_singlefloats = flag
def dump_unsafe_loops(self):
f = udir.join("unsafe-loops.txt").open('w')
strs = [str(graph) for graph in self.unsafe_loopy_graphs]
strs.sort()
for graph in strs:
print >> f, graph
f.close()
from rpython.rlib import rmarshal, types
from rpython.rlib.signature import signature
# ____________________________________________________________
#
# Sandboxing code generator for external functions
#
from rpython.rlib import rposix
from rpython.rtyper.lltypesystem import lltype, rffi
from rpython.rtyper.llannotation import lltype_to_annotation
from rpython.rtyper.annlowlevel import MixLevelHelperAnnotator
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("sandbox")
# a version of os.read() and os.write() that are not mangled
# by the sandboxing mechanism
ll_read_not_sandboxed = rposix.external('read',
[rffi.INT, rffi.CCHARP, rffi.SIZE_T],
rffi.SIZE_T,
sandboxsafe=True)
ll_write_not_sandboxed = rposix.external('write',
[rffi.INT, rffi.CCHARP, rffi.SIZE_T],
rffi.SIZE_T,
sandboxsafe=True)
@signature(types.int(),
from contextlib import contextmanager
from rpython.tool.ansi_print import AnsiLogger
from rpython.tool.pairtype import pair
from rpython.tool.error import (format_blocked_annotation_error, gather_error,
source_lines)
from rpython.flowspace.model import Variable, Constant, checkgraph
from rpython.translator import simplify, transform
from rpython.annotator import model as annmodel, signature
from rpython.annotator.model import (typeof, s_ImpossibleValue, SomeInstance,
intersection, difference)
from rpython.annotator.bookkeeper import Bookkeeper
from rpython.rtyper.normalizecalls import perform_normalizations
from collections import deque
log = AnsiLogger("annrpython")
class ShuffleDict(object):
def __init__(self):
self._d = {}
self.keys = deque()
def __setitem__(self, k, v):
if k in self._d:
self._d[k] = v
else:
self._d[k] = v
self.keys.append(k)
def __getitem__(self, k):
"""Platform-specific support for compiling/executing C sources."""
import py, os, sys
from rpython.tool.runsubprocess import run_subprocess as _run_subprocess
from rpython.tool.udir import udir
from rpython.tool.version import rpythonroot
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("platform")
class CompilationError(Exception):
def __init__(self, out, err):
self.out = out.replace('\r\n', '\n')
self.err = err.replace('\r\n', '\n')
def __repr__(self):
if self.err:
attr = 'err'
else:
attr = 'out'
text = getattr(self, attr).replace('\n', '\n\t')
return 'CompilationError(%s="""\n\t%s""")' % (attr, text)
__str__ = __repr__
class ExecutionResult(object):
def __init__(self, returncode, out, err):
self.returncode = returncode
progress = False
for dst in dest2src.keys():
if dst not in srccount:
src, typename = dest2src.pop(dst)
yield '%s = %s;' % (dst, src)
srccount[src] -= 1
if not srccount[src]:
del srccount[src]
progress = True
if not progress:
# we are left with only pure disjoint cycles; break them
while dest2src:
dst, (src, typename) = dest2src.popitem()
assert srccount[dst] == 1
startingpoint = dst
tmpdecl = cdecl(typename, 'tmp')
code = ['{ %s = %s;' % (tmpdecl, dst)]
while src != startingpoint:
code.append('%s = %s;' % (dst, src))
dst = src
src, typename = dest2src.pop(dst)
assert srccount[dst] == 1
code.append('%s = tmp; }' % (dst, ))
yield ' '.join(code)
# logging
from rpython.tool.ansi_print import AnsiLogger
log = AnsiLogger("c")
