def __init__(self, genoo):
self._pending_nodes = set()
self.genoo = genoo
self._rendered_nodes = set()
self.classes = {} # classdef --> class_name
self.functions = {} # graph --> function_name
self.function_names = {} # graph --> real_name
self.methods = {} # graph --> method_name
self.consts = {} # value --> const_name
self.reverse_consts = {}
self.const_names = set()
self.rendered = set()
self.const_var = Variable("__consts")
self.name_manager = JavascriptNameManager(self)
self.pending_consts = []
self.cts = self.genoo.TypeSystem(self)
self.proxies = []
def __init__(self, genoo):
self._pending_nodes = set()
self.genoo = genoo
self._rendered_nodes = set()
self.classes = {} # classdef --> class_name
self.functions = {} # graph --> function_name
self.function_names = {} # graph --> real_name
self.methods = {} # graph --> method_name
self.consts = {} # value --> const_name
self.reverse_consts = {}
self.const_names = set()
self.rendered = set()
self.const_var = Variable("__consts")
self.name_manager = JavascriptNameManager(self)
self.pending_consts = []
self.cts = self.genoo.TypeSystem(self)
self.proxies = []
class LowLevelDatabase(object):
def __init__(self, genoo):
self._pending_nodes = set()
self.genoo = genoo
self._rendered_nodes = set()
self.classes = {} # classdef --> class_name
self.functions = {} # graph --> function_name
self.function_names = {} # graph --> real_name
self.methods = {} # graph --> method_name
self.consts = {} # value --> const_name
self.reverse_consts = {}
self.const_names = set()
self.rendered = set()
self.const_var = Variable("__consts")
self.name_manager = JavascriptNameManager(self)
self.pending_consts = []
self.cts = self.genoo.TypeSystem(self)
self.proxies = []
def is_primitive(self, type_):
if type_ in [Void, Bool, Float, Signed, Unsigned, SignedLongLong, UnsignedLongLong, Char, UniChar, ootype.StringBuilder] or \
isinstance(type_,ootype.StaticMethod):
return True
return False
def pending_function(self, graph):
self.pending_node(self.genoo.Function(self, graph))
def pending_abstract_function(self, name):
pass
# XXX we want to implement it at some point (maybe...)
def pending_class(self, classdef):
c = Class(self, classdef)
self.pending_node(c)
return c
def pending_record(self, record):
r = Record(self, record)
self.pending_node(r)
return r.get_name()
def pending_node(self, node):
if node in self._pending_nodes or node in self._rendered_nodes:
return
self._pending_nodes.add(node)
def record_function(self, graph, name):
self.functions[graph] = name
def get_uniquename(self, graph, name):
try:
return self.function_names[graph]
except KeyError:
real_name = self.name_manager.uniquename(name, lenmax=1111111)
self.function_names[graph] = real_name
return real_name
def record_class(self, classdef, name):
self.classes[classdef] = name
def register_comm_proxy(self, proxy_const, *args):
""" Register external object which should be rendered as
method call
"""
self.proxies.append(XmlHttp(proxy_const, *args))
def graph_name(self, graph):
return self.functions.get(graph, None)
def class_name(self, classdef):
return self.classes.get(classdef, None)
def record_const(self, value, type_=None, retval='name'):
if type_ is None:
type_ = typeOf(value)
if self.is_primitive(type_):
return None
const = AbstractConst.make(self, value)
if not const:
return None
try:
if retval == 'name':
return self.consts[const]
else:
self.consts[const]
return self.reverse_consts[self.consts[const]]
except KeyError:
if self.genoo.config.translation.verbose:
log("New const:%r" % value)
if isinstance(value, ootype._string):
log(value._str)
else:
log.dot()
name = const.get_name()
if name in self.const_names:
name += '__%d' % len(self.consts)
self.consts[const] = name
self.reverse_consts[name] = const
self.const_names.add(name)
self.pending_consts.append((const, name))
if retval == 'name':
return name
else:
return const
def gen_constants(self, ilasm, pending):
try:
while True:
const, name = self.pending_consts.pop()
const.record_fields()
except IndexError:
pass
if pending:
return
if not self.rendered:
ilasm.begin_consts(self.const_var.name)
def generate_constants(consts):
all_c = [const for const, name in consts.iteritems()]
dep_ok = set()
while len(all_c) > 0:
const = all_c.pop()
if const not in self.rendered:
to_render = True
if hasattr(const, 'depends_on') and const.depends_on:
for i in const.depends_on:
if i not in self.rendered and i not in dep_ok:
assert i.depends is None or const in i.depends
to_render = False
continue
if to_render and (not hasattr(const, 'depends')) or (
not const.depends) or const in dep_ok:
yield const, consts[const]
self.rendered.add(const)
else:
all_c.append(const)
for i in const.depends:
all_c.append(i)
dep_ok.add(const)
# We need to keep track of fields to make sure
# our items appear earlier than us
to_init = []
for const, name in generate_constants(self.consts):
if self.genoo.config.translation.verbose:
log("Recording %r %r" % (const, name))
else:
log.dot()
ilasm.load_local(self.const_var)
const.init(ilasm)
ilasm.set_field(None, name)
ilasm.store_void()
to_init.append((const, name))
#ilasm.field(name, const.get_type(), static=True)
for const, name in to_init:
const.init_fields(ilasm, self.const_var, name)
def load_const(self, type_, value, ilasm):
if self.is_primitive(type_):
ilasm.load_const(self.cts.primitive_repr(type_, value))
else:
try:
return self.consts[BuiltinConst(value)]
except KeyError:
name = self.record_const(value)
ilasm.load_local(self.const_var)
ilasm.get_field(name)
class LowLevelDatabase(object):
def __init__(self, genoo):
self._pending_nodes = set()
self.genoo = genoo
self._rendered_nodes = set()
self.classes = {} # classdef --> class_name
self.functions = {} # graph --> function_name
self.function_names = {} # graph --> real_name
self.methods = {} # graph --> method_name
self.consts = {} # value --> const_name
self.reverse_consts = {}
self.const_names = set()
self.rendered = set()
self.const_var = Variable("__consts")
self.name_manager = JavascriptNameManager(self)
self.pending_consts = []
self.cts = self.genoo.TypeSystem(self)
self.proxies = []
def is_primitive(self, type_):
if type_ in [Void, Bool, Float, Signed, Unsigned, SignedLongLong, UnsignedLongLong, Char, UniChar, ootype.StringBuilder] or \
isinstance(type_,ootype.StaticMethod):
return True
return False
def pending_function(self, graph):
self.pending_node(self.genoo.Function(self, graph))
def pending_abstract_function(self, name):
pass
# XXX we want to implement it at some point (maybe...)
def pending_class(self, classdef):
c = Class(self, classdef)
self.pending_node(c)
return c
def pending_record(self, record):
r = Record(self, record)
self.pending_node(r)
return r.get_name()
def pending_node(self, node):
if node in self._pending_nodes or node in self._rendered_nodes:
return
self._pending_nodes.add(node)
def record_function(self, graph, name):
self.functions[graph] = name
def get_uniquename(self, graph, name):
try:
return self.function_names[graph]
except KeyError:
real_name = self.name_manager.uniquename(name, lenmax=1111111)
self.function_names[graph] = real_name
return real_name
def record_class(self, classdef, name):
self.classes[classdef] = name
def register_comm_proxy(self, proxy_const, *args):
""" Register external object which should be rendered as
method call
"""
self.proxies.append(XmlHttp(proxy_const, *args))
def graph_name(self, graph):
return self.functions.get(graph, None)
def class_name(self, classdef):
return self.classes.get(classdef, None)
def record_const(self, value, type_ = None, retval='name'):
if type_ is None:
type_ = typeOf(value)
if self.is_primitive(type_):
return None
const = AbstractConst.make(self, value)
if not const:
return None
try:
if retval == 'name':
return self.consts[const]
else:
self.consts[const]
return self.reverse_consts[self.consts[const]]
except KeyError:
if self.genoo.config.translation.verbose:
log("New const:%r"%value)
if isinstance(value, ootype._string):
log(value._str)
else:
log.dot()
name = const.get_name()
if name in self.const_names:
name += '__%d' % len(self.consts)
self.consts[const] = name
self.reverse_consts[name] = const
self.const_names.add(name)
self.pending_consts.append((const,name))
if retval == 'name':
return name
else:
return const
def gen_constants(self, ilasm, pending):
try:
while True:
const,name = self.pending_consts.pop()
const.record_fields()
except IndexError:
pass
if pending:
return
if not self.rendered:
ilasm.begin_consts(self.const_var.name)
def generate_constants(consts):
all_c = [const for const,name in consts.iteritems()]
dep_ok = set()
while len(all_c) > 0:
const = all_c.pop()
if const not in self.rendered:
to_render = True
if hasattr(const, 'depends_on') and const.depends_on:
for i in const.depends_on:
if i not in self.rendered and i not in dep_ok:
assert i.depends is None or const in i.depends
to_render = False
continue
if to_render and (not hasattr(const, 'depends')) or (not const.depends) or const in dep_ok:
yield const,consts[const]
self.rendered.add(const)
else:
all_c.append(const)
for i in const.depends:
all_c.append(i)
dep_ok.add(const)
# We need to keep track of fields to make sure
# our items appear earlier than us
to_init = []
for const, name in generate_constants(self.consts):
if self.genoo.config.translation.verbose:
log("Recording %r %r"%(const,name))
else:
log.dot()
ilasm.load_local(self.const_var)
const.init(ilasm)
ilasm.set_field(None, name)
ilasm.store_void()
to_init.append((const, name))
#ilasm.field(name, const.get_type(), static=True)
for const, name in to_init:
const.init_fields(ilasm, self.const_var, name)
def load_const(self, type_, value, ilasm):
if self.is_primitive(type_):
ilasm.load_const(self.cts.primitive_repr(type_, value))
else:
try:
return self.consts[BuiltinConst(value)]
except KeyError:
name = self.record_const(value)
ilasm.load_local(self.const_var)
ilasm.get_field(name)
