intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-25 09:57:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

get rid of PythonInteger::GetInteger()

Browse Source 
Summary:
One small step in my long running quest to improve python exception handling in
LLDB.  Replace GetInteger() which just returns an int with As<long long> and
friends, which return Expected types that can track python exceptions

Reviewers: labath, jasonmolenda, JDevlieghere, vadimcn

Reviewed By: labath

Subscribers: lldb-commits

Tags: #lldb

Differential Revision: https://reviews.llvm.org/D78462
This commit is contained in:
Lawrence D'Anna
2020-04-21 16:53:47 -07:00
parent dad6de4112
commit 7375212172
6 changed files with 115 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
View File

@@ -44,7 +44,15 @@ template <>
Expected<long long> python::As<long long>(Expected<PythonObject> &&obj) {
if (!obj)
return obj.takeError();
return obj.get().AsLongLong();
return obj->AsLongLong();
}
template <>
Expected<unsigned long long>
python::As<unsigned long long>(Expected<PythonObject> &&obj) {
if (!obj)
return obj.takeError();
return obj->AsUnsignedLongLong();
}
template <>
@@ -463,32 +471,22 @@ void PythonInteger::Convert(PyRefType &type, PyObject *&py_obj) {
#endif
}
int64_t PythonInteger::GetInteger() const {
if (m_py_obj) {
assert(PyLong_Check(m_py_obj) &&
"PythonInteger::GetInteger has a PyObject that isn't a PyLong");
int overflow = 0;
int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow);
if (overflow != 0) {
// We got an integer that overflows, like 18446744072853913392L we can't
// use PyLong_AsLongLong() as it will return 0xffffffffffffffff. If we
// use the unsigned long long it will work as expected.
const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj);
result = static_cast<int64_t>(uval);
}
return result;
}
return UINT64_MAX;
}
void PythonInteger::SetInteger(int64_t value) {
*this = Take<PythonInteger>(PyLong_FromLongLong(value));
}
StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
StructuredData::IntegerSP result(new StructuredData::Integer);
result->SetValue(GetInteger());
// FIXME this is really not ideal. Errors are silently converted to 0
// and overflows are silently wrapped. But we'd need larger changes
// to StructuredData to fix it, so that's how it is for now.
llvm::Expected<unsigned long long> value = AsModuloUnsignedLongLong();
if (!value) {
llvm::consumeError(value.takeError());
result->SetValue(0);
} else {
result->SetValue(value.get());
}
return result;
}