Beispiel #1
0
def make_comp_maint_func(clausetools, fresh_var_prefix, fresh_join_names, comp,
                         result_var, rel, op, *, counted):
    """Make maintenance function for a comprehension."""
    assert isinstance(op, (L.SetAdd, L.SetRemove))

    op_name = L.set_update_name(op)
    func_name = N.get_maint_func_name(result_var, rel, op_name)

    update = L.RelUpdate(rel, op, '_elem')
    code = clausetools.get_maint_code(fresh_var_prefix,
                                      fresh_join_names,
                                      comp,
                                      result_var,
                                      update,
                                      counted=counted)
    func = L.Parser.ps('''
        def _FUNC(_elem):
            _CODE
        ''',
                       subst={
                           '_FUNC': func_name,
                           '<c>_CODE': code
                       })

    return func
Beispiel #2
0
def make_wrap_maint_func(fresh_vars, wrapinv: WrapInvariant, op: L.setupop):
    fresh_var_prefix = next(fresh_vars)
    v = fresh_var_prefix + '_v'

    update_code = (L.RelUpdate(wrapinv.rel, op, v), )

    func_name = wrapinv.get_maint_func_name(op)

    if wrapinv.unwrap:
        v_code = L.Parser.pc('_V = index(_elem, 0)', subst={'_V': v})
    else:
        v_code = L.Parser.pc('_V = (_elem,)', subst={'_V': v})

    func = L.Parser.ps('''
        def _FUNC(_elem):
            _V_CODE
            _UPDATE
        ''',
                       subst={
                           '_FUNC': func_name,
                           '<c>_V_CODE': v_code,
                           '<c>_UPDATE': update_code
                       })

    return func
Beispiel #3
0
 def visit_AttrAssign(self, node):
     if node.attr not in self.objrels.Fs:
         return
     
     pair = L.Tuple([node.obj, node.value])
     var = next(self.fresh_vars)
     return (L.Assign(var, pair),
             L.RelUpdate(N.F(node.attr), L.SetAdd(), var))
Beispiel #4
0
 def visit_DictAssign(self, node):
     if not self.objrels.MAP:
         return
     
     triple = L.Tuple([node.target, node.key, node.value])
     var = next(self.fresh_vars)
     return (L.Assign(var, triple),
             L.RelUpdate(N.MAP, L.SetAdd(), var))
Beispiel #5
0
 def visit_AttrDelete(self, node):
     if node.attr not in self.objrels.Fs:
         return
     
     lookup = L.Attribute(node.obj, node.attr)
     pair = L.Tuple([node.obj, lookup])
     var = next(self.fresh_vars)
     return (L.Assign(var, pair),
             L.RelUpdate(N.F(node.attr), L.SetRemove(), var))
Beispiel #6
0
 def visit_DictDelete(self, node):
     if not self.objrels.MAP:
         return
     
     lookup = L.DictLookup(node.target, node.key, None)
     triple = L.Tuple([node.target, node.key, lookup])
     var = next(self.fresh_vars)
     return (L.Assign(var, triple),
             L.RelUpdate(N.MAP, L.SetRemove(), var))
Beispiel #7
0
 def visit_SetUpdate(self, node):
     if not isinstance(node.op, (L.SetAdd, L.SetRemove)):
         return
     if not self.objrels.M:
         return
     
     pair = L.Tuple([node.target, node.value])
     var = next(self.fresh_vars)
     return (L.Assign(var, pair),
             L.RelUpdate(N.M, node.op, var))
Beispiel #8
0
def make_setfrommap_maint_func(fresh_vars, setfrommap: SetFromMapInvariant,
                               op: str):
    mask = setfrommap.mask
    nb = L.break_mapmask(mask)
    # Fresh variables for components of the key and value.
    key_vars = N.get_subnames('_key', nb)

    decomp_code = (L.DecompAssign(key_vars, L.Name('_key')), )

    vars = L.combine_by_mask(mask, key_vars, ['_val'])
    elem = L.tuplify(vars)
    fresh_var_prefix = next(fresh_vars)
    elem_var = fresh_var_prefix + '_elem'

    decomp_code += (L.Assign(elem_var, elem), )

    setopcls = {'assign': L.SetAdd, 'delete': L.SetRemove}[op]
    update_code = (L.RelUpdate(setfrommap.rel, setopcls(), elem_var), )

    func_name = setfrommap.get_maint_func_name(op)

    if op == 'assign':
        func = L.Parser.ps('''
            def _FUNC(_key, _val):
                _DECOMP
                _UPDATE
            ''',
                           subst={
                               '_FUNC': func_name,
                               '<c>_DECOMP': decomp_code,
                               '<c>_UPDATE': update_code
                           })
    elif op == 'delete':
        lookup_expr = L.DictLookup(L.Name(setfrommap.map), L.Name('_key'),
                                   None)
        func = L.Parser.ps('''
            def _FUNC(_key):
                _val = _LOOKUP
                _DECOMP
                _UPDATE
            ''',
                           subst={
                               '_FUNC': func_name,
                               '_LOOKUP': lookup_expr,
                               '<c>_DECOMP': decomp_code,
                               '<c>_UPDATE': update_code
                           })
    else:
        assert ()

    return func
Beispiel #9
0
    def visit_SetUpdate(self, node):
        if not (isinstance(node.target, L.Name)
                and node.target.id in self.rels):
            return node

        code = ()
        if isinstance(node.value, L.Name):
            elem_var = node.value.id
        else:
            elem_var = next(self.fresh_vars)
            code += L.Parser.pc('_VAR = _VALUE',
                                subst={
                                    '_VAR': elem_var,
                                    '_VALUE': node.value
                                })
        update = L.RelUpdate(node.target.id, node.op, elem_var)
        code += (update, )
        return code