Did I find the right examples for you? yes no

All Samples(406)  |  Call(314)  |  Derive(0)  |  Import(92)

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/translator/simplify.py   plexnet(Download)
def get_graph(arg, translator):
    from pypy.translator.translator import graphof
    if isinstance(arg, Variable):
        return None
    f = arg.value
    try:
        callable = funcobj._callable
        return graphof(translator, callable)
    except (AttributeError, KeyError, AssertionError):
        return None

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/translator/jvm/prebuiltnodes.py   plexnet(Download)
from pypy.translator.translator import graphof
 
# ___________________________________________________________________________
 
HELPERS = {}
    helpers = {}
    for func in HELPERS.keys():
        graph = graphof(translator, func)
        helpers[func.func_name] = db.pending_function(graph)
 

src/s/y/Sypy-HEAD/translator/jvm/prebuiltnodes.py   Sypy(Download)
from pypy.translator.translator import graphof
 
# ___________________________________________________________________________
 
HELPERS = {}
    helpers = {}
    for func in HELPERS.keys():
        graph = graphof(translator, func)
        helpers[func.func_name] = db.pending_function(graph)
 

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/translator/driver.py   plexnet(Download)
import sys, os
import os.path
import shutil
 
from pypy.translator.translator import TranslationContext, graphof

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/rpython/test/test_llinterp.py   plexnet(Download)
from pypy.rpython.llinterp import LLInterpreter, LLException, log
from pypy.rpython.rmodel import inputconst
from pypy.translator.translator import TranslationContext, graphof
from pypy.rpython.rint import signed_repr
from pypy.rpython.lltypesystem import rstr, lltype
    annotator.build_types(bb, [int])
    t.buildrtyper(type_system="ootype").specialize()
    graph = graphof(t, bb)
    interp = LLInterpreter(t.rtyper)
    res = interp.eval_graph(graph, [1])
    t.buildrtyper().specialize()
    etrafo = exceptiontransform.ExceptionTransformer(t)
    etrafo.create_exception_handling(graphof(t, f1))
    etrafo.create_exception_handling(graphof(t, g2))
    etrafo.create_exception_handling(graphof(t, g3))

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/rlib/test/test_objectmodel.py   plexnet(Download)
import py
from pypy.rlib.objectmodel import *
from pypy.translator.translator import TranslationContext, graphof
from pypy.rpython.test.tool import BaseRtypingTest, LLRtypeMixin, OORtypeMixin
from pypy.conftest import option
    a.build_types(test_r_dict, [])
    #t.view()
    graph = graphof(t, strange_key_eq)
    assert a.binding(graph.getargs()[0]).knowntype == str
    assert a.binding(graph.getargs()[1]).knowntype == str
    graph = graphof(t, strange_key_hash)
    Strange_def = a.bookkeeper.getuniqueclassdef(Strange)
 
    graph = graphof(t, strange_key_eq)
    assert a.binding(graph.getargs()[0]).knowntype == Strange_def
    assert a.binding(graph.getargs()[1]).knowntype == str
    assert a.binding(graph.getargs()[2]).knowntype == str
    graph = graphof(t, strange_key_hash)

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/translator/backendopt/test/test_inline.py   plexnet(Download)
from pypy.translator.backendopt.inline import instrument_inline_candidates
from pypy.translator.backendopt.checkvirtual import check_virtual_methods
from pypy.translator.translator import TranslationContext, graphof
from pypy.rpython.llinterp import LLInterpreter
from pypy.rpython.test.tool import LLRtypeMixin, OORtypeMixin
            t.view()
        raise_analyzer = canraise.RaiseAnalyzer(t)
        inliner = Inliner(t, graphof(t, in_func), func,
                          t.rtyper.lltype_to_classdef_mapping(),
                          inline_guarded_calls,
        def eval_func(args):
            return interp.eval_graph(graphof(t, entry), args)
        if graph:
            return eval_func, graphof(t, func)
        return eval_func
        def eval_func(args):
            return interp.eval_graph(graphof(t, func), args)
        return eval_func, t
 
 

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/rpython/test/test_normalizecalls.py   plexnet(Download)
import py
from pypy.annotation import model as annmodel
from pypy.translator.translator import TranslationContext, graphof
from pypy.rpython.llinterp import LLInterpreter
from pypy.rpython.test.test_llinterp import interpret
 
        translator = self.rtype(g, [int], annmodel.s_None)
        f1graph = graphof(translator, f1)
        f2graph = graphof(translator, f2)
        s_l1 = translator.annotator.binding(f1graph.getargs()[0])
 
        translator = self.rtype(g, [int], annmodel.s_None)
        f1graph = graphof(translator, f1)
        f2graph = graphof(translator, f2)
        assert len(f1graph.getargs()) == 2

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/translator/backendopt/test/test_support.py   plexnet(Download)
from pypy.translator.unsimplify import varoftype
from pypy.translator.translator import TranslationContext, graphof
from pypy.translator.backendopt.support import \
     needs_conservative_livevar_calculation, split_block_with_keepalive, \
     find_loop_blocks, find_backedges, compute_reachability
    t.buildannotator().build_types(f, [int])
    t.buildrtyper().specialize()
    graph = graphof(t, f)
    backedges = find_backedges(graph)
    assert len(backedges) == 2
    t.buildannotator().build_types(f, [int])
    t.buildrtyper().specialize()
    graph = graphof(t, f)
    loop_blocks = find_loop_blocks(graph)
    assert len(loop_blocks) == 4
    t.buildannotator().build_types(f, [int])
    t.buildrtyper().specialize()
    graph = graphof(t, f)
    backedges = find_backedges(graph)
    assert backedges == []
    t.buildannotator().build_types(f, [int])
    t.buildrtyper().specialize()
    graph = graphof(t, f)
    backedges = find_backedges(graph)
    assert backedges == []

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/translator/backendopt/test/test_mallocprediction.py   plexnet(Download)
import py
from pypy.translator.translator import TranslationContext
from pypy.translator.backendopt import inline
from pypy.translator.backendopt.all import backend_optimizations
from pypy.translator.translator import TranslationContext, graphof
def rtype(fn, signature):
    t = TranslationContext()
    t.buildannotator().build_types(fn, signature)
    t.buildrtyper().specialize()
    graph = graphof(t, fn)
    assert caller_candidates == {graph: True}
    assert len(callgraph) == 1
    ggraph = graphof(t, g)
    assert callgraph == {graph: {ggraph: True}}
 
    assert caller_candidates == {graph: True}
    assert len(callgraph) == 1
    g1graph = graphof(t, g1)
    g2graph = graphof(t, g2)
    assert callgraph == {graph: {g1graph: True}}

  1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9  Next