caiyu/nextpnr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

python: Restructuring wrapper system

Browse Source 
Signed-off-by: David Shah <davey1576@gmail.com>
This commit is contained in:
David Shah 2018-07-02 15:13:09 +02:00
parent 2e8c0c872f
commit 65195513eb
2 changed files with 84 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
common/pywrappers.h
View File

@ -41,66 +41,91 @@ template <typename T> struct ContextualWrapper
Context *ctx; Context *ctx;
T base; T base;
ContextualWrapper(Context *c, T &&x) : ctx(c), base(x){}; inline ContextualWrapper(Context *c, T &&x) : ctx(c), base(x){};
operator T() { return base; }; inline operator T() { return base; };
typedef T base_type; typedef T base_type;
}; };
template <typename T> struct WrapIfNotContext {
typedef ContextualWrapper<T> maybe_wrapped_t;
};
template <> struct WrapIfNotContext<Context> {
typedef Context maybe_wrapped_t;
};
template <typename T> inline Context *get_ctx(typename WrapIfNotContext<T>::maybe_wrapped_t &wrp_ctx) {
return wrp_ctx.ctx;
}
template <> inline Context *get_ctx<Context>(WrapIfNotContext<Context>::maybe_wrapped_t &unwrp_ctx) {
return &unwrp_ctx;
}
template <typename T> inline T&get_base(typename WrapIfNotContext<T>::maybe_wrapped_t &wrp_ctx) {
return wrp_ctx.base;
}
template <> inline Context &get_base<Context>(WrapIfNotContext<Context>::maybe_wrapped_t &unwrp_ctx) {
return unwrp_ctx;
}
template <typename T> ContextualWrapper<T> wrap_ctx(Context *ctx, T x) { return ContextualWrapper<T>(ctx, x); } template <typename T> ContextualWrapper<T> wrap_ctx(Context *ctx, T x) { return ContextualWrapper<T>(ctx, x); }
// Dummy class, to be implemented by users // Dummy class, to be implemented by users
template <typename T> class string_converter; template <typename T> struct string_converter;
// Action options // Action options
template <typename T> class do_nothing template <typename T> struct do_nothing
{ {
T operator()(Context *ctx, T x) { return x; } inline T operator()(Context *ctx, T x) { return x; }
using ret_type = T; using ret_type = T;
using arg_type = T; using arg_type = T;
}; };
template <typename T> class wrap_context template <typename T> struct wrap_context
{ {
ContextualWrapper<T> operator()(Context *ctx, T x) { return ContextualWrapper<T>(ctx, x); } inline ContextualWrapper<T> operator()(Context *ctx, T x) { return ContextualWrapper<T>(ctx, x); }
using arg_type = T; using arg_type = T;
using ret_type = ContextualWrapper<T>; using ret_type = ContextualWrapper<T>;
}; };
template <typename T> class unwrap_context template <typename T> struct unwrap_context
{ {
T operator()(Context *ctx, ContextualWrapper<T> x) { return x.base; } inline T operator()(Context *ctx, ContextualWrapper<T> x) { return x.base; }
using ret_type = T; using ret_type = T;
using arg_type = ContextualWrapper<T>; using arg_type = ContextualWrapper<T>;
}; };
template <typename T> class conv_from_string template <typename T> struct conv_from_str
{ {
T operator()(Context *ctx, std::string x) { return string_converter<T>().from_str(ctx, x); } inline T operator()(Context *ctx, std::string x) { return string_converter<T>().from_str(ctx, x); }
using ret_type = T; using ret_type = T;
using arg_type = std::string; using arg_type = std::string;
}; };
template <typename T> class conv_to_string template <typename T> struct conv_to_str
{ {
std::string operator()(Context *ctx, T x) { return string_converter<T>().to_str(ctx, x); } inline std::string operator()(Context *ctx, T x) { return string_converter<T>().to_str(ctx, x); }
using ret_type = std::string; using ret_type = std::string;
using arg_type = T; using arg_type = T;
}; };
// Function wrapper // Function wrapper
// Example: one parameter, one return // Example: one parameter, one return
template <typename Class, typename FuncT, FuncT fn, typename rv_conv, typename arg1_conv> struct function_wrapper template <typename Class, typename FuncT, FuncT fn, typename rv_conv, typename arg1_conv> struct fn_wrapper
{ {
using class_type = ContextualWrapper<Class>; using class_type = typename WrapIfNotContext<Class>::maybe_wrapped_t;
using conv_result_type = typename rv_conv::ret_type; using conv_result_type = typename rv_conv::ret_type;
using conv_arg1_type = typename arg1_conv::arg_type; using conv_arg1_type = typename arg1_conv::arg_type;
static conv_result_type wrapped_fn(class_type &cls, conv_arg1_type arg1) static conv_result_type wrapped_fn(class_type &cls, conv_arg1_type arg1)
{ {
return rv_conv()(cls.ctx, cls.base.*fn(arg1_conv()(cls.ctx, arg1))); return rv_conv()(get_base(cls).ctx, get_base(cls).*fn(arg1_conv()(get_ctx(cls), arg1)));
} }
template <typename WrapCls> static void def_wrap(WrapCls cls_, const char *name) { cls_.def(name, wrapped_fn); }
}; };
} // namespace PythonConversion } // namespace PythonConversion

65
ice40/pybindings.cc
View File

@ -25,8 +25,27 @@
NEXTPNR_NAMESPACE_BEGIN NEXTPNR_NAMESPACE_BEGIN
namespace PythonConversion {
template <> struct string_converter<BelId>
{
BelId from_str(Context *ctx, std::string name) { return ctx->getBelByName(ctx->id(name)); }
std::string to_str(Context *ctx, BelId id) { return ctx->getBelName(id).str(ctx); }
};
template <> struct string_converter<BelType>
{
BelType from_str(Context *ctx, std::string name) { return ctx->belTypeFromId(ctx->id(name)); }
std::string to_str(Context *ctx, BelType typ) { return ctx->belTypeToId(typ).str(ctx); }
};
} // namespace PythonConversion
void arch_wrap_python() void arch_wrap_python()
{ {
using namespace PythonConversion;
class_<ArchArgs>("ArchArgs").def_readwrite("type", &ArchArgs::type); class_<ArchArgs>("ArchArgs").def_readwrite("type", &ArchArgs::type);
enum_<decltype(std::declval<ArchArgs>().type)>("iCE40Type") enum_<decltype(std::declval<ArchArgs>().type)>("iCE40Type")
@ -53,28 +72,30 @@ void arch_wrap_python()
; ;
#undef X #undef X
class_<Arch, Arch *, bases<BaseCtx>, boost::noncopyable>("Arch", init<ArchArgs>()) auto arch_cls = class_<Arch, Arch *, bases<BaseCtx>, boost::noncopyable>("Arch", init<ArchArgs>())
.def("getBelByName", &Arch::getBelByName) .def("getBelByName", &Arch::getBelByName)
.def("getWireByName", &Arch::getWireByName) .def("getWireByName", &Arch::getWireByName)
.def("getBelName", &Arch::getBelName) .def("getBelName", &Arch::getBelName)
.def("getWireName", &Arch::getWireName) .def("getWireName", &Arch::getWireName)
.def("getBels", &Arch::getBels) .def("getBels", &Arch::getBels)
.def("getBelType", &Arch::getBelType) .def("getWireBelPin", &Arch::getWireBelPin)
.def("getWireBelPin", &Arch::getWireBelPin) .def("getBelPinUphill", &Arch::getBelPinUphill)
.def("getBelPinUphill", &Arch::getBelPinUphill) .def("getBelPinsDownhill", &Arch::getBelPinsDownhill)
.def("getBelPinsDownhill", &Arch::getBelPinsDownhill) .def("getWires", &Arch::getWires)
.def("getWires", &Arch::getWires) .def("getPipByName", &Arch::getPipByName)
.def("getPipByName", &Arch::getPipByName) .def("getPipName", &Arch::getPipName)
.def("getPipName", &Arch::getPipName) .def("getPips", &Arch::getPips)
.def("getPips", &Arch::getPips) .def("getPipSrcWire", &Arch::getPipSrcWire)
.def("getPipSrcWire", &Arch::getPipSrcWire) .def("getPipDstWire", &Arch::getPipDstWire)
.def("getPipDstWire", &Arch::getPipDstWire) .def("getPipDelay", &Arch::getPipDelay)
.def("getPipDelay", &Arch::getPipDelay) .def("getPipsDownhill", &Arch::getPipsDownhill)
.def("getPipsDownhill", &Arch::getPipsDownhill) .def("getPipsUphill", &Arch::getPipsUphill)
.def("getPipsUphill", &Arch::getPipsUphill) .def("getWireAliases", &Arch::getWireAliases)
.def("getWireAliases", &Arch::getWireAliases) .def("estimatePosition", &Arch::estimatePosition)
.def("estimatePosition", &Arch::estimatePosition) .def("estimateDelay", &Arch::estimateDelay);
.def("estimateDelay", &Arch::estimateDelay);
/*fn_wrapper<Arch, typeof(&Arch::getBelType), &Arch::getBelType, conv_from_str<BelId>,
conv_to_str<BelType>>::def_wrap(arch_cls, "getBelType");*/
WRAP_RANGE(Bel); WRAP_RANGE(Bel);
WRAP_RANGE(BelPin); WRAP_RANGE(BelPin);