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")