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

22
common/handle_error.cc
View File

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

1
common/log.h
View File

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

146
common/pycontainers.h
View File

@ -21,13 +21,12 @@
#ifndef COMMON_PYCONTAINERS_H #ifndef COMMON_PYCONTAINERS_H
#define 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 <stdexcept>
#include <type_traits> #include <type_traits>
#include <boost/python.hpp> #include <utility>
#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>
using namespace boost::python; 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) pair<Iterator, Iterator> containing (current, end)
*/ */
template<typename T, typename P> template <typename T, typename P> struct iterator_wrapper
struct iterator_wrapper { {
typedef decltype(*(std::declval<T>())) value_t; typedef decltype(*(std::declval<T>())) value_t;
static value_t next(std::pair <T, T> &iter) { static value_t next(std::pair<T, T> &iter)
if (iter.first != iter.second) { {
value_t val = *iter.first; if (iter.first != iter.second) {
++iter.first; value_t val = *iter.first;
return val; ++iter.first;
} else { return val;
PyErr_SetString(PyExc_StopIteration, "End of range reached"); } else {
boost::python::throw_error_already_set(); PyErr_SetString(PyExc_StopIteration, "End of range reached");
// Should be unreachable, but prevent control may reach end of non-void boost::python::throw_error_already_set();
throw std::runtime_error("unreachable"); // Should be unreachable, but prevent control may reach end of
} // non-void
} throw std::runtime_error("unreachable");
}
}
static void wrap(const char *python_name) { static void wrap(const char *python_name)
class_ < std::pair < T, T >> (python_name, no_init) {
.def("__next__", next, P()); 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 Full STL iterator semantics are not required, unlike the standard Boost wrappers
*/ */
template<typename T, typename P = return_value_policy<return_by_value>> template <typename T, typename P = return_value_policy<return_by_value>>
struct range_wrapper { struct range_wrapper
typedef decltype(std::declval<T>().begin()) iterator_t; {
typedef decltype(std::declval<T>().begin()) iterator_t;
static std::pair <iterator_t, iterator_t> iter(T &range) { static std::pair<iterator_t, iterator_t> iter(T &range)
return std::make_pair(range.begin(), range.end()); {
} return std::make_pair(range.begin(), range.end());
}
static void wrap(const char *range_name, const char *iter_name) { static void wrap(const char *range_name, const char *iter_name)
class_<T>(range_name, no_init) {
.def("__iter__", iter); class_<T>(range_name, no_init).def("__iter__", iter);
iterator_wrapper<iterator_t, P>().wrap(iter_name); iterator_wrapper<iterator_t, P>().wrap(iter_name);
} }
typedef iterator_wrapper<iterator_t, P> iter_wrap; typedef iterator_wrapper<iterator_t, P> iter_wrap;
}; };
#define WRAP_RANGE(t) range_wrapper<t##Range>().wrap(#t "Range", #t "Iterator") #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"); } inline void KeyError() { PyErr_SetString(PyExc_KeyError, "Key not found"); }
template<typename T> template <typename T> struct map_wrapper
struct map_wrapper { {
typedef typename std::remove_cv<typename std::remove_reference<typename T::key_type>::type>::type K; typedef typename std::remove_cv<
typedef typename T::mapped_type V; typename std::remove_reference<typename T::key_type>::type>::type K;
typedef typename T::value_type KV; typedef typename T::mapped_type V;
typedef typename T::value_type KV;
static V &get(T &x, K const &i) { static V &get(T &x, K const &i)
if (x.find(i) != x.end()) return x.at(i); {
KeyError(); if (x.find(i) != x.end())
std::terminate(); return x.at(i);
} KeyError();
std::terminate();
}
static void set(T &x, K const &i, V const &v) { static void set(T &x, K const &i, V const &v) { x[i] = v; }
x[i] = v;
}
static void del(T const &x, K const &i) { static void del(T const &x, K const &i)
if (x.find(i) != x.end()) x.erase(i); {
else KeyError(); if (x.find(i) != x.end())
std::terminate(); x.erase(i);
} else
KeyError();
std::terminate();
}
static void wrap(const char *map_name, const char *kv_name, const char *iter_name) { static void wrap(const char *map_name, const char *kv_name,
class_<KV>(kv_name) const char *iter_name)
.def_readonly("first", &KV::first) {
.def_readwrite("second", &KV::second); class_<KV>(kv_name)
typedef range_wrapper<T, return_value_policy<copy_non_const_reference>> rw; .def_readonly("first", &KV::first)
typename rw::iter_wrap().wrap(iter_name); .def_readwrite("second", &KV::second);
class_<T>(map_name, no_init) typedef range_wrapper<T, return_value_policy<copy_non_const_reference>>
.def("__iter__", rw::iter) rw;
.def("__len__", &T::size) typename rw::iter_wrap().wrap(iter_name);
.def("__getitem__", get, return_internal_reference<>()) class_<T>(map_name, no_init)
.def("__setitem__", set, with_custodian_and_ward<1,2>()); .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 #endif

5
dummy/chip.cc
View File

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

1
ice40/main.cc
View File

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