def prepare(self, node, ctx): """ Initialise arguments effects as this analysis in inter-procedural. Initialisation done for Pythonic functions and default values set for user defined functions. """ super(ArgumentReadOnce, self).prepare(node, ctx) # global functions init for n in self.global_declarations.itervalues(): fe = ArgumentReadOnce.FunctionEffects(n) self.node_to_functioneffect[n] = fe self.result.add(fe) # Pythonic functions init def save_effect(module): """ Recursively save read once effect for Pythonic functions. """ for intr in module.itervalues(): if isinstance(intr, dict): # Submodule case save_effect(intr) else: fe = ArgumentReadOnce.FunctionEffects(intr) self.node_to_functioneffect[intr] = fe self.result.add(fe) if isinstance(intr, intrinsic.Class): # Class case save_effect(intr.fields) for module in MODULES.itervalues(): save_effect(module)
def prepare(self, node): """ Initialise globals effects as this analyse is inter-procedural. Initialisation done for Pythonic functions and default value set for user defined functions. """ super(GlobalEffects, self).prepare(node) def register_node(module): """ Recursively save globals effect for all functions. """ for v in module.values(): if isinstance(v, dict): # Submodule case register_node(v) else: fe = GlobalEffects.FunctionEffect(v) self.node_to_functioneffect[v] = fe self.result.add_node(fe) if isinstance(v, intrinsic.Class): register_node(v.fields) register_node(self.global_declarations) for module in MODULES.values(): register_node(module) self.node_to_functioneffect[intrinsic.UnboundValue] = \ GlobalEffects.FunctionEffect(intrinsic.UnboundValue)
def visit_FunctionDef(self, node): """ Initialise aliasing default value before visiting. Add aliasing values for : - Pythonic - globals declarations - current function arguments """ self.aliases = dict() def save_intrinsic_alias(module): """ Recursively save default aliases for pythonic functions. """ for v in module.itervalues(): if isinstance(v, dict): # Submodules case save_intrinsic_alias(v) else: self.aliases[v] = {v} if isinstance(v, Class): save_intrinsic_alias(v.fields) for module in MODULES.itervalues(): save_intrinsic_alias(module) self.aliases.update((f.name, {f}) for f in self.global_declarations.itervalues()) self.aliases.update((arg.id, {arg}) for arg in node.args.args) self.generic_visit(node)
def prepare(self, node, ctx): """ Initialise globals effects as this analyse is inter-procedural. Initialisation done for Pythonic functions and default value set for user defined functions. """ super(GlobalEffects, self).prepare(node, ctx) def register_node(module): """ Recursively save globals effect for all functions. """ for v in module.itervalues(): if isinstance(v, dict): # Submodule case register_node(v) else: fe = GlobalEffects.FunctionEffect(v) self.node_to_functioneffect[v] = fe self.result.add_node(fe) if isinstance(v, intrinsic.Class): register_node(v.fields) register_node(self.global_declarations) for module in MODULES.itervalues(): register_node(module) self.node_to_functioneffect[intrinsic.UnboundValue] = \ GlobalEffects.FunctionEffect(intrinsic.UnboundValue)
def prepare(self, node, ctx): """ Initialise arguments effects as this analysis in inter-procedural. Initialisation done for Pythonic functions and default values set for user defined functions. """ super(ArgumentReadOnce, self).prepare(node, ctx) # global functions init for n in self.global_declarations.values(): fe = ArgumentReadOnce.FunctionEffects(n) self.node_to_functioneffect[n] = fe self.result.add(fe) # Pythonic functions init def save_effect(module): """ Recursively save read once effect for Pythonic functions. """ for intr in module.values(): if isinstance(intr, dict): # Submodule case save_effect(intr) else: fe = ArgumentReadOnce.FunctionEffects(intr) self.node_to_functioneffect[intr] = fe self.result.add(fe) if isinstance(intr, intrinsic.Class): # Class case save_effect(intr.fields) for module in MODULES.values(): save_effect(module)
def access_path(node): if isinstance(node, ast.Name): return MODULES.get(demangle(node.id), node.id) elif isinstance(node, ast.Attribute): return Aliases.access_path(node.value)[demangle(node.attr)] elif isinstance(node, ast.FunctionDef): return node.name else: return node
def __init__(self): """ Gather attributes from MODULES content. """ self.attributes = set() def save_attribute(module): """ Recursively save Pythonic keywords as possible attributes. """ self.attributes.update(module.keys()) for signature in module.values(): if isinstance(signature, dict): save_attribute(signature) elif isinstance(signature, Class): save_attribute(signature.fields) for module in MODULES.values(): save_attribute(module)
def access_path(node): if isinstance(node, ast.Name): return MODULES.get(demangle(node.id), node.id) elif isinstance(node, ast.Attribute): attr_key = demangle(node.attr) value_dict = Aliases.access_path(node.value) if attr_key not in value_dict: raise PythranSyntaxError( "Unsupported attribute '{}' for this object".format( attr_key), node.value) return value_dict[attr_key] elif isinstance(node, ast.FunctionDef): return node.name else: return node
def prepare(self, node): """ Initialise values to prepare typing computation. Reorder functions to avoid dependencies issues and prepare typing computation setting typing values for Pythonic functions. """ def register(name, module): """ Recursively save function typing and combiners for Pythonic.""" for fname, function in module.items(): if isinstance(function, dict): register(name + "::" + fname, function) else: tname = 'pythonic::{0}::functor::{1}'.format(name, fname) self.result[function] = self.builder.NamedType(tname) self.combiners[function] = function if isinstance(function, Class): register(name + "::" + fname, function.fields) for mname, module in MODULES.items(): register(mname, module) super(Types, self).prepare(node)
self.index = index self.containee = containee def save_intrinsic_alias(module): """ Recursively save default aliases for pythonic functions. """ for v in module.values(): if isinstance(v, dict): # Submodules case save_intrinsic_alias(v) else: IntrinsicAliases[v] = {v} if isinstance(v, Class): save_intrinsic_alias(v.fields) for module in MODULES.values(): save_intrinsic_alias(module) class CopyOnWriteAliasesMap(object): def __init__(self, *args, **kwargs): self.src = kwargs.get('src', None) if self.src is None: self.data = dict(*args) else: assert not args, "cannot use a src and positional arguments" self.data = self.src def _copy_on_write(self): if self.src is not None: # need to do a copy
# Compute the intrinsic effects only once IntrinsicArgumentEffects = {} def save_function_effect(module): """ Recursively save function effect for pythonic functions. """ for intr in module.itervalues(): if isinstance(intr, dict): # Submodule case save_function_effect(intr) else: fe = FunctionEffects(intr) IntrinsicArgumentEffects[intr] = fe if isinstance(intr, intrinsic.Class): save_function_effect(intr.fields) for module in MODULES.itervalues(): save_function_effect(module) class ArgumentEffects(ModuleAnalysis): """Gathers inter-procedural effects on function arguments.""" def __init__(self): self.result = nx.DiGraph() self.node_to_functioneffect = IntrinsicArgumentEffects.copy() for fe in IntrinsicArgumentEffects.itervalues(): self.result.add_node(fe) super(ArgumentEffects, self).__init__(Aliases, GlobalDeclarations) def prepare(self, node, ctx):
import ast IntrinsicAliases = dict() def save_intrinsic_alias(module): """ Recursively save default aliases for pythonic functions. """ for v in module.itervalues(): if isinstance(v, dict): # Submodules case save_intrinsic_alias(v) else: IntrinsicAliases[v] = {v} if isinstance(v, Class): save_intrinsic_alias(v.fields) for module in MODULES.itervalues(): save_intrinsic_alias(module) class CopyOnWriteAliasesMap(object): def __init__(self, *args, **kwargs): self.src = kwargs.get('src', None) if self.src is None: self.data = dict(*args) else: assert not args, "cannot use a src and positional arguments" self.data = self.src def _copy_on_write(self): if self.src is not None:
def __init__(self, containee, index=UnknownIndex): self.index = index self.containee = containee def save_intrinsic_alias(module): """ Recursively save default aliases for pythonic functions. """ for v in module.values(): if isinstance(v, dict): # Submodules case save_intrinsic_alias(v) else: IntrinsicAliases[v] = frozenset((v,)) if isinstance(v, Class): save_intrinsic_alias(v.fields) for module in MODULES.values(): save_intrinsic_alias(module) class Aliases(ModuleAnalysis): ''' Gather aliasing informations across nodes As a result, each node from the module is associated to a set of node or Intrinsic to which it *may* alias to. ''' RetId = '@' def __init__(self): self.result = dict()