def _printnode_assign(node, ctx): at = get("at", ctx) if R.isinstance(Cat, node.l): return pipe( node.l.l, reversed, map(juxt([identity, len])), list, juxt([identity, comp(sum, map(second))]), juxt([first, comp(reduce(partial(accumulate, sub)), juxt([comp(map(second), first), second]))]), R.apply(zip), map(lambda x: _printnode( x[0][0].eq(node.r[x[1] - x[0][1]: x[1]]), ctx)), ";\n".join) lhs = _printexpr(node.l, merge(ctx, dict(lhs=True, thint=_THint.logic, lhint=None))) rhs = _printexpr(node.r, merge(ctx, dict( lhs=False, thint=_THint.logic, lhint=len(node.l) if R.isinstance(Constant, node.r) or len(node.l) > len(node.r) else None))) return pipe([lhs, ":=" if at == _AT_BLOCKING else "<=", rhs], " ".join)
def _printnode_assign(node, ctx): at = get("at", ctx) if R.isinstance(Cat, node.l): return pipe( node.l.l, reversed, map(juxt([identity, len])), list, juxt([identity, comp(sum, map(second))]), juxt([ first, comp(reduce(partial(accumulate, sub)), juxt([comp(map(second), first), second])) ]), R.apply(zip), map(lambda x: _printnode(x[0][0].eq(node.r[x[1] - x[0][1]:x[1]]), ctx)), ";\n".join) lhs = _printexpr( node.l, merge(ctx, dict(lhs=True, thint=_THint.logic, lhint=None))) rhs = _printexpr( node.r, merge( ctx, dict(lhs=False, thint=_THint.logic, lhint=len(node.l) if R.isinstance(Constant, node.r) or len(node.l) > len(node.r) else None))) return pipe([lhs, ":=" if at == _AT_BLOCKING else "<=", rhs], " ".join)
def _printgeneric(param, ns): from migen.fhdl.specials import Instance if R.isinstance(Instance.PreformattedParam, param): return param raise NotImplementedError("{} not implemented".format(type(param)))
def _printgeneric(param, ns): from migen.fhdl.specials import Instance if R.isinstance(Instance.PreformattedParam, param): return param raise NotImplementedError("{} not implemented".format(type(param)))
def convert(f, ios=None, name="top", special_overrides=dict(), attr_translate=None, create_clock_domains=True, display_run=False, asic_syntax=False): r = ConvOutput() if R.complement(R.isinstance(_Fragment))(f): f = f.get_fragment() if ios is None: ios = set() for cd_name in sorted(list_clock_domains(f)): try: f.clock_domains[cd_name] except KeyError: if create_clock_domains: cd = ClockDomain(cd_name) f.clock_domains.append(cd) ios |= {cd.clk, cd.rst} else: raise KeyError("Unresolved clock domain: '{}'".format(cd_name)) f = lower_complex_slices(f) insert_resets(f) f = lower_basics(f) fs, lowered_specials = lower_specials(special_overrides, f.specials) f += lower_basics(fs) ns = build_namespace( list_signals(f) | list_special_ios(f, True, True, True) | ios, _reserved_keywords) ns.clock_domains = f.clock_domains r.ns = ns specials = f.specials - lowered_specials r.set_main_source("".join([ _printentity(f, ios, name, ns), _printarchitecture(f, ios, name, ns, special_overrides, specials, r.add_data_file) ])) return r
def convert(f, ios=None, name="top", special_overrides=dict(), attr_translate=None, create_clock_domains=True, display_run=False, asic_syntax=False): r = ConvOutput() if R.complement(R.isinstance(_Fragment))(f): f = f.get_fragment() if ios is None: ios = set() for cd_name in sorted(list_clock_domains(f)): try: f.clock_domains[cd_name] except KeyError: if create_clock_domains: cd = ClockDomain(cd_name) f.clock_domains.append(cd) ios |= {cd.clk, cd.rst} else: raise KeyError("Unresolved clock domain: '{}'".format(cd_name)) f = lower_complex_slices(f) insert_resets(f) f = lower_basics(f) fs, lowered_specials = lower_specials(special_overrides, f.specials) f += lower_basics(fs) ns = build_namespace( list_signals(f) | list_special_ios(f, True, True, True) | ios, _reserved_keywords) ns.clock_domains = f.clock_domains r.ns = ns specials = f.specials - lowered_specials r.set_main_source("".join([ _printentity(f, ios, name, ns), _printarchitecture( f, ios, name, ns, special_overrides, specials, r.add_data_file)])) return r
if isinstance(data, dict) and lang in data: return data[lang] return data def localize2(lang, data): localize_one_level_on_lang = lambda x: localize_one_level(lang, x) return cata(localize_one_level_on_lang, data) val = { "en": "This is a sentence in english", "fr": "Ceci est une phrase en français" } tagfn = lambda fn: r.if_else(r.isinstance(bs4.element.Tag), fn, r.identity) scalarfn = lambda fn: r.if_else(r.isinstance(list), r.identity, maybe_none_resolver) data = cata(tagfn(me.find_all('tr')), at3) data2 = cata(tagfn(me.find_all('td')), data) data_texts = cata(tagfn(mn.get_text()), data2) data3 = cata(tagfn(mn.find('a')), data2) data_titles = cata(tagfn(mn.get('title')), data3) data_links = cata(tagfn(mn.get('href')), data3) #data5 = cata(tagfn(maybe_none_resolver),data4) uw_titles = cata(lambda x: x.value if isinstance(x, md.Maybe) else x, data_titles) uw_texts = cata(lambda x: x.value if isinstance(x, md.Maybe) else x, data_texts)
# def bind(self,fn): # return super(Result,self).bind( r.compose(r.if_else(r.isinstance(Exception),Error,Result),excepting( fn ) ) ) def map(self, fn): return Result(fn(self.value)) def chain(self, fn): return fn(self.value) def __add__(self, other): return Result(self.value + other.value) if not isinstance(other, Error) else self #Result = md.Result ex = MethodAp(lambda x: x, r.if_else(r.isinstance(Exception), Error, Result), excepting) em = MethodAp(lambda x: x, r.if_else(lambda x: len(x) == 0, r.always(Nothing), Just)) en = MethodAp(lambda x: x, r.if_else(lambda x: x is None, r.always(Nothing), Just)) p = MethodAp(lambda x: x, lambda x: x) itex = IterableAp(lambda x: x, r.if_else(r.isinstance(Exception), Error, Result), excepting) item = IterableAp(lambda x: x, r.if_else(lambda x: len(x) == 0, r.always(Nothing), Just)) iten = IterableAp(lambda x: x, r.if_else(lambda x: x is None, r.always(Nothing), Just)) it = IterableAp(lambda x: x, lambda x: x) sc = ScalarAp(lambda x: x, lambda x: x) scex = ScalarAp(lambda x: x, r.if_else(r.isinstance(Exception), Error, Result),
def _printexpr_operator(node, ctx): thint = get("thint", ctx) arity = len(node.operands) if arity == 1: r1 = _printexpr(node.operands[0], merge(ctx, dict(lhs=False, thint=_THint.logic, lhint=None))) if node.op == "-": expr = "(-{})".format(_signed(r1)) if thint == _THint.un_signed: return expr elif thint == _THint.integer: return _to_integer(expr) elif thint == _THint.logic: return _std_logic_vector(expr) else: return expr else: expr = "{} {}".format(_get_op(node), r1) if thint == _THint.un_signed: return _unsigned(expr) elif thint == _THint.integer: return _fn_call("to_integer", _unsigned(expr)) elif thint == _THint.boolean: return _fn_call("\\??\\", expr) else: return "({})".format(expr) elif arity == 2: if _is_bitwise_op(node): r1, r2 = pipe( [node, ctx], juxt([ comp(attrgetter("operands"), first), comp(repeat, flip(merge, dict(lhs=False, thint=_THint.logic, lhint=None)), second), ]), R.apply(zip), map(R.apply(_printexpr))) expr = pipe([r1, _get_op(node), r2], " ".join) if thint == _THint.un_signed: return _unsigned(expr) elif thint == _THint.integer: return _fn_call("to_integer", expr) else: return expr elif _is_comp_op(node): if pipe(node.operands, R.all_satisfy(comp(R.equals(1), len))): r1, r2 = pipe( [node, ctx], juxt([ comp(attrgetter("operands"), first), comp(repeat, flip(merge, dict(lhs=False, thint=_THint.logic, lhint=None)), second), ]), R.apply(zip), R.map(R.apply(_printexpr))) else: r1, r2 = pipe( [node, ctx], juxt([ comp(attrgetter("operands"), first), comp(repeat, second)]), R.apply(zip), map(juxt([ first, comp( R.apply(merge), juxt([ second, R.always(dict(lhs=False, lhint=None)), R.if_else( comp(R.isinstance(Constant), first), R.always(dict(thint=_THint.integer)), R.always(dict(thint=_THint.un_signed))) ]))])), map(R.apply(_printexpr))) if thint == _THint.logic: return _fn_call(pipe(node, _get_op, "\\?{}\\".format), r1, r2) else: return pipe([r1, _get_op(node), r2], " ".join) elif _is_shift_op(node): r1, r2 = pipe( [node, ctx], juxt([ comp(attrgetter("operands"), first), comp(repeat, second)]), R.apply(zip), map(juxt([ first, comp( R.apply(merge), juxt([ second, R.always(dict(lhs=False, lhint=None)), R.if_else( comp(R.isinstance(Constant), first), R.always(dict(thint=_THint.integer)), R.always(dict(thint=_THint.un_signed))) ]))])), map(R.apply(_printexpr))) expr = _fn_call(_shift_op[node.op], r1, r2) if thint == _THint.integer: return _fn_call("to_integer", expr) elif thint == _THint.logic: return _std_logic_vector(expr) else: return expr elif _is_arith_op(node): r1, r2 = pipe( node.operands, map(lambda x: _printexpr(x, merge(ctx, dict(lhs=False, thint=_THint.integer if R.isinstance(Constant, x) else _THint.un_signed, lhint=None))))) expr = pipe([r1, _arith_op_map[node.op], r2], " ".join) if thint == _THint.integer: return _fn_call("to_integer", expr) elif thint == _THint.logic: return _std_logic_vector(expr) else: return expr raise TypeError("unkown operator: {}, arity: {}".format(node, arity))
def _is_op_cmp(node): return node.op == "==" if R.isinstance(_Operator, node) else False
_get_comb, _get_sync, _get_clock_domains = map( attrgetter, ["comb", "sync", "clock_domains"]) _r_name = "{}_r".format _v_name = "{}_v".format _sorted_sync = comp(concatv, partial(sorted, key=get(0)), iteritems, _get_sync) _cd_regs = comp( map(juxt([ first, comp(list, filter(complement(is_variable)), filter(comp(R.isinstance(Signal))), list_targets, second)])), _sorted_sync) _assignment_filter_fn = comp( R.apply(and_), juxt([ comp(R.equals(1), len, first), comp(R.isinstance(_Assign), get_in([1, 0]))])) _comb = comp(concatv, group_by_targets, _get_comb) _assignments = comp(map(get_in([1, 0])), filter(_assignment_filter_fn), _comb) _comb_statements = comp(pluck(1), _comb) # _comb_sigs = comp(concat, pluck(0), _comb)
def _printexpr_operator(node, ctx): thint = get("thint", ctx) arity = len(node.operands) if arity == 1: r1 = _printexpr( node.operands[0], merge(ctx, dict(lhs=False, thint=_THint.logic, lhint=None))) if node.op == "-": expr = "(-{})".format(_signed(r1)) if thint == _THint.un_signed: return expr elif thint == _THint.integer: return _to_integer(expr) elif thint == _THint.logic: return _std_logic_vector(expr) else: return expr else: expr = "{} {}".format(_get_op(node), r1) if thint == _THint.un_signed: return _unsigned(expr) elif thint == _THint.integer: return _fn_call("to_integer", _unsigned(expr)) elif thint == _THint.boolean: return _fn_call("\\??\\", expr) else: return "({})".format(expr) elif arity == 2: if _is_bitwise_op(node): r1, r2 = pipe([node, ctx], juxt([ comp(attrgetter("operands"), first), comp( repeat, flip( merge, dict(lhs=False, thint=_THint.logic, lhint=None)), second), ]), R.apply(zip), map(R.apply(_printexpr))) expr = pipe([r1, _get_op(node), r2], " ".join) if thint == _THint.un_signed: return _unsigned(expr) elif thint == _THint.integer: return _fn_call("to_integer", expr) else: return expr elif _is_comp_op(node): if pipe(node.operands, R.all_satisfy(comp(R.equals(1), len))): r1, r2 = pipe([node, ctx], juxt([ comp(attrgetter("operands"), first), comp( repeat, flip( merge, dict(lhs=False, thint=_THint.logic, lhint=None)), second), ]), R.apply(zip), R.map(R.apply(_printexpr))) else: r1, r2 = pipe( [node, ctx], juxt([ comp(attrgetter("operands"), first), comp(repeat, second) ]), R.apply(zip), map( juxt([ first, comp( R.apply(merge), juxt([ second, R.always(dict(lhs=False, lhint=None)), R.if_else( comp(R.isinstance(Constant), first), R.always(dict(thint=_THint.integer)), R.always(dict(thint=_THint.un_signed))) ])) ])), map(R.apply(_printexpr))) if thint == _THint.logic: return _fn_call(pipe(node, _get_op, "\\?{}\\".format), r1, r2) else: return pipe([r1, _get_op(node), r2], " ".join) elif _is_shift_op(node): r1, r2 = pipe( [node, ctx], juxt([ comp(attrgetter("operands"), first), comp(repeat, second) ]), R.apply(zip), map( juxt([ first, comp( R.apply(merge), juxt([ second, R.always(dict(lhs=False, lhint=None)), R.if_else( comp(R.isinstance(Constant), first), R.always(dict(thint=_THint.integer)), R.always(dict(thint=_THint.un_signed))) ])) ])), map(R.apply(_printexpr))) expr = _fn_call(_shift_op[node.op], r1, r2) if thint == _THint.integer: return _fn_call("to_integer", expr) elif thint == _THint.logic: return _std_logic_vector(expr) else: return expr elif _is_arith_op(node): r1, r2 = pipe( node.operands, map(lambda x: _printexpr( x, merge( ctx, dict(lhs=False, thint=_THint.integer if R.isinstance(Constant, x) else _THint.un_signed, lhint=None))))) expr = pipe([r1, _arith_op_map[node.op], r2], " ".join) if thint == _THint.integer: return _fn_call("to_integer", expr) elif thint == _THint.logic: return _std_logic_vector(expr) else: return expr raise TypeError("unkown operator: {}, arity: {}".format(node, arity))
def _is_op_cmp(node): return node.op == "==" if R.isinstance(_Operator, node) else False
_get_comb, _get_sync, _get_clock_domains = map( attrgetter, ["comb", "sync", "clock_domains"]) _r_name = "{}_r".format _v_name = "{}_v".format _sorted_sync = comp(concatv, partial(sorted, key=get(0)), iteritems, _get_sync) _cd_regs = comp( map( juxt([ first, comp(list, filter(complement(is_variable)), filter(comp(R.isinstance(Signal))), list_targets, second) ])), _sorted_sync) _assignment_filter_fn = comp( R.apply(and_), juxt([ comp(R.equals(1), len, first), comp(R.isinstance(_Assign), get_in([1, 0])) ])) _comb = comp(concatv, group_by_targets, _get_comb) _assignments = comp(map(get_in([1, 0])), filter(_assignment_filter_fn), _comb) _comb_statements = comp(pluck(1), _comb)