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

Reformat remaining files

Browse Source 
Signed-off-by: David Shah <davey1576@gmail.com>
This commit is contained in:
David Shah 2018-06-08 11:04:02 +02:00
parent cbd0622fb8
commit 7f330af9f3
5 changed files with 93 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
common/handle_error.cc
View File

@ -1,11 +1,12 @@
#include <boost/python.hpp>
#include <Python.h>
#include <boost/python.hpp>
namespace py = boost::python;
// Parses the value of the active python exception
// NOTE SHOULD NOT BE CALLED IF NO EXCEPTION
std::string parse_python_exception(){
std::string parse_python_exception()
{
PyObject *type_ptr = NULL, *value_ptr = NULL, *traceback_ptr = NULL;
// Fetch the exception info from the Python C API
PyErr_Fetch(&type_ptr, &value_ptr, &traceback_ptr);
@ -13,30 +14,31 @@ std::string parse_python_exception(){
// Fallback error
std::string ret("Unfetchable Python error");
// If the fetch got a type pointer, parse the type into the exception string
if(type_ptr != NULL){
if (type_ptr != NULL) {
py::handle<> h_type(type_ptr);
py::str type_pstr(h_type);
// Extract the string from the boost::python object
py::extract<std::string> e_type_pstr(type_pstr);
// If a valid string extraction is available, use it
// If a valid string extraction is available, use it
// otherwise use fallback
if(e_type_pstr.check())
if (e_type_pstr.check())
ret = e_type_pstr();
else
ret = "Unknown exception type";
}
// Do the same for the exception value (the stringification of the exception)
if(value_ptr != NULL){
// Do the same for the exception value (the stringification of the
// exception)
if (value_ptr != NULL) {
py::handle<> h_val(value_ptr);
py::str a(h_val);
py::extract<std::string> returned(a);
if(returned.check())
ret += ": " + returned();
if (returned.check())
ret += ": " + returned();
else
ret += std::string(": Unparseable Python error: ");
}
// Parse lines from the traceback using the Python traceback module
if(traceback_ptr != NULL){
if (traceback_ptr != NULL) {
py::handle<> h_tb(traceback_ptr);
// Load the traceback module and the format_tb function
py::object tb(py::import("traceback"));
@ -47,7 +49,7 @@ std::string parse_python_exception(){
py::object tb_str(py::str("\n").join(tb_list));
// Extract the string, check the extraction, and fallback in necessary
py::extract<std::string> returned(tb_str);
if(returned.check())
if (returned.check())
ret += ": " + returned();
else
ret += std::string(": Unparseable Python traceback");

1
common/log.h
View File

@ -20,7 +20,6 @@
#ifndef LOG_H
#define LOG_H
#include <ostream>
#include <ostream>
#include <set>
#include <stdarg.h>

146
common/pycontainers.h
View File

@ -21,13 +21,12 @@
#ifndef COMMON_PYCONTAINERS_H
#define COMMON_PYCONTAINERS_H
#include <utility>
#include <boost/python.hpp>
#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <stdexcept>
#include <type_traits>
#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <utility>
using namespace boost::python;
@ -36,27 +35,30 @@ A wrapper for a Pythonised nextpnr Iterator. The actual class wrapped is a
pair<Iterator, Iterator> containing (current, end)
*/
template<typename T, typename P>
struct iterator_wrapper {
typedef decltype(*(std::declval<T>())) value_t;
template <typename T, typename P> struct iterator_wrapper
{
typedef decltype(*(std::declval<T>())) value_t;
static value_t next(std::pair <T, T> &iter) {
if (iter.first != iter.second) {
value_t val = *iter.first;
++iter.first;
return val;
} else {
PyErr_SetString(PyExc_StopIteration, "End of range reached");
boost::python::throw_error_already_set();
// Should be unreachable, but prevent control may reach end of non-void
throw std::runtime_error("unreachable");
}
}
static value_t next(std::pair<T, T> &iter)
{
if (iter.first != iter.second) {
value_t val = *iter.first;
++iter.first;
return val;
} else {
PyErr_SetString(PyExc_StopIteration, "End of range reached");
boost::python::throw_error_already_set();
// Should be unreachable, but prevent control may reach end of
// non-void
throw std::runtime_error("unreachable");
}
}
static void wrap(const char *python_name) {
class_ < std::pair < T, T >> (python_name, no_init)
.def("__next__", next, P());
}
static void wrap(const char *python_name)
{
class_<std::pair<T, T>>(python_name, no_init)
.def("__next__", next, P());
}
};
/*
@ -65,20 +67,22 @@ and end() which return iterator-like objects supporting ++, * and !=
Full STL iterator semantics are not required, unlike the standard Boost wrappers
*/
template<typename T, typename P = return_value_policy<return_by_value>>
struct range_wrapper {
typedef decltype(std::declval<T>().begin()) iterator_t;
template <typename T, typename P = return_value_policy<return_by_value>>
struct range_wrapper
{
typedef decltype(std::declval<T>().begin()) iterator_t;
static std::pair <iterator_t, iterator_t> iter(T &range) {
return std::make_pair(range.begin(), range.end());
}
static std::pair<iterator_t, iterator_t> iter(T &range)
{
return std::make_pair(range.begin(), range.end());
}
static void wrap(const char *range_name, const char *iter_name) {
class_<T>(range_name, no_init)
.def("__iter__", iter);
iterator_wrapper<iterator_t, P>().wrap(iter_name);
}
typedef iterator_wrapper<iterator_t, P> iter_wrap;
static void wrap(const char *range_name, const char *iter_name)
{
class_<T>(range_name, no_init).def("__iter__", iter);
iterator_wrapper<iterator_t, P>().wrap(iter_name);
}
typedef iterator_wrapper<iterator_t, P> iter_wrap;
};
#define WRAP_RANGE(t) range_wrapper<t##Range>().wrap(#t "Range", #t "Iterator")
@ -88,42 +92,50 @@ Wrapper for a map, either an unordered_map, regular map or dict
*/
inline void KeyError() { PyErr_SetString(PyExc_KeyError, "Key not found"); }
template<typename T>
struct map_wrapper {
typedef typename std::remove_cv<typename std::remove_reference<typename T::key_type>::type>::type K;
typedef typename T::mapped_type V;
typedef typename T::value_type KV;
template <typename T> struct map_wrapper
{
typedef typename std::remove_cv<
typename std::remove_reference<typename T::key_type>::type>::type K;
typedef typename T::mapped_type V;
typedef typename T::value_type KV;
static V &get(T &x, K const &i) {
if (x.find(i) != x.end()) return x.at(i);
KeyError();
std::terminate();
}
static V &get(T &x, K const &i)
{
if (x.find(i) != x.end())
return x.at(i);
KeyError();
std::terminate();
}
static void set(T &x, K const &i, V const &v) {
x[i] = v;
}
static void set(T &x, K const &i, V const &v) { x[i] = v; }
static void del(T const &x, K const &i) {
if (x.find(i) != x.end()) x.erase(i);
else KeyError();
std::terminate();
}
static void del(T const &x, K const &i)
{
if (x.find(i) != x.end())
x.erase(i);
else
KeyError();
std::terminate();
}
static void wrap(const char *map_name, const char *kv_name, const char *iter_name) {
class_<KV>(kv_name)
.def_readonly("first", &KV::first)
.def_readwrite("second", &KV::second);
typedef range_wrapper<T, return_value_policy<copy_non_const_reference>> rw;
typename rw::iter_wrap().wrap(iter_name);
class_<T>(map_name, no_init)
.def("__iter__", rw::iter)
.def("__len__", &T::size)
.def("__getitem__", get, return_internal_reference<>())
.def("__setitem__", set, with_custodian_and_ward<1,2>());
}
static void wrap(const char *map_name, const char *kv_name,
const char *iter_name)
{
class_<KV>(kv_name)
.def_readonly("first", &KV::first)
.def_readwrite("second", &KV::second);
typedef range_wrapper<T, return_value_policy<copy_non_const_reference>>
rw;
typename rw::iter_wrap().wrap(iter_name);
class_<T>(map_name, no_init)
.def("__iter__", rw::iter)
.def("__len__", &T::size)
.def("__getitem__", get, return_internal_reference<>())
.def("__setitem__", set, with_custodian_and_ward<1, 2>());
}
};
#define WRAP_MAP(t, name) map_wrapper<t>().wrap(#name, #name "KeyValue", #name "Iterator")
#define WRAP_MAP(t, name) \
map_wrapper<t>().wrap(#name, #name "KeyValue", #name "Iterator")
#endif

5
dummy/chip.cc
View File

@ -27,7 +27,4 @@ const vector<BelId> &Chip::getBels() const
return ret;
}
BelType Chip::getBelType(BelId bel) const
{
return BelType();
}
BelType Chip::getBelType(BelId bel) const { return BelType(); }

1
ice40/main.cc
View File

@ -23,7 +23,6 @@
#include "design.h"
#include "jsonparse.h"
#include "log.h"
#include "log.h"
#include "mainwindow.h"
#include "place.h"
#include "pybindings.h"