From 088d2c4fec5b2726ee3085cd84bf9502a25927a3 Mon Sep 17 00:00:00 2001
From: Josh Morman <mormjb@gmail.com>
Date: Thu, 23 Apr 2020 07:12:36 -0400
Subject: pmt: add pybind11 bindings
---
gnuradio-runtime/python/pmt/bindings/pmt_python.cc | 1553 ++++++++++++++++++++
1 file changed, 1553 insertions(+)
create mode 100644 gnuradio-runtime/python/pmt/bindings/pmt_python.cc
(limited to 'gnuradio-runtime/python/pmt/bindings/pmt_python.cc')
diff --git a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
new file mode 100644
index 0000000000..eb9b0e1a43
--- /dev/null
+++ b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
@@ -0,0 +1,1553 @@
+/*
+ * Copyright 2020 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+/* This file is automatically generated using bindtool */
+
+#include <pybind11/complex.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+#include <pmt/pmt.h>
+// pydoc.h is automatically generated in the build directory
+#include <pmt_pydoc.h>
+
+void bind_pmt(py::module& m)
+{
+ using pmt_base = pmt::pmt_base;
+ // using exception = pmt::exception;
+ // using wrong_type = pmt::wrong_type;
+ // using out_of_range = pmt::out_of_range;
+ // using notimplemented = pmt::notimplemented;
+ using comparator = pmt::comparator;
+
+ py::class_<pmt_base, std::shared_ptr<pmt_base>>(m, "pmt_base")
+
+ .def(py::init<>(), D(pmt_base, pmt_base))
+ .def("__str__", [](const pmt::pmt_t& p) { return pmt::write_string(p); })
+ .def("is_bool", &pmt_base::is_bool, D(pmt_base, is_bool))
+
+
+ .def("is_symbol", &pmt_base::is_symbol, D(pmt_base, is_symbol))
+
+
+ .def("is_number", &pmt_base::is_number, D(pmt_base, is_number))
+
+
+ .def("is_integer", &pmt_base::is_integer, D(pmt_base, is_integer))
+
+
+ .def("is_uint64", &pmt_base::is_uint64, D(pmt_base, is_uint64))
+
+
+ .def("is_real", &pmt_base::is_real, D(pmt_base, is_real))
+
+
+ .def("is_complex", &pmt_base::is_complex, D(pmt_base, is_complex))
+
+
+ .def("is_null", &pmt_base::is_null, D(pmt_base, is_null))
+
+
+ .def("is_pair", &pmt_base::is_pair, D(pmt_base, is_pair))
+
+
+ .def("is_tuple", &pmt_base::is_tuple, D(pmt_base, is_tuple))
+
+
+ .def("is_vector", &pmt_base::is_vector, D(pmt_base, is_vector))
+
+
+ .def("is_dict", &pmt_base::is_dict, D(pmt_base, is_dict))
+
+
+ .def("is_any", &pmt_base::is_any, D(pmt_base, is_any))
+
+
+ .def("is_uniform_vector",
+ &pmt_base::is_uniform_vector,
+ D(pmt_base, is_uniform_vector))
+
+
+ .def("is_u8vector", &pmt_base::is_u8vector, D(pmt_base, is_u8vector))
+
+
+ .def("is_s8vector", &pmt_base::is_s8vector, D(pmt_base, is_s8vector))
+
+
+ .def("is_u16vector", &pmt_base::is_u16vector, D(pmt_base, is_u16vector))
+
+
+ .def("is_s16vector", &pmt_base::is_s16vector, D(pmt_base, is_s16vector))
+
+
+ .def("is_u32vector", &pmt_base::is_u32vector, D(pmt_base, is_u32vector))
+
+
+ .def("is_s32vector", &pmt_base::is_s32vector, D(pmt_base, is_s32vector))
+
+
+ .def("is_u64vector", &pmt_base::is_u64vector, D(pmt_base, is_u64vector))
+
+
+ .def("is_s64vector", &pmt_base::is_s64vector, D(pmt_base, is_s64vector))
+
+
+ .def("is_f32vector", &pmt_base::is_f32vector, D(pmt_base, is_f32vector))
+
+
+ .def("is_f64vector", &pmt_base::is_f64vector, D(pmt_base, is_f64vector))
+
+
+ .def("is_c32vector", &pmt_base::is_c32vector, D(pmt_base, is_c32vector))
+
+
+ .def("is_c64vector", &pmt_base::is_c64vector, D(pmt_base, is_c64vector))
+
+ ;
+
+
+ // py::class_<exception,std::logic_error,
+ // std::shared_ptr<exception>>(m, "exception")
+
+ // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"),
+ // py::arg("obj")
+ // )
+ // .def(py::init<pmt::exception const &>(), py::arg("arg0")
+ // )
+
+ // ;
+
+
+ // py::class_<wrong_type,pmt::exception,
+ // std::shared_ptr<wrong_type>>(m, "wrong_type")
+
+ // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"),
+ // py::arg("obj")
+ // )
+ // .def(py::init<pmt::wrong_type const &>(), py::arg("arg0")
+ // )
+
+ // ;
+
+
+ // py::class_<out_of_range,pmt::exception,
+ // std::shared_ptr<out_of_range>>(m, "out_of_range")
+
+ // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"),
+ // py::arg("obj")
+ // )
+ // .def(py::init<pmt::out_of_range const &>(), py::arg("arg0")
+ // )
+
+ // ;
+
+
+ // py::class_<notimplemented,pmt::exception,
+ // std::shared_ptr<notimplemented>>(m, "notimplemented")
+
+ // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"),
+ // py::arg("obj")
+ // )
+ // .def(py::init<pmt::notimplemented const &>(), py::arg("arg0")
+ // )
+
+ // ;
+
+
+ py::class_<comparator, std::shared_ptr<comparator>>(m, "comparator")
+
+ .def(py::init<>())
+ .def(py::init<pmt::comparator const&>(), py::arg("arg0"))
+
+ ;
+
+
+ m.def("get_PMT_NIL", &::pmt::get_PMT_NIL, D(get_PMT_NIL));
+
+
+ m.def("get_PMT_T", &::pmt::get_PMT_T, D(get_PMT_T));
+
+
+ m.def("get_PMT_F", &::pmt::get_PMT_F, D(get_PMT_F));
+
+
+ m.def("get_PMT_EOF", &::pmt::get_PMT_EOF, D(get_PMT_EOF));
+
+
+ m.def("is_bool", &::pmt::is_bool, py::arg("obj"), D(is_bool));
+
+
+ m.def("is_true", &::pmt::is_true, py::arg("obj"), D(is_true));
+
+
+ m.def("is_false", &::pmt::is_false, py::arg("obj"), D(is_false));
+
+
+ m.def("from_bool", &::pmt::from_bool, py::arg("val"), D(from_bool));
+
+
+ m.def("to_bool", &::pmt::to_bool, py::arg("val"), D(to_bool));
+
+
+ m.def("is_symbol", &::pmt::is_symbol, py::arg("obj"), D(is_symbol));
+
+
+ m.def(
+ "string_to_symbol", &::pmt::string_to_symbol, py::arg("s"), D(string_to_symbol));
+
+
+ m.def("intern", &::pmt::intern, py::arg("s"), D(intern));
+
+
+ m.def("symbol_to_string",
+ &::pmt::symbol_to_string,
+ py::arg("sym"),
+ D(symbol_to_string));
+
+
+ m.def("is_number", &::pmt::is_number, py::arg("obj"), D(is_number));
+
+
+ m.def("is_integer", &::pmt::is_integer, py::arg("x"), D(is_integer));
+
+
+ m.def("from_long", &::pmt::from_long, py::arg("x"), D(from_long));
+
+
+ m.def("to_long", &::pmt::to_long, py::arg("x"), D(to_long));
+
+
+ m.def("is_uint64", &::pmt::is_uint64, py::arg("x"), D(is_uint64));
+
+
+ m.def("from_uint64", &::pmt::from_uint64, py::arg("x"), D(from_uint64));
+
+
+ m.def("to_uint64", &::pmt::to_uint64, py::arg("x"), D(to_uint64));
+
+
+ m.def("is_real", &::pmt::is_real, py::arg("obj"), D(is_real));
+
+
+ m.def("from_double", &::pmt::from_double, py::arg("x"), D(from_double));
+
+
+ m.def("from_float", &::pmt::from_float, py::arg("x"), D(from_float));
+
+
+ m.def("to_double", &::pmt::to_double, py::arg("x"), D(to_double));
+
+
+ m.def("to_float", &::pmt::to_float, py::arg("x"), D(to_float));
+
+
+ m.def("is_complex", &::pmt::is_complex, py::arg("obj"), D(is_complex));
+
+
+ m.def("make_rectangular",
+ &::pmt::make_rectangular,
+ py::arg("re"),
+ py::arg("im"),
+ D(make_rectangular));
+
+
+ m.def("from_complex",
+ (pmt::pmt_t(*)(double, double)) & ::pmt::from_complex,
+ py::arg("re"),
+ py::arg("im"),
+ D(from_complex, 0));
+
+
+ m.def("from_complex",
+ (pmt::pmt_t(*)(std::complex<double> const&)) & ::pmt::from_complex,
+ py::arg("z"),
+ D(from_complex, 1));
+
+
+ m.def("pmt_from_complex",
+ (pmt::pmt_t(*)(double, double)) & ::pmt::pmt_from_complex,
+ py::arg("re"),
+ py::arg("im"),
+ D(pmt_from_complex, 0));
+
+
+ m.def("pmt_from_complex",
+ (pmt::pmt_t(*)(std::complex<double> const&)) & ::pmt::pmt_from_complex,
+ py::arg("z"),
+ D(pmt_from_complex, 1));
+
+
+ m.def("to_complex", &::pmt::to_complex, py::arg("z"), D(to_complex));
+
+
+ m.def("is_null", &::pmt::is_null, py::arg("x"), D(is_null));
+
+
+ m.def("is_pair", &::pmt::is_pair, py::arg("obj"), D(is_pair));
+
+
+ m.def("cons", &::pmt::cons, py::arg("x"), py::arg("y"), D(cons));
+
+
+ m.def("car", &::pmt::car, py::arg("pair"), D(car));
+
+
+ m.def("cdr", &::pmt::cdr, py::arg("pair"), D(cdr));
+
+
+ m.def("set_car", &::pmt::set_car, py::arg("pair"), py::arg("value"), D(set_car));
+
+
+ m.def("set_cdr", &::pmt::set_cdr, py::arg("pair"), py::arg("value"), D(set_cdr));
+
+
+ m.def("caar", &::pmt::caar, py::arg("pair"), D(caar));
+
+
+ m.def("cadr", &::pmt::cadr, py::arg("pair"), D(cadr));
+
+
+ m.def("cdar", &::pmt::cdar, py::arg("pair"), D(cdar));
+
+
+ m.def("cddr", &::pmt::cddr, py::arg("pair"), D(cddr));
+
+
+ m.def("caddr", &::pmt::caddr, py::arg("pair"), D(caddr));
+
+
+ m.def("cadddr", &::pmt::cadddr, py::arg("pair"), D(cadddr));
+
+
+ m.def("is_tuple", &::pmt::is_tuple, py::arg("x"), D(is_tuple));
+
+
+ m.def("make_tuple", (pmt::pmt_t(*)()) & ::pmt::make_tuple, D(make_tuple, 0));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&)) & ::pmt::make_tuple,
+ py::arg("e0"),
+ D(make_tuple, 1));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&, pmt::pmt_t const&)) & ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ D(make_tuple, 2));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ D(make_tuple, 3));
+
+
+ m.def(
+ "make_tuple",
+ (pmt::pmt_t(*)(
+ pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ py::arg("e3"),
+ D(make_tuple, 4));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ py::arg("e3"),
+ py::arg("e4"),
+ D(make_tuple, 5));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ py::arg("e3"),
+ py::arg("e4"),
+ py::arg("e5"),
+ D(make_tuple, 6));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ py::arg("e3"),
+ py::arg("e4"),
+ py::arg("e5"),
+ py::arg("e6"),
+ D(make_tuple, 7));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ py::arg("e3"),
+ py::arg("e4"),
+ py::arg("e5"),
+ py::arg("e6"),
+ py::arg("e7"),
+ D(make_tuple, 8));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ py::arg("e3"),
+ py::arg("e4"),
+ py::arg("e5"),
+ py::arg("e6"),
+ py::arg("e7"),
+ py::arg("e8"),
+ D(make_tuple, 9));
+
+
+ m.def("make_tuple",
+ (pmt::pmt_t(*)(pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&,
+ pmt::pmt_t const&)) &
+ ::pmt::make_tuple,
+ py::arg("e0"),
+ py::arg("e1"),
+ py::arg("e2"),
+ py::arg("e3"),
+ py::arg("e4"),
+ py::arg("e5"),
+ py::arg("e6"),
+ py::arg("e7"),
+ py::arg("e8"),
+ py::arg("e9"),
+ D(make_tuple, 10));
+
+
+ m.def("to_tuple", &::pmt::to_tuple, py::arg("x"), D(to_tuple));
+
+
+ m.def("tuple_ref", &::pmt::tuple_ref, py::arg("tuple"), py::arg("k"), D(tuple_ref));
+
+
+ m.def("is_vector", &::pmt::is_vector, py::arg("x"), D(is_vector));
+
+
+ m.def("make_vector",
+ &::pmt::make_vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_vector));
+
+
+ m.def(
+ "vector_ref", &::pmt::vector_ref, py::arg("vector"), py::arg("k"), D(vector_ref));
+
+
+ m.def("vector_set",
+ &::pmt::vector_set,
+ py::arg("vector"),
+ py::arg("k"),
+ py::arg("obj"),
+ D(vector_set));
+
+
+ m.def("vector_fill",
+ &::pmt::vector_fill,
+ py::arg("vector"),
+ py::arg("fill"),
+ D(vector_fill));
+
+
+ m.def("is_blob", &::pmt::is_blob, py::arg("x"), D(is_blob));
+
+
+ m.def("make_blob", &::pmt::make_blob, py::arg("buf"), py::arg("len"), D(make_blob));
+
+
+ m.def("blob_data", &::pmt::blob_data, py::arg("blob"), D(blob_data));
+
+
+ m.def("blob_length", &::pmt::blob_length, py::arg("blob"), D(blob_length));
+
+
+ m.def("is_uniform_vector",
+ &::pmt::is_uniform_vector,
+ py::arg("x"),
+ D(is_uniform_vector));
+
+
+ m.def("is_u8vector", &::pmt::is_u8vector, py::arg("x"), D(is_u8vector));
+
+
+ m.def("is_s8vector", &::pmt::is_s8vector, py::arg("x"), D(is_s8vector));
+
+
+ m.def("is_u16vector", &::pmt::is_u16vector, py::arg("x"), D(is_u16vector));
+
+
+ m.def("is_s16vector", &::pmt::is_s16vector, py::arg("x"), D(is_s16vector));
+
+
+ m.def("is_u32vector", &::pmt::is_u32vector, py::arg("x"), D(is_u32vector));
+
+
+ m.def("is_s32vector", &::pmt::is_s32vector, py::arg("x"), D(is_s32vector));
+
+
+ m.def("is_u64vector", &::pmt::is_u64vector, py::arg("x"), D(is_u64vector));
+
+
+ m.def("is_s64vector", &::pmt::is_s64vector, py::arg("x"), D(is_s64vector));
+
+
+ m.def("is_f32vector", &::pmt::is_f32vector, py::arg("x"), D(is_f32vector));
+
+
+ m.def("is_f64vector", &::pmt::is_f64vector, py::arg("x"), D(is_f64vector));
+
+
+ m.def("is_c32vector", &::pmt::is_c32vector, py::arg("x"), D(is_c32vector));
+
+
+ m.def("is_c64vector", &::pmt::is_c64vector, py::arg("x"), D(is_c64vector));
+
+
+ m.def("uniform_vector_itemsize",
+ &::pmt::uniform_vector_itemsize,
+ py::arg("x"),
+ D(uniform_vector_itemsize));
+
+
+ m.def("make_u8vector",
+ &::pmt::make_u8vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_u8vector));
+
+
+ m.def("make_s8vector",
+ &::pmt::make_s8vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_s8vector));
+
+
+ m.def("make_u16vector",
+ &::pmt::make_u16vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_u16vector));
+
+
+ m.def("make_s16vector",
+ &::pmt::make_s16vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_s16vector));
+
+
+ m.def("make_u32vector",
+ &::pmt::make_u32vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_u32vector));
+
+
+ m.def("make_s32vector",
+ &::pmt::make_s32vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_s32vector));
+
+
+ m.def("make_u64vector",
+ &::pmt::make_u64vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_u64vector));
+
+
+ m.def("make_s64vector",
+ &::pmt::make_s64vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_s64vector));
+
+
+ m.def("make_f32vector",
+ &::pmt::make_f32vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_f32vector));
+
+
+ m.def("make_f64vector",
+ &::pmt::make_f64vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_f64vector));
+
+
+ m.def("make_c32vector",
+ &::pmt::make_c32vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_c32vector));
+
+
+ m.def("make_c64vector",
+ &::pmt::make_c64vector,
+ py::arg("k"),
+ py::arg("fill"),
+ D(make_c64vector));
+
+
+ m.def("init_u8vector",
+ (pmt::pmt_t(*)(size_t, uint8_t const*)) & ::pmt::init_u8vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u8vector, 0));
+
+
+ m.def("init_u8vector",
+ (pmt::pmt_t(*)(
+ size_t, std::vector<unsigned char, std::allocator<unsigned char>> const&)) &
+ ::pmt::init_u8vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u8vector, 1));
+
+
+ m.def("init_s8vector",
+ (pmt::pmt_t(*)(size_t, int8_t const*)) & ::pmt::init_s8vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s8vector, 0));
+
+
+ m.def("init_s8vector",
+ (pmt::pmt_t(*)(size_t,
+ std::vector<signed char, std::allocator<signed char>> const&)) &
+ ::pmt::init_s8vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s8vector, 1));
+
+
+ m.def("init_u16vector",
+ (pmt::pmt_t(*)(size_t, uint16_t const*)) & ::pmt::init_u16vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u16vector, 0));
+
+
+ m.def(
+ "init_u16vector",
+ (pmt::pmt_t(*)(
+ size_t, std::vector<unsigned short, std::allocator<unsigned short>> const&)) &
+ ::pmt::init_u16vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u16vector, 1));
+
+
+ m.def("init_s16vector",
+ (pmt::pmt_t(*)(size_t, int16_t const*)) & ::pmt::init_s16vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s16vector, 0));
+
+
+ m.def("init_s16vector",
+ (pmt::pmt_t(*)(size_t, std::vector<short, std::allocator<short>> const&)) &
+ ::pmt::init_s16vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s16vector, 1));
+
+
+ m.def("init_u32vector",
+ (pmt::pmt_t(*)(size_t, uint32_t const*)) & ::pmt::init_u32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u32vector, 0));
+
+
+ m.def("init_u32vector",
+ (pmt::pmt_t(*)(
+ size_t, std::vector<unsigned int, std::allocator<unsigned int>> const&)) &
+ ::pmt::init_u32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u32vector, 1));
+
+
+ m.def("init_s32vector",
+ (pmt::pmt_t(*)(size_t, int32_t const*)) & ::pmt::init_s32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s32vector, 0));
+
+
+ m.def("init_s32vector",
+ (pmt::pmt_t(*)(size_t, std::vector<int, std::allocator<int>> const&)) &
+ ::pmt::init_s32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s32vector, 1));
+
+
+ m.def("init_u64vector",
+ (pmt::pmt_t(*)(size_t, uint64_t const*)) & ::pmt::init_u64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u64vector, 0));
+
+
+ m.def("init_u64vector",
+ (pmt::pmt_t(*)(
+ size_t, std::vector<unsigned long, std::allocator<unsigned long>> const&)) &
+ ::pmt::init_u64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u64vector, 1));
+
+
+ m.def("init_s64vector",
+ (pmt::pmt_t(*)(size_t, int64_t const*)) & ::pmt::init_s64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s64vector, 0));
+
+
+ m.def("init_s64vector",
+ (pmt::pmt_t(*)(size_t, std::vector<long, std::allocator<long>> const&)) &
+ ::pmt::init_s64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_s64vector, 1));
+
+
+ m.def("init_f32vector",
+ (pmt::pmt_t(*)(size_t, float const*)) & ::pmt::init_f32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_f32vector, 0));
+
+
+ m.def("init_f32vector",
+ (pmt::pmt_t(*)(size_t, std::vector<float, std::allocator<float>> const&)) &
+ ::pmt::init_f32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_f32vector, 1));
+
+
+ m.def("init_f64vector",
+ (pmt::pmt_t(*)(size_t, double const*)) & ::pmt::init_f64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_f64vector, 0));
+
+
+ m.def("init_f64vector",
+ (pmt::pmt_t(*)(size_t, std::vector<double, std::allocator<double>> const&)) &
+ ::pmt::init_f64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_f64vector, 1));
+
+
+ m.def("init_c32vector",
+ (pmt::pmt_t(*)(size_t, std::complex<float> const*)) & ::pmt::init_c32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_c32vector, 0));
+
+
+ m.def("init_c32vector",
+ (pmt::pmt_t(*)(size_t,
+ std::vector<std::complex<float>,
+ std::allocator<std::complex<float>>> const&)) &
+ ::pmt::init_c32vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_c32vector, 1));
+
+
+ m.def("init_c64vector",
+ (pmt::pmt_t(*)(size_t, std::complex<double> const*)) & ::pmt::init_c64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_c64vector, 0));
+
+
+ m.def("init_c64vector",
+ (pmt::pmt_t(*)(size_t,
+ std::vector<std::complex<double>,
+ std::allocator<std::complex<double>>> const&)) &
+ ::pmt::init_c64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_c64vector, 1));
+
+
+ m.def("u8vector_ref",
+ &::pmt::u8vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(u8vector_ref));
+
+
+ m.def("s8vector_ref",
+ &::pmt::s8vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(s8vector_ref));
+
+
+ m.def("u16vector_ref",
+ &::pmt::u16vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(u16vector_ref));
+
+
+ m.def("s16vector_ref",
+ &::pmt::s16vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(s16vector_ref));
+
+
+ m.def("u32vector_ref",
+ &::pmt::u32vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(u32vector_ref));
+
+
+ m.def("s32vector_ref",
+ &::pmt::s32vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(s32vector_ref));
+
+
+ m.def("u64vector_ref",
+ &::pmt::u64vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(u64vector_ref));
+
+
+ m.def("s64vector_ref",
+ &::pmt::s64vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(s64vector_ref));
+
+
+ m.def("f32vector_ref",
+ &::pmt::f32vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(f32vector_ref));
+
+
+ m.def("f64vector_ref",
+ &::pmt::f64vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(f64vector_ref));
+
+
+ m.def("c32vector_ref",
+ &::pmt::c32vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(c32vector_ref));
+
+
+ m.def("c64vector_ref",
+ &::pmt::c64vector_ref,
+ py::arg("v"),
+ py::arg("k"),
+ D(c64vector_ref));
+
+
+ m.def("u8vector_set",
+ &::pmt::u8vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(u8vector_set));
+
+
+ m.def("s8vector_set",
+ &::pmt::s8vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(s8vector_set));
+
+
+ m.def("u16vector_set",
+ &::pmt::u16vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(u16vector_set));
+
+
+ m.def("s16vector_set",
+ &::pmt::s16vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(s16vector_set));
+
+
+ m.def("u32vector_set",
+ &::pmt::u32vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(u32vector_set));
+
+
+ m.def("s32vector_set",
+ &::pmt::s32vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(s32vector_set));
+
+
+ m.def("u64vector_set",
+ &::pmt::u64vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(u64vector_set));
+
+
+ m.def("s64vector_set",
+ &::pmt::s64vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(s64vector_set));
+
+
+ m.def("f32vector_set",
+ &::pmt::f32vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(f32vector_set));
+
+
+ m.def("f64vector_set",
+ &::pmt::f64vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(f64vector_set));
+
+
+ m.def("c32vector_set",
+ &::pmt::c32vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(c32vector_set));
+
+
+ m.def("c64vector_set",
+ &::pmt::c64vector_set,
+ py::arg("v"),
+ py::arg("k"),
+ py::arg("x"),
+ D(c64vector_set));
+
+
+ m.def("uniform_vector_elements",
+ &::pmt::uniform_vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(uniform_vector_elements));
+
+
+ m.def("u8vector_elements",
+ (uint8_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u8vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u8vector_elements, 0));
+
+
+ m.def("s8vector_elements",
+ (int8_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s8vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s8vector_elements, 0));
+
+
+ m.def("u16vector_elements",
+ (uint16_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u16vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u16vector_elements, 0));
+
+
+ m.def("s16vector_elements",
+ (int16_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s16vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s16vector_elements, 0));
+
+
+ m.def("u32vector_elements",
+ (uint32_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u32vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u32vector_elements, 0));
+
+
+ m.def("s32vector_elements",
+ (int32_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s32vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s32vector_elements, 0));
+
+
+ m.def("u64vector_elements",
+ (uint64_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u64vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u64vector_elements, 0));
+
+
+ m.def("s64vector_elements",
+ (int64_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s64vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s64vector_elements, 0));
+
+
+ m.def("f32vector_elements",
+ (float const* (*)(pmt::pmt_t, size_t&)) & ::pmt::f32vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(f32vector_elements, 0));
+
+
+ m.def("f64vector_elements",
+ (double const* (*)(pmt::pmt_t, size_t&)) & ::pmt::f64vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(f64vector_elements, 0));
+
+
+ m.def("c32vector_elements",
+ (std::complex<float> const* (*)(pmt::pmt_t, size_t&)) &
+ ::pmt::c32vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(c32vector_elements, 0));
+
+
+ m.def("c64vector_elements",
+ (std::complex<double> const* (*)(pmt::pmt_t, size_t&)) &
+ ::pmt::c64vector_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(c64vector_elements, 0));
+
+ m.def("u8vector_elements",
+ (std::vector<unsigned char, std::allocator<unsigned char>> const (*)(
+ pmt::pmt_t)) &
+ ::pmt::u8vector_elements,
+ py::arg("v"),
+ D(u8vector_elements, 1));
+
+
+ m.def("s8vector_elements",
+ (std::vector<signed char, std::allocator<signed char>> const (*)(pmt::pmt_t)) &
+ ::pmt::s8vector_elements,
+ py::arg("v"),
+ D(s8vector_elements, 1));
+
+
+ m.def("u16vector_elements",
+ (std::vector<unsigned short, std::allocator<unsigned short>> const (*)(
+ pmt::pmt_t)) &
+ ::pmt::u16vector_elements,
+ py::arg("v"),
+ D(u16vector_elements, 1));
+
+
+ m.def("s16vector_elements",
+ (std::vector<short, std::allocator<short>> const (*)(pmt::pmt_t)) &
+ ::pmt::s16vector_elements,
+ py::arg("v"),
+ D(s16vector_elements, 1));
+
+
+ m.def(
+ "u32vector_elements",
+ (std::vector<unsigned int, std::allocator<unsigned int>> const (*)(pmt::pmt_t)) &
+ ::pmt::u32vector_elements,
+ py::arg("v"),
+ D(u32vector_elements, 1));
+
+
+ m.def("s32vector_elements",
+ (std::vector<int, std::allocator<int>> const (*)(pmt::pmt_t)) &
+ ::pmt::s32vector_elements,
+ py::arg("v"),
+ D(s32vector_elements, 1));
+
+
+ m.def("u64vector_elements",
+ (std::vector<unsigned long, std::allocator<unsigned long>> const (*)(
+ pmt::pmt_t)) &
+ ::pmt::u64vector_elements,
+ py::arg("v"),
+ D(u64vector_elements, 1));
+
+
+ m.def("s64vector_elements",
+ (std::vector<long, std::allocator<long>> const (*)(pmt::pmt_t)) &
+ ::pmt::s64vector_elements,
+ py::arg("v"),
+ D(s64vector_elements, 1));
+
+
+ m.def("f32vector_elements",
+ (std::vector<float, std::allocator<float>> const (*)(pmt::pmt_t)) &
+ ::pmt::f32vector_elements,
+ py::arg("v"),
+ D(f32vector_elements, 1));
+
+
+ m.def("f64vector_elements",
+ (std::vector<double, std::allocator<double>> const (*)(pmt::pmt_t)) &
+ ::pmt::f64vector_elements,
+ py::arg("v"),
+ D(f64vector_elements, 1));
+
+
+ m.def(
+ "c32vector_elements",
+ (std::vector<std::complex<float>, std::allocator<std::complex<float>>> const (*)(
+ pmt::pmt_t)) &
+ ::pmt::c32vector_elements,
+ py::arg("v"),
+ D(c32vector_elements, 1));
+
+
+ m.def("c64vector_elements",
+ (std::vector<std::complex<double>,
+ std::allocator<std::complex<double>>> const (*)(pmt::pmt_t)) &
+ ::pmt::c64vector_elements,
+ py::arg("v"),
+ D(c64vector_elements, 1));
+
+ // The following functions are not implemented in pmt.cc
+ // m.def("pmt_u8vector_elements",&pmt::pmt_u8vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_s8vector_elements",&pmt::pmt_s8vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_u16vector_elements",&pmt::pmt_u16vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_s16vector_elements",&pmt::pmt_s16vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_u32vector_elements",&pmt::pmt_u32vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_s32vector_elements",&pmt::pmt_s32vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_u64vector_elements",&pmt::pmt_u64vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_s64vector_elements",&pmt::pmt_s64vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_f32vector_elements",&pmt::pmt_f32vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_f64vector_elements",&pmt::pmt_f64vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_c32vector_elements",&pmt::pmt_c32vector_elements,
+ // py::arg("v")
+ // );
+ // m.def("pmt_c64vector_elements",&pmt::pmt_c64vector_elements,
+ // py::arg("v")
+ // );
+ m.def("uniform_vector_writable_elements",
+ &::pmt::uniform_vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(uniform_vector_writable_elements));
+
+
+ m.def("u8vector_writable_elements",
+ &::pmt::u8vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u8vector_writable_elements));
+
+
+ m.def("s8vector_writable_elements",
+ &::pmt::s8vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s8vector_writable_elements));
+
+
+ m.def("u16vector_writable_elements",
+ &::pmt::u16vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u16vector_writable_elements));
+
+
+ m.def("s16vector_writable_elements",
+ &::pmt::s16vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s16vector_writable_elements));
+
+
+ m.def("u32vector_writable_elements",
+ &::pmt::u32vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u32vector_writable_elements));
+
+
+ m.def("s32vector_writable_elements",
+ &::pmt::s32vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s32vector_writable_elements));
+
+
+ m.def("u64vector_writable_elements",
+ &::pmt::u64vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(u64vector_writable_elements));
+
+
+ m.def("s64vector_writable_elements",
+ &::pmt::s64vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(s64vector_writable_elements));
+
+
+ m.def("f32vector_writable_elements",
+ &::pmt::f32vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(f32vector_writable_elements));
+
+
+ m.def("f64vector_writable_elements",
+ &::pmt::f64vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(f64vector_writable_elements));
+
+
+ m.def("c32vector_writable_elements",
+ &::pmt::c32vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(c32vector_writable_elements));
+
+
+ m.def("c64vector_writable_elements",
+ &::pmt::c64vector_writable_elements,
+ py::arg("v"),
+ py::arg("len"),
+ D(c64vector_writable_elements));
+
+
+ m.def("is_dict", &::pmt::is_dict, py::arg("obj"), D(is_dict));
+
+
+ m.def("make_dict", &::pmt::make_dict, D(make_dict));
+
+
+ m.def("dict_add",
+ &::pmt::dict_add,
+ py::arg("dict"),
+ py::arg("key"),
+ py::arg("value"),
+ D(dict_add));
+
+
+ m.def("dict_delete",
+ &::pmt::dict_delete,
+ py::arg("dict"),
+ py::arg("key"),
+ D(dict_delete));
+
+
+ m.def("dict_has_key",
+ &::pmt::dict_has_key,
+ py::arg("dict"),
+ py::arg("key"),
+ D(dict_has_key));
+
+
+ m.def("dict_ref",
+ &::pmt::dict_ref,
+ py::arg("dict"),
+ py::arg("key"),
+ py::arg("not_found"),
+ D(dict_ref));
+
+
+ m.def("dict_items", &::pmt::dict_items, py::arg("dict"), D(dict_items));
+
+
+ m.def("dict_keys", &::pmt::dict_keys, py::arg("dict"), D(dict_keys));
+
+
+ m.def("dict_update",
+ &::pmt::dict_update,
+ py::arg("dict1"),
+ py::arg("dict2"),
+ D(dict_update));
+
+
+ m.def("dict_values", &::pmt::dict_values, py::arg("dict"), D(dict_values));
+
+
+ m.def("is_any", &::pmt::is_any, py::arg("obj"), D(is_any));
+
+
+ m.def("make_any", &::pmt::make_any, py::arg("any"), D(make_any));
+
+
+ m.def("any_ref", &::pmt::any_ref, py::arg("obj"), D(any_ref));
+
+
+ m.def("any_set", &::pmt::any_set, py::arg("obj"), py::arg("any"), D(any_set));
+
+ // m.def("is_msg_accepter",&pmt::is_msg_accepter,
+ // py::arg("obj")
+ // );
+ // m.def("make_msg_accepter",&pmt::make_msg_accepter,
+ // py::arg("ma")
+ // );
+ // m.def("msg_accepter_ref",&pmt::msg_accepter_ref,
+ // py::arg("obj")
+ // );
+ m.def("eq", &::pmt::eq, py::arg("x"), py::arg("y"), D(eq));
+
+
+ m.def("eqv", &::pmt::eqv, py::arg("x"), py::arg("y"), D(eqv));
+
+
+ m.def("equal", &::pmt::equal, py::arg("x"), py::arg("y"), D(equal));
+
+
+ m.def("assq", &::pmt::assq, py::arg("obj"), py::arg("alist"), D(assq));
+
+
+ m.def("assv", &::pmt::assv, py::arg("obj"), py::arg("alist"), D(assv));
+
+
+ m.def("assoc", &::pmt::assoc, py::arg("obj"), py::arg("alist"), D(assoc));
+
+
+ m.def("map", &::pmt::map, py::arg("proc"), py::arg("list"), D(map));
+
+
+ m.def("reverse", &::pmt::reverse, py::arg("list"), D(reverse));
+
+
+ m.def("reverse_x", &::pmt::reverse_x, py::arg("list"), D(reverse_x));
+
+
+ m.def("acons", &::pmt::acons, py::arg("x"), py::arg("y"), py::arg("a"), D(acons));
+
+
+ m.def("nth", &::pmt::nth, py::arg("n"), py::arg("list"), D(nth));
+
+
+ m.def("nthcdr", &::pmt::nthcdr, py::arg("n"), py::arg("list"), D(nthcdr));
+
+
+ m.def("memq", &::pmt::memq, py::arg("obj"), py::arg("list"), D(memq));
+
+
+ m.def("memv", &::pmt::memv, py::arg("obj"), py::arg("list"), D(memv));
+
+
+ m.def("member", &::pmt::member, py::arg("obj"), py::arg("list"), D(member));
+
+
+ m.def("subsetp", &::pmt::subsetp, py::arg("list1"), py::arg("list2"), D(subsetp));
+
+
+ m.def("list1", &::pmt::list1, py::arg("x1"), D(list1));
+
+
+ m.def("list2", &::pmt::list2, py::arg("x1"), py::arg("x2"), D(list2));
+
+
+ m.def("list3", &::pmt::list3, py::arg("x1"), py::arg("x2"), py::arg("x3"), D(list3));
+
+
+ m.def("list4",
+ &::pmt::list4,
+ py::arg("x1"),
+ py::arg("x2"),
+ py::arg("x3"),
+ py::arg("x4"),
+ D(list4));
+
+
+ m.def("list5",
+ &::pmt::list5,
+ py::arg("x1"),
+ py::arg("x2"),
+ py::arg("x3"),
+ py::arg("x4"),
+ py::arg("x5"),
+ D(list5));
+
+
+ m.def("list6",
+ &::pmt::list6,
+ py::arg("x1"),
+ py::arg("x2"),
+ py::arg("x3"),
+ py::arg("x4"),
+ py::arg("x5"),
+ py::arg("x6"),
+ D(list6));
+
+
+ m.def("list_add", &::pmt::list_add, py::arg("list"), py::arg("item"), D(list_add));
+
+
+ m.def("list_rm", &::pmt::list_rm, py::arg("list"), py::arg("item"), D(list_rm));
+
+
+ m.def("list_has", &::pmt::list_has, py::arg("list"), py::arg("item"), D(list_has));
+
+
+ m.def("is_eof_object", &::pmt::is_eof_object, py::arg("obj"), D(is_eof_object));
+
+
+ m.def("read", &::pmt::read, py::arg("port"), D(read));
+
+
+ m.def("write", &::pmt::write, py::arg("obj"), py::arg("port"), D(write));
+
+
+ m.def("write_string", &::pmt::write_string, py::arg("obj"), D(write_string));
+
+
+ m.def("print", &::pmt::print, py::arg("v"), D(print));
+
+
+ m.def("serialize", &::pmt::serialize, py::arg("obj"), py::arg("sink"), D(serialize));
+
+
+ m.def("deserialize", &::pmt::deserialize, py::arg("source"), D(deserialize));
+
+
+ m.def("dump_sizeof", &::pmt::dump_sizeof, D(dump_sizeof));
+
+ m.def("length", &pmt::length, py::arg("v"));
+
+ // pybind11 needs explicit conversion to handle non-utf8 strings
+ m.def(
+ "serialize_str",
+ [](pmt::pmt_t obj) {
+ std::string s = serialize_str(obj);
+ return py::bytes(s); // Return the data without transcoding
+ },
+ py::arg("obj"),
+ D(serialize_str));
+
+ m.def("deserialize_str", &pmt::deserialize_str, py::arg("str"), D(deserialize_str));
+}
--
cgit v1.2.3
From f29e6126e0fce0dff8dd6667fa93e2511c004f13 Mon Sep 17 00:00:00 2001
From: Josh Morman <mormjb@gmail.com>
Date: Sun, 26 Apr 2020 17:48:49 -0400
Subject: pmt: replace "long" with int64_t in python bindings
pygccxml seems to replace int64_t and uint64_t with long and unsigned
long. This causes a mismatch in the overload on 32b systems
Fixes #3408
---
gnuradio-runtime/python/pmt/bindings/pmt_python.cc | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
(limited to 'gnuradio-runtime/python/pmt/bindings/pmt_python.cc')
diff --git a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
index eb9b0e1a43..995b6fdd84 100644
--- a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
+++ b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
@@ -770,7 +770,7 @@ void bind_pmt(py::module& m)
m.def("init_u64vector",
(pmt::pmt_t(*)(
- size_t, std::vector<unsigned long, std::allocator<unsigned long>> const&)) &
+ size_t, std::vector<uint64_t, std::allocator<uint64_t>> const&)) &
::pmt::init_u64vector,
py::arg("k"),
py::arg("data"),
@@ -785,7 +785,7 @@ void bind_pmt(py::module& m)
m.def("init_s64vector",
- (pmt::pmt_t(*)(size_t, std::vector<long, std::allocator<long>> const&)) &
+ (pmt::pmt_t(*)(size_t, std::vector<int64_t, std::allocator<int64_t>> const&)) &
::pmt::init_s64vector,
py::arg("k"),
py::arg("data"),
@@ -1174,7 +1174,7 @@ void bind_pmt(py::module& m)
m.def("u64vector_elements",
- (std::vector<unsigned long, std::allocator<unsigned long>> const (*)(
+ (std::vector<uint64_t, std::allocator<uint64_t>> const (*)(
pmt::pmt_t)) &
::pmt::u64vector_elements,
py::arg("v"),
@@ -1182,7 +1182,7 @@ void bind_pmt(py::module& m)
m.def("s64vector_elements",
- (std::vector<long, std::allocator<long>> const (*)(pmt::pmt_t)) &
+ (std::vector<int64_t, std::allocator<int64_t>> const (*)(pmt::pmt_t)) &
::pmt::s64vector_elements,
py::arg("v"),
D(s64vector_elements, 1));
--
cgit v1.2.3
From 5cdb091ee899b9bfd500d036279409b707dd3cd6 Mon Sep 17 00:00:00 2001
From: Josh Morman <mormjb@gmail.com>
Date: Mon, 4 May 2020 10:39:42 -0400
Subject: pybind: run clang-format
---
docs/doxygen/pydoc_macros.h | 29 ++++++++-------
gnuradio-runtime/include/gnuradio/block_gateway.h | 35 +++++++++---------
gnuradio-runtime/include/pmt/pmt.h | 4 +-
gnuradio-runtime/lib/block_gateway_impl.cc | 18 ++++-----
gnuradio-runtime/lib/block_gateway_impl.h | 5 ++-
gnuradio-runtime/lib/pmt/pmt.cc | 2 +-
gnuradio-runtime/python/pmt/bindings/pmt_python.cc | 17 ++++-----
gr-blocks/python/blocks/bindings/wavfile_python.cc | 13 +++----
.../digital/bindings/adaptive_algorithm_python.cc | 3 +-
.../digital/bindings/modulate_vector_python.cc | 11 +++---
gr-fec/include/gnuradio/fec/gf2vec.h | 2 +-
gr-fec/include/gnuradio/fec/polar_common.h | 2 +-
gr-fec/lib/depuncture_bb_impl.cc | 8 +++-
gr-fec/lib/polar_encoder_systematic.cc | 3 +-
.../bindings/docstrings/tcp_sink_pydoc_template.h | 11 ++----
.../bindings/docstrings/udp_sink_pydoc_template.h | 11 ++----
.../docstrings/udp_source_pydoc_template.h | 11 ++----
.../python/network/bindings/python_bindings.cc | 1 -
.../python/network/bindings/tcp_sink_python.cc | 37 +++++++------------
.../python/network/bindings/udp_sink_python.cc | 41 ++++++++-------------
.../python/network/bindings/udp_source_python.cc | 43 ++++++++--------------
.../gr-newmod/docs/doxygen/pydoc_macros.h | 29 ++++++++-------
.../gr-newmod/python/bindings/python_bindings.cc | 3 --
.../vocoder/bindings/gsm_fr_decode_ps_python.cc | 2 +-
.../vocoder/bindings/gsm_fr_encode_sp_python.cc | 2 +-
25 files changed, 151 insertions(+), 192 deletions(-)
(limited to 'gnuradio-runtime/python/pmt/bindings/pmt_python.cc')
diff --git a/docs/doxygen/pydoc_macros.h b/docs/doxygen/pydoc_macros.h
index 746b3babcd..98bf7cd639 100644
--- a/docs/doxygen/pydoc_macros.h
+++ b/docs/doxygen/pydoc_macros.h
@@ -1,18 +1,19 @@
#ifndef PYDOC_MACROS_H
#define PYDOC_MACROS_H
-#define __EXPAND(x) x
-#define __COUNT(_1, _2, _3, _4, _5, _6, _7, COUNT, ...) COUNT
-#define __VA_SIZE(...) __EXPAND(__COUNT(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1))
-#define __CAT1(a, b) a ## b
-#define __CAT2(a, b) __CAT1(a, b)
-#define __DOC1(n1) __doc_##n1
-#define __DOC2(n1, n2) __doc_##n1##_##n2
-#define __DOC3(n1, n2, n3) __doc_##n1##_##n2##_##n3
-#define __DOC4(n1, n2, n3, n4) __doc_##n1##_##n2##_##n3##_##n4
-#define __DOC5(n1, n2, n3, n4, n5) __doc_##n1##_##n2##_##n3##_##n4##_##n5
-#define __DOC6(n1, n2, n3, n4, n5, n6) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6
-#define __DOC7(n1, n2, n3, n4, n5, n6, n7) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6##_##n7
-#define DOC(...) __EXPAND(__EXPAND(__CAT2(__DOC, __VA_SIZE(__VA_ARGS__)))(__VA_ARGS__))
+#define __EXPAND(x) x
+#define __COUNT(_1, _2, _3, _4, _5, _6, _7, COUNT, ...) COUNT
+#define __VA_SIZE(...) __EXPAND(__COUNT(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1))
+#define __CAT1(a, b) a##b
+#define __CAT2(a, b) __CAT1(a, b)
+#define __DOC1(n1) __doc_##n1
+#define __DOC2(n1, n2) __doc_##n1##_##n2
+#define __DOC3(n1, n2, n3) __doc_##n1##_##n2##_##n3
+#define __DOC4(n1, n2, n3, n4) __doc_##n1##_##n2##_##n3##_##n4
+#define __DOC5(n1, n2, n3, n4, n5) __doc_##n1##_##n2##_##n3##_##n4##_##n5
+#define __DOC6(n1, n2, n3, n4, n5, n6) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6
+#define __DOC7(n1, n2, n3, n4, n5, n6, n7) \
+ __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6##_##n7
+#define DOC(...) __EXPAND(__EXPAND(__CAT2(__DOC, __VA_SIZE(__VA_ARGS__)))(__VA_ARGS__))
-#endif //PYDOC_MACROS_H
\ No newline at end of file
+#endif // PYDOC_MACROS_H
\ No newline at end of file
diff --git a/gnuradio-runtime/include/gnuradio/block_gateway.h b/gnuradio-runtime/include/gnuradio/block_gateway.h
index e8e1df87e3..d42dfbb620 100644
--- a/gnuradio-runtime/include/gnuradio/block_gateway.h
+++ b/gnuradio-runtime/include/gnuradio/block_gateway.h
@@ -37,6 +37,7 @@ class GR_RUNTIME_API block_gateway : virtual public gr::block
{
private:
py::handle d_py_handle;
+
public:
// gr::block_gateway::sptr
typedef std::shared_ptr<block_gateway> sptr;
@@ -62,18 +63,17 @@ public:
}
void _add_item_tag(unsigned int which_output,
- uint64_t abs_offset,
- const pmt::pmt_t& key,
- const pmt::pmt_t& value,
- const pmt::pmt_t& srcid = pmt::PMT_F)
+ uint64_t abs_offset,
+ const pmt::pmt_t& key,
+ const pmt::pmt_t& value,
+ const pmt::pmt_t& srcid = pmt::PMT_F)
{
return gr::block::add_item_tag(which_output, abs_offset, key, value, srcid);
}
- std::vector<tag_t> _get_tags_in_range(unsigned int which_input,
- uint64_t abs_start,
- uint64_t abs_end)
+ std::vector<tag_t>
+ _get_tags_in_range(unsigned int which_input, uint64_t abs_start, uint64_t abs_end)
{
std::vector<gr::tag_t> tags;
gr::block::get_tags_in_range(tags, which_input, abs_start, abs_end);
@@ -81,18 +81,17 @@ public:
}
std::vector<tag_t> _get_tags_in_range(unsigned int which_input,
- uint64_t abs_start,
- uint64_t abs_end,
- const pmt::pmt_t& key)
+ uint64_t abs_start,
+ uint64_t abs_end,
+ const pmt::pmt_t& key)
{
std::vector<gr::tag_t> tags;
gr::block::get_tags_in_range(tags, which_input, abs_start, abs_end, key);
return tags;
}
- std::vector<tag_t> _get_tags_in_window(unsigned int which_input,
- uint64_t rel_start,
- uint64_t rel_end)
+ std::vector<tag_t>
+ _get_tags_in_window(unsigned int which_input, uint64_t rel_start, uint64_t rel_end)
{
std::vector<gr::tag_t> tags;
gr::block::get_tags_in_window(tags, which_input, rel_start, rel_end);
@@ -100,21 +99,21 @@ public:
}
std::vector<tag_t> _get_tags_in_window(unsigned int which_input,
- uint64_t rel_start,
- uint64_t rel_end,
- const pmt::pmt_t& key)
+ uint64_t rel_start,
+ uint64_t rel_end,
+ const pmt::pmt_t& key)
{
std::vector<gr::tag_t> tags;
gr::block::get_tags_in_window(tags, which_input, rel_start, rel_end, key);
return tags;
}
- virtual void set_msg_handler_pybind(pmt::pmt_t which_port, std::string& handler_name) = 0;
+ virtual void set_msg_handler_pybind(pmt::pmt_t which_port,
+ std::string& handler_name) = 0;
protected:
virtual bool has_msg_handler(pmt::pmt_t which_port) = 0;
virtual void dispatch_msg(pmt::pmt_t which_port, pmt::pmt_t msg) = 0;
-
};
} /* namespace gr */
diff --git a/gnuradio-runtime/include/pmt/pmt.h b/gnuradio-runtime/include/pmt/pmt.h
index e13a6044d6..a977a23eaa 100644
--- a/gnuradio-runtime/include/pmt/pmt.h
+++ b/gnuradio-runtime/include/pmt/pmt.h
@@ -41,12 +41,12 @@ namespace pmt {
/*!
* \brief base class of all pmt types
*/
-class PMT_API pmt_base
+class PMT_API pmt_base
{
public:
pmt_base(){};
- pmt_base(const pmt_base&)=delete;
+ pmt_base(const pmt_base&) = delete;
virtual ~pmt_base();
virtual bool is_bool() const { return false; }
diff --git a/gnuradio-runtime/lib/block_gateway_impl.cc b/gnuradio-runtime/lib/block_gateway_impl.cc
index ced8edd1f5..f4550a8bdc 100644
--- a/gnuradio-runtime/lib/block_gateway_impl.cc
+++ b/gnuradio-runtime/lib/block_gateway_impl.cc
@@ -20,8 +20,7 @@ block_gateway::sptr block_gateway::make(const py::object& p,
gr::io_signature::sptr in_sig,
gr::io_signature::sptr out_sig)
{
- return block_gateway::sptr(
- new block_gateway_impl(p, name, in_sig, out_sig));
+ return block_gateway::sptr(new block_gateway_impl(p, name, in_sig, out_sig));
}
block_gateway_impl::block_gateway_impl(const py::handle& p,
@@ -36,10 +35,10 @@ block_gateway_impl::block_gateway_impl(const py::handle& p,
void block_gateway_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required)
{
py::gil_scoped_acquire acquire;
-
- py::object ret_ninput_items_required = _py_handle.attr("handle_forecast")(noutput_items, ninput_items_required.size());
- ninput_items_required = ret_ninput_items_required.cast<std::vector<int>>();
+ py::object ret_ninput_items_required =
+ _py_handle.attr("handle_forecast")(noutput_items, ninput_items_required.size());
+ ninput_items_required = ret_ninput_items_required.cast<std::vector<int>>();
}
int block_gateway_impl::general_work(int noutput_items,
@@ -49,9 +48,11 @@ int block_gateway_impl::general_work(int noutput_items,
{
py::gil_scoped_acquire acquire;
- py::object ret = _py_handle.attr("handle_general_work")(noutput_items, ninput_items, input_items, output_items);
-
- return ret.cast<int>();;
+ py::object ret = _py_handle.attr("handle_general_work")(
+ noutput_items, ninput_items, input_items, output_items);
+
+ return ret.cast<int>();
+ ;
}
bool block_gateway_impl::start(void)
@@ -68,7 +69,6 @@ bool block_gateway_impl::stop(void)
py::object ret = _py_handle.attr("stop")();
return ret.cast<bool>();
-
}
} /* namespace gr */
diff --git a/gnuradio-runtime/lib/block_gateway_impl.h b/gnuradio-runtime/lib/block_gateway_impl.h
index 168a78650e..dc609a1248 100644
--- a/gnuradio-runtime/lib/block_gateway_impl.h
+++ b/gnuradio-runtime/lib/block_gateway_impl.h
@@ -46,7 +46,7 @@ public:
}
d_msg_handlers_pybind[which_port] = handler_name;
}
-
+
protected:
// Message handlers back into python using pybind API
typedef std::map<pmt::pmt_t, std::string, pmt::comparator> msg_handlers_pybind_t;
@@ -68,7 +68,8 @@ protected:
// d_msg_handlers_pybind[which_port]->calleval(msg); // Yes, invoke it.
py::gil_scoped_acquire acquire;
// std::string handler_name(d_msg_handlers_pybind[which_port]);
- py::object ret = _py_handle.attr(d_msg_handlers_pybind[which_port].c_str())(msg);
+ py::object ret =
+ _py_handle.attr(d_msg_handlers_pybind[which_port].c_str())(msg);
} else {
// Pass to generic dispatcher if not found
gr::basic_block::dispatch_msg(which_port, msg);
diff --git a/gnuradio-runtime/lib/pmt/pmt.cc b/gnuradio-runtime/lib/pmt/pmt.cc
index cad2d27d4a..102c8b0fa2 100644
--- a/gnuradio-runtime/lib/pmt/pmt.cc
+++ b/gnuradio-runtime/lib/pmt/pmt.cc
@@ -298,7 +298,7 @@ pmt_t pmt_from_complex(double re, double im)
return pmt_t(new pmt_complex(std::complex<double>(re, im)));
}
-pmt_t pmt_from_complex(const std::complex<double> &z)
+pmt_t pmt_from_complex(const std::complex<double>& z)
{
return pmt_t(new pmt_complex(z));
}
diff --git a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
index 995b6fdd84..5761d5c1c9 100644
--- a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
+++ b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
@@ -768,13 +768,13 @@ void bind_pmt(py::module& m)
D(init_u64vector, 0));
- m.def("init_u64vector",
- (pmt::pmt_t(*)(
- size_t, std::vector<uint64_t, std::allocator<uint64_t>> const&)) &
- ::pmt::init_u64vector,
- py::arg("k"),
- py::arg("data"),
- D(init_u64vector, 1));
+ m.def(
+ "init_u64vector",
+ (pmt::pmt_t(*)(size_t, std::vector<uint64_t, std::allocator<uint64_t>> const&)) &
+ ::pmt::init_u64vector,
+ py::arg("k"),
+ py::arg("data"),
+ D(init_u64vector, 1));
m.def("init_s64vector",
@@ -1174,8 +1174,7 @@ void bind_pmt(py::module& m)
m.def("u64vector_elements",
- (std::vector<uint64_t, std::allocator<uint64_t>> const (*)(
- pmt::pmt_t)) &
+ (std::vector<uint64_t, std::allocator<uint64_t>> const (*)(pmt::pmt_t)) &
::pmt::u64vector_elements,
py::arg("v"),
D(u64vector_elements, 1));
diff --git a/gr-blocks/python/blocks/bindings/wavfile_python.cc b/gr-blocks/python/blocks/bindings/wavfile_python.cc
index 70f4df7965..a02c743215 100644
--- a/gr-blocks/python/blocks/bindings/wavfile_python.cc
+++ b/gr-blocks/python/blocks/bindings/wavfile_python.cc
@@ -24,13 +24,12 @@ void bind_wavfile(py::module& m)
using wav_header_info = gr::blocks::wav_header_info;
py::class_<wav_header_info, std::shared_ptr<wav_header_info>>(m, "wav_header_info")
- .def_readwrite("sample_rate",&wav_header_info::sample_rate)
- .def_readwrite("nchans",&wav_header_info::nchans)
- .def_readwrite("bytes_per_sample",&wav_header_info::bytes_per_sample)
- .def_readwrite("first_sample_pos",&wav_header_info::first_sample_pos)
- .def_readwrite("samples_per_chan",&wav_header_info::samples_per_chan)
- .def_readwrite("data_chunk_size",&wav_header_info::data_chunk_size)
- ;
+ .def_readwrite("sample_rate", &wav_header_info::sample_rate)
+ .def_readwrite("nchans", &wav_header_info::nchans)
+ .def_readwrite("bytes_per_sample", &wav_header_info::bytes_per_sample)
+ .def_readwrite("first_sample_pos", &wav_header_info::first_sample_pos)
+ .def_readwrite("samples_per_chan", &wav_header_info::samples_per_chan)
+ .def_readwrite("data_chunk_size", &wav_header_info::data_chunk_size);
m.def("wavheader_parse",
&::gr::blocks::wavheader_parse,
diff --git a/gr-digital/python/digital/bindings/adaptive_algorithm_python.cc b/gr-digital/python/digital/bindings/adaptive_algorithm_python.cc
index e27279c41f..bd764c5bb4 100644
--- a/gr-digital/python/digital/bindings/adaptive_algorithm_python.cc
+++ b/gr-digital/python/digital/bindings/adaptive_algorithm_python.cc
@@ -25,8 +25,7 @@ void bind_adaptive_algorithm(py::module& m)
using adaptive_algorithm = ::gr::digital::adaptive_algorithm;
- py::class_<adaptive_algorithm,
- std::shared_ptr<adaptive_algorithm>>(
+ py::class_<adaptive_algorithm, std::shared_ptr<adaptive_algorithm>>(
m, "adaptive_algorithm", D(adaptive_algorithm))
.def("base", &adaptive_algorithm::base, D(adaptive_algorithm, base))
diff --git a/gr-digital/python/digital/bindings/modulate_vector_python.cc b/gr-digital/python/digital/bindings/modulate_vector_python.cc
index 6e486a841e..c6a2c80b49 100644
--- a/gr-digital/python/digital/bindings/modulate_vector_python.cc
+++ b/gr-digital/python/digital/bindings/modulate_vector_python.cc
@@ -16,14 +16,15 @@
namespace py = pybind11;
#include <gnuradio/basic_block.h>
-#include <gnuradio/runtime_types.h>
#include <gnuradio/digital/modulate_vector.h>
+#include <gnuradio/runtime_types.h>
void bind_modulate_vector(py::module& m)
{
- m.def("modulate_vector_bc",&::gr::digital::modulate_vector_bc,
- py::arg("modulator"),
- py::arg("data"),
- py::arg("taps"));
+ m.def("modulate_vector_bc",
+ &::gr::digital::modulate_vector_bc,
+ py::arg("modulator"),
+ py::arg("data"),
+ py::arg("taps"));
}
diff --git a/gr-fec/include/gnuradio/fec/gf2vec.h b/gr-fec/include/gnuradio/fec/gf2vec.h
index 2dd4f0d2ea..fc0740051b 100644
--- a/gr-fec/include/gnuradio/fec/gf2vec.h
+++ b/gr-fec/include/gnuradio/fec/gf2vec.h
@@ -11,8 +11,8 @@
#ifndef GF2VEC_H
#define GF2VEC_H
-#include <vector>
#include <stdint.h>
+#include <vector>
class GF2Vec
{
diff --git a/gr-fec/include/gnuradio/fec/polar_common.h b/gr-fec/include/gnuradio/fec/polar_common.h
index bfebe6df26..102e47e2c5 100644
--- a/gr-fec/include/gnuradio/fec/polar_common.h
+++ b/gr-fec/include/gnuradio/fec/polar_common.h
@@ -15,8 +15,8 @@
#include <vector>
#include <gnuradio/fec/api.h>
-#include <vector>
#include <stdint.h>
+#include <vector>
// Forward declaration for those objects. SWIG doesn't like them to be #include'd.
namespace gr {
diff --git a/gr-fec/lib/depuncture_bb_impl.cc b/gr-fec/lib/depuncture_bb_impl.cc
index e006725797..a6dc4fccfc 100644
--- a/gr-fec/lib/depuncture_bb_impl.cc
+++ b/gr-fec/lib/depuncture_bb_impl.cc
@@ -23,13 +23,17 @@
namespace gr {
namespace fec {
-depuncture_bb::sptr depuncture_bb::make(int puncsize, int puncpat, int delay, uint8_t symbol)
+depuncture_bb::sptr
+depuncture_bb::make(int puncsize, int puncpat, int delay, uint8_t symbol)
{
return gnuradio::get_initial_sptr(
new depuncture_bb_impl(puncsize, puncpat, delay, symbol));
}
-depuncture_bb_impl::depuncture_bb_impl(int puncsize, int puncpat, int delay, uint8_t symbol)
+depuncture_bb_impl::depuncture_bb_impl(int puncsize,
+ int puncpat,
+ int delay,
+ uint8_t symbol)
: block("depuncture_bb",
io_signature::make(1, 1, sizeof(unsigned char)),
io_signature::make(1, 1, sizeof(unsigned char))),
diff --git a/gr-fec/lib/polar_encoder_systematic.cc b/gr-fec/lib/polar_encoder_systematic.cc
index 605a83dcb9..b77f5e0730 100644
--- a/gr-fec/lib/polar_encoder_systematic.cc
+++ b/gr-fec/lib/polar_encoder_systematic.cc
@@ -30,7 +30,8 @@ generic_encoder::sptr polar_encoder_systematic::make(
polar_encoder_systematic::polar_encoder_systematic(int block_size,
int num_info_bits,
std::vector<int> frozen_bit_positions)
- : polar_common(block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>())
+ : polar_common(
+ block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>())
{
d_volk_syst_intermediate = (unsigned char*)volk_malloc(
sizeof(unsigned char) * block_size, volk_get_alignment());
diff --git a/gr-network/python/network/bindings/docstrings/tcp_sink_pydoc_template.h b/gr-network/python/network/bindings/docstrings/tcp_sink_pydoc_template.h
index 33286aca96..5ce85026f0 100644
--- a/gr-network/python/network/bindings/docstrings/tcp_sink_pydoc_template.h
+++ b/gr-network/python/network/bindings/docstrings/tcp_sink_pydoc_template.h
@@ -7,7 +7,7 @@
*
*/
#include "pydoc_macros.h"
-#define D(...) DOC(gr,network, __VA_ARGS__ )
+#define D(...) DOC(gr, network, __VA_ARGS__)
/*
This file contains placeholders for docstrings for the Python bindings.
Do not edit! These were automatically extracted during the binding process
@@ -15,13 +15,10 @@
*/
-
- static const char *__doc_gr_network_tcp_sink = R"doc()doc";
+static const char* __doc_gr_network_tcp_sink = R"doc()doc";
- static const char *__doc_gr_network_tcp_sink_tcp_sink = R"doc()doc";
+static const char* __doc_gr_network_tcp_sink_tcp_sink = R"doc()doc";
- static const char *__doc_gr_network_tcp_sink_make = R"doc()doc";
-
-
+static const char* __doc_gr_network_tcp_sink_make = R"doc()doc";
diff --git a/gr-network/python/network/bindings/docstrings/udp_sink_pydoc_template.h b/gr-network/python/network/bindings/docstrings/udp_sink_pydoc_template.h
index 95c60a30b8..583dcd9152 100644
--- a/gr-network/python/network/bindings/docstrings/udp_sink_pydoc_template.h
+++ b/gr-network/python/network/bindings/docstrings/udp_sink_pydoc_template.h
@@ -7,7 +7,7 @@
*
*/
#include "pydoc_macros.h"
-#define D(...) DOC(gr,network, __VA_ARGS__ )
+#define D(...) DOC(gr, network, __VA_ARGS__)
/*
This file contains placeholders for docstrings for the Python bindings.
Do not edit! These were automatically extracted during the binding process
@@ -15,13 +15,10 @@
*/
-
- static const char *__doc_gr_network_udp_sink = R"doc()doc";
+static const char* __doc_gr_network_udp_sink = R"doc()doc";
- static const char *__doc_gr_network_udp_sink_udp_sink = R"doc()doc";
+static const char* __doc_gr_network_udp_sink_udp_sink = R"doc()doc";
- static const char *__doc_gr_network_udp_sink_make = R"doc()doc";
-
-
+static const char* __doc_gr_network_udp_sink_make = R"doc()doc";
diff --git a/gr-network/python/network/bindings/docstrings/udp_source_pydoc_template.h b/gr-network/python/network/bindings/docstrings/udp_source_pydoc_template.h
index 643e28ffb3..4c08528949 100644
--- a/gr-network/python/network/bindings/docstrings/udp_source_pydoc_template.h
+++ b/gr-network/python/network/bindings/docstrings/udp_source_pydoc_template.h
@@ -7,7 +7,7 @@
*
*/
#include "pydoc_macros.h"
-#define D(...) DOC(gr,network, __VA_ARGS__ )
+#define D(...) DOC(gr, network, __VA_ARGS__)
/*
This file contains placeholders for docstrings for the Python bindings.
Do not edit! These were automatically extracted during the binding process
@@ -15,13 +15,10 @@
*/
-
- static const char *__doc_gr_network_udp_source = R"doc()doc";
+static const char* __doc_gr_network_udp_source = R"doc()doc";
- static const char *__doc_gr_network_udp_source_udp_source = R"doc()doc";
+static const char* __doc_gr_network_udp_source_udp_source = R"doc()doc";
- static const char *__doc_gr_network_udp_source_make = R"doc()doc";
-
-
+static const char* __doc_gr_network_udp_source_make = R"doc()doc";
diff --git a/gr-network/python/network/bindings/python_bindings.cc b/gr-network/python/network/bindings/python_bindings.cc
index 226cb0e609..3de111aa79 100644
--- a/gr-network/python/network/bindings/python_bindings.cc
+++ b/gr-network/python/network/bindings/python_bindings.cc
@@ -46,4 +46,3 @@ PYBIND11_MODULE(network_python, m)
bind_udp_sink(m);
bind_udp_source(m);
}
-
diff --git a/gr-network/python/network/bindings/tcp_sink_python.cc b/gr-network/python/network/bindings/tcp_sink_python.cc
index d234651096..bacd5bb98a 100644
--- a/gr-network/python/network/bindings/tcp_sink_python.cc
+++ b/gr-network/python/network/bindings/tcp_sink_python.cc
@@ -9,8 +9,8 @@
/* This file is automatically generated using bindtool */
-#include <pybind11/pybind11.h>
#include <pybind11/complex.h>
+#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
namespace py = pybind11;
@@ -22,34 +22,23 @@ namespace py = pybind11;
void bind_tcp_sink(py::module& m)
{
- using tcp_sink = ::gr::network::tcp_sink;
+ using tcp_sink = ::gr::network::tcp_sink;
- py::class_<tcp_sink, gr::sync_block, gr::block, gr::basic_block,
- std::shared_ptr<tcp_sink>>(m, "tcp_sink", D(tcp_sink))
+ py::class_<tcp_sink,
+ gr::sync_block,
+ gr::block,
+ gr::basic_block,
+ std::shared_ptr<tcp_sink>>(m, "tcp_sink", D(tcp_sink))
.def(py::init(&tcp_sink::make),
- py::arg("itemsize"),
- py::arg("veclen"),
- py::arg("host"),
- py::arg("port"),
- py::arg("sinkmode"),
- D(tcp_sink,make)
- )
-
-
+ py::arg("itemsize"),
+ py::arg("veclen"),
+ py::arg("host"),
+ py::arg("port"),
+ py::arg("sinkmode"),
+ D(tcp_sink, make))
;
-
-
-
-
}
-
-
-
-
-
-
-
diff --git a/gr-network/python/network/bindings/udp_sink_python.cc b/gr-network/python/network/bindings/udp_sink_python.cc
index 40e8e6f3b8..8dc4e6da3b 100644
--- a/gr-network/python/network/bindings/udp_sink_python.cc
+++ b/gr-network/python/network/bindings/udp_sink_python.cc
@@ -9,8 +9,8 @@
/* This file is automatically generated using bindtool */
-#include <pybind11/pybind11.h>
#include <pybind11/complex.h>
+#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
namespace py = pybind11;
@@ -22,36 +22,25 @@ namespace py = pybind11;
void bind_udp_sink(py::module& m)
{
- using udp_sink = ::gr::network::udp_sink;
+ using udp_sink = ::gr::network::udp_sink;
- py::class_<udp_sink, gr::sync_block, gr::block, gr::basic_block,
- std::shared_ptr<udp_sink>>(m, "udp_sink", D(udp_sink))
+ py::class_<udp_sink,
+ gr::sync_block,
+ gr::block,
+ gr::basic_block,
+ std::shared_ptr<udp_sink>>(m, "udp_sink", D(udp_sink))
.def(py::init(&udp_sink::make),
- py::arg("itemsize"),
- py::arg("veclen"),
- py::arg("host"),
- py::arg("port"),
- py::arg("header_type"),
- py::arg("payloadsize"),
- py::arg("send_eof"),
- D(udp_sink,make)
- )
-
-
+ py::arg("itemsize"),
+ py::arg("veclen"),
+ py::arg("host"),
+ py::arg("port"),
+ py::arg("header_type"),
+ py::arg("payloadsize"),
+ py::arg("send_eof"),
+ D(udp_sink, make))
;
-
-
-
-
}
-
-
-
-
-
-
-
diff --git a/gr-network/python/network/bindings/udp_source_python.cc b/gr-network/python/network/bindings/udp_source_python.cc
index f6ce27ff36..216e2c3c41 100644
--- a/gr-network/python/network/bindings/udp_source_python.cc
+++ b/gr-network/python/network/bindings/udp_source_python.cc
@@ -9,8 +9,8 @@
/* This file is automatically generated using bindtool */
-#include <pybind11/pybind11.h>
#include <pybind11/complex.h>
+#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
namespace py = pybind11;
@@ -22,37 +22,26 @@ namespace py = pybind11;
void bind_udp_source(py::module& m)
{
- using udp_source = ::gr::network::udp_source;
+ using udp_source = ::gr::network::udp_source;
- py::class_<udp_source, gr::sync_block, gr::block, gr::basic_block,
- std::shared_ptr<udp_source>>(m, "udp_source", D(udp_source))
+ py::class_<udp_source,
+ gr::sync_block,
+ gr::block,
+ gr::basic_block,
+ std::shared_ptr<udp_source>>(m, "udp_source", D(udp_source))
.def(py::init(&udp_source::make),
- py::arg("itemsize"),
- py::arg("vecLen"),
- py::arg("port"),
- py::arg("header_type"),
- py::arg("payloadsize"),
- py::arg("notify_missed"),
- py::arg("source_zeros"),
- py::arg("ipv6"),
- D(udp_source,make)
- )
-
-
+ py::arg("itemsize"),
+ py::arg("vecLen"),
+ py::arg("port"),
+ py::arg("header_type"),
+ py::arg("payloadsize"),
+ py::arg("notify_missed"),
+ py::arg("source_zeros"),
+ py::arg("ipv6"),
+ D(udp_source, make))
;
-
-
-
-
}
-
-
-
-
-
-
-
diff --git a/gr-utils/modtool/templates/gr-newmod/docs/doxygen/pydoc_macros.h b/gr-utils/modtool/templates/gr-newmod/docs/doxygen/pydoc_macros.h
index 746b3babcd..98bf7cd639 100644
--- a/gr-utils/modtool/templates/gr-newmod/docs/doxygen/pydoc_macros.h
+++ b/gr-utils/modtool/templates/gr-newmod/docs/doxygen/pydoc_macros.h
@@ -1,18 +1,19 @@
#ifndef PYDOC_MACROS_H
#define PYDOC_MACROS_H
-#define __EXPAND(x) x
-#define __COUNT(_1, _2, _3, _4, _5, _6, _7, COUNT, ...) COUNT
-#define __VA_SIZE(...) __EXPAND(__COUNT(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1))
-#define __CAT1(a, b) a ## b
-#define __CAT2(a, b) __CAT1(a, b)
-#define __DOC1(n1) __doc_##n1
-#define __DOC2(n1, n2) __doc_##n1##_##n2
-#define __DOC3(n1, n2, n3) __doc_##n1##_##n2##_##n3
-#define __DOC4(n1, n2, n3, n4) __doc_##n1##_##n2##_##n3##_##n4
-#define __DOC5(n1, n2, n3, n4, n5) __doc_##n1##_##n2##_##n3##_##n4##_##n5
-#define __DOC6(n1, n2, n3, n4, n5, n6) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6
-#define __DOC7(n1, n2, n3, n4, n5, n6, n7) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6##_##n7
-#define DOC(...) __EXPAND(__EXPAND(__CAT2(__DOC, __VA_SIZE(__VA_ARGS__)))(__VA_ARGS__))
+#define __EXPAND(x) x
+#define __COUNT(_1, _2, _3, _4, _5, _6, _7, COUNT, ...) COUNT
+#define __VA_SIZE(...) __EXPAND(__COUNT(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1))
+#define __CAT1(a, b) a##b
+#define __CAT2(a, b) __CAT1(a, b)
+#define __DOC1(n1) __doc_##n1
+#define __DOC2(n1, n2) __doc_##n1##_##n2
+#define __DOC3(n1, n2, n3) __doc_##n1##_##n2##_##n3
+#define __DOC4(n1, n2, n3, n4) __doc_##n1##_##n2##_##n3##_##n4
+#define __DOC5(n1, n2, n3, n4, n5) __doc_##n1##_##n2##_##n3##_##n4##_##n5
+#define __DOC6(n1, n2, n3, n4, n5, n6) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6
+#define __DOC7(n1, n2, n3, n4, n5, n6, n7) \
+ __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6##_##n7
+#define DOC(...) __EXPAND(__EXPAND(__CAT2(__DOC, __VA_SIZE(__VA_ARGS__)))(__VA_ARGS__))
-#endif //PYDOC_MACROS_H
\ No newline at end of file
+#endif // PYDOC_MACROS_H
\ No newline at end of file
diff --git a/gr-utils/modtool/templates/gr-newmod/python/bindings/python_bindings.cc b/gr-utils/modtool/templates/gr-newmod/python/bindings/python_bindings.cc
index 83dbf33c6d..4cf0b21781 100644
--- a/gr-utils/modtool/templates/gr-newmod/python/bindings/python_bindings.cc
+++ b/gr-utils/modtool/templates/gr-newmod/python/bindings/python_bindings.cc
@@ -50,7 +50,4 @@ PYBIND11_MODULE(howto_python, m)
/**************************************/
// BINDING_FUNCTION_CALLS(
// ) END BINDING_FUNCTION_CALLS
-
-
}
-
diff --git a/gr-vocoder/python/vocoder/bindings/gsm_fr_decode_ps_python.cc b/gr-vocoder/python/vocoder/bindings/gsm_fr_decode_ps_python.cc
index 11149ac0c0..b5d7f4b69c 100644
--- a/gr-vocoder/python/vocoder/bindings/gsm_fr_decode_ps_python.cc
+++ b/gr-vocoder/python/vocoder/bindings/gsm_fr_decode_ps_python.cc
@@ -33,7 +33,7 @@ void bind_gsm_fr_decode_ps(py::module& m)
std::shared_ptr<gsm_fr_decode_ps>>(
m, "gsm_fr_decode_ps", D(gsm_fr_decode_ps))
- .def(py::init(&gsm_fr_decode_ps::make), D(gsm_fr_decode_ps, make))
+ .def(py::init(&gsm_fr_decode_ps::make), D(gsm_fr_decode_ps, make))
;
diff --git a/gr-vocoder/python/vocoder/bindings/gsm_fr_encode_sp_python.cc b/gr-vocoder/python/vocoder/bindings/gsm_fr_encode_sp_python.cc
index d119a61022..0c2daaaa49 100644
--- a/gr-vocoder/python/vocoder/bindings/gsm_fr_encode_sp_python.cc
+++ b/gr-vocoder/python/vocoder/bindings/gsm_fr_encode_sp_python.cc
@@ -33,7 +33,7 @@ void bind_gsm_fr_encode_sp(py::module& m)
std::shared_ptr<gsm_fr_encode_sp>>(
m, "gsm_fr_encode_sp", D(gsm_fr_encode_sp))
- .def(py::init(&gsm_fr_encode_sp::make),D(gsm_fr_encode_sp, make))
+ .def(py::init(&gsm_fr_encode_sp::make), D(gsm_fr_encode_sp, make))
;
--
cgit v1.2.3
From 31f0a0703eecb4949168bba1be0cb3aea86e1db1 Mon Sep 17 00:00:00 2001
From: Josh Morman <mormjb@gmail.com>
Date: Wed, 3 Jun 2020 09:04:55 -0400
Subject: pmt: update pybind code for dcons and is_pmt
---
.../python/pmt/bindings/docstrings/pmt_pydoc_template.h | 6 ++++++
gnuradio-runtime/python/pmt/bindings/pmt_python.cc | 6 ++++++
2 files changed, 12 insertions(+)
(limited to 'gnuradio-runtime/python/pmt/bindings/pmt_python.cc')
diff --git a/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h
index 76d7234d14..6af2f9e0af 100644
--- a/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h
+++ b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h
@@ -249,6 +249,9 @@ static const char* __doc_pmt_is_pair = R"doc()doc";
static const char* __doc_pmt_cons = R"doc()doc";
+static const char* __doc_pmt_dcons = R"doc()doc";
+
+
static const char* __doc_pmt_car = R"doc()doc";
@@ -771,6 +774,9 @@ static const char* __doc_pmt_make_msg_accepter = R"doc()doc";
static const char* __doc_pmt_msg_accepter_ref = R"doc()doc";
+static const char* __doc_pmt_is_pdu = R"doc()doc";
+
+
static const char* __doc_pmt_eq = R"doc()doc";
diff --git a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
index 5761d5c1c9..7cb1e530d3 100644
--- a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
+++ b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc
@@ -297,6 +297,9 @@ void bind_pmt(py::module& m)
m.def("cons", &::pmt::cons, py::arg("x"), py::arg("y"), D(cons));
+ m.def("dcons", &::pmt::dcons, py::arg("x"), py::arg("y"), D(dcons));
+
+
m.def("car", &::pmt::car, py::arg("pair"), D(car));
@@ -1417,6 +1420,9 @@ void bind_pmt(py::module& m)
// m.def("msg_accepter_ref",&pmt::msg_accepter_ref,
// py::arg("obj")
// );
+ m.def("is_pdu", &::pmt::is_pdu, py::arg("obj"), D(is_pdu));
+
+
m.def("eq", &::pmt::eq, py::arg("x"), py::arg("y"), D(eq));
--
cgit v1.2.3