1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
from rpython.translator.translator import TranslationContext
from rpython.translator import driver
from rpython.rlib.entrypoint import export_symbol
DEFAULTS = {
'translation.backend': None,
'translation.type_system': None,
'translation.verbose': True,
}
class Translation(object):
def __init__(self, entry_point, argtypes=None, **kwds):
self.driver = driver.TranslationDriver(overrides=DEFAULTS)
self.config = self.driver.config
self.entry_point = export_symbol(entry_point)
self.context = TranslationContext(config=self.config)
policy = kwds.pop('policy', None)
self.update_options(kwds)
self.ensure_setup(argtypes, policy)
# for t.view() to work just after construction
graph = self.context.buildflowgraph(entry_point)
self.context._prebuilt_graphs[entry_point] = graph
def view(self):
self.context.view()
def viewcg(self):
self.context.viewcg()
def ensure_setup(self, argtypes=None, policy=None):
self.driver.setup(self.entry_point, argtypes, policy,
empty_translator=self.context)
self.ann_argtypes = argtypes
self.ann_policy = policy
def update_options(self, kwds):
gc = kwds.pop('gc', None)
if gc:
self.config.translation.gc = gc
self.config.translation.set(**kwds)
def ensure_opt(self, name, value=None, fallback=None):
if value is not None:
self.update_options({name: value})
return value
val = getattr(self.config.translation, name, None)
if fallback is not None and val is None:
self.update_options({name: fallback})
return fallback
if val is not None:
return val
raise Exception(
"the %r option should have been specified at this point" % name)
def ensure_type_system(self, type_system=None):
if self.config.translation.backend is not None:
return self.ensure_opt('type_system')
return self.ensure_opt('type_system', type_system, 'lltype')
def ensure_backend(self, backend=None):
backend = self.ensure_opt('backend', backend)
self.ensure_type_system()
return backend
# disable some goals (steps)
def disable(self, to_disable):
self.driver.disable(to_disable)
def set_backend_extra_options(self, **extra_options):
for name in extra_options:
backend, option = name.split('_', 1)
self.ensure_backend(backend)
self.driver.set_backend_extra_options(extra_options)
# backend independent
def annotate(self, **kwds):
self.update_options(kwds)
return self.driver.annotate()
# type system dependent
def rtype(self, **kwds):
self.update_options(kwds)
ts = self.ensure_type_system()
return getattr(self.driver, 'rtype_' + ts)()
def backendopt(self, **kwds):
self.update_options(kwds)
ts = self.ensure_type_system('lltype')
return getattr(self.driver, 'backendopt_' + ts)()
# backend depedent
def source(self, **kwds):
self.update_options(kwds)
backend = self.ensure_backend()
getattr(self.driver, 'source_' + backend)()
def source_c(self, **kwds):
self.update_options(kwds)
self.ensure_backend('c')
self.driver.source_c()
def source_cl(self, **kwds):
self.update_options(kwds)
self.ensure_backend('cl')
self.driver.source_cl()
def compile(self, **kwds):
self.update_options(kwds)
backend = self.ensure_backend()
getattr(self.driver, 'compile_' + backend)()
return self.driver.c_entryp
def compile_c(self, **kwds):
self.update_options(kwds)
self.ensure_backend('c')
self.driver.compile_c()
return self.driver.c_entryp
|
