PyValue PyValue::childFromIndex(int index)
{
if (childCount() <= index)
return PyValue();
int offset = index + 1;
for (ULONG childIndex = m_index + 1; childIndex < m_index + offset; ) {
const ULONG childDescendantCount = currentNumberOfDescendants(childIndex, m_symbolGroup);
childIndex += childDescendantCount + 1;
offset += childDescendantCount;
}
return PyValue(m_index + offset, m_symbolGroup);
}
PyValue PyValue::childFromField(const PyField &field)
{
if (!m_symbolGroup)
return PyValue();
ULONG64 childAddress = address();
if (!childAddress)
return PyValue();
childAddress += field.bitpos();
const std::string childTypeName = field.type().name();
if (childTypeName.empty())
return PyValue();
const std::string name = pointedToSymbolName(childAddress, childTypeName);
ULONG index = DEBUG_ANY_ID;
if (FAILED(m_symbolGroup->AddSymbol(name.c_str(), &index)))
return PyValue();
return PyValue(index, m_symbolGroup);
}
PyValue PyValue::childFromName(const std::string &name)
{
const ULONG endIndex = m_index + childCount();
for (ULONG childIndex = m_index + 1; childIndex <= endIndex; ++childIndex) {
PyValue child(childIndex, m_symbolGroup);
if (child.name() == name)
return child;
}
return PyValue();
}
static PyObject *cdbext_listOfLocals(PyObject *, PyObject *args) // -> [ Value ]
{
char *partialVariablesC;
if (!PyArg_ParseTuple(args, "s", &partialVariablesC))
Py_RETURN_NONE;
const std::string partialVariable(partialVariablesC);
IDebugSymbolGroup2 *symbolGroup = nullptr;
auto locals = PyList_New(0);
if (partialVariable.empty()) {
symbolGroup = CurrentSymbolGroup::create();
if (symbolGroup == nullptr)
return locals;
} else {
symbolGroup = CurrentSymbolGroup::get();
if (symbolGroup == nullptr)
return locals;
ULONG scopeEnd;
if (FAILED(symbolGroup->GetNumberSymbols(&scopeEnd)))
return locals;
std::vector<std::string> inameTokens;
split(partialVariable, '.', std::back_inserter(inameTokens));
auto currentPartialIname = inameTokens.begin();
++currentPartialIname; // skip "local" part
ULONG symbolGroupIndex = 0;
for (;symbolGroupIndex < scopeEnd; ++symbolGroupIndex) {
const PyValue value(symbolGroupIndex, symbolGroup);
if (value.name() == *currentPartialIname) {
PyList_Append(locals, createPythonObject(value));
return locals;
}
}
}
ULONG symbolCount;
if (FAILED(symbolGroup->GetNumberSymbols(&symbolCount)))
return locals;
for (ULONG index = 0; index < symbolCount; ++index) {
DEBUG_SYMBOL_PARAMETERS params;
if (SUCCEEDED(symbolGroup->GetSymbolParameters(index, 1, ¶ms))) {
if ((params.Flags & DEBUG_SYMBOL_IS_ARGUMENT) || (params.Flags & DEBUG_SYMBOL_IS_LOCAL))
PyList_Append(locals, createPythonObject(PyValue(index, symbolGroup)));
}
}
return locals;
}
int PyType::code() const
{
if (!m_resolved)
return TypeCodeUnresolvable;
if (m_tag < 0) {
// try to parse typeName
const std::string &typeName = name();
if (typeName.empty())
return TypeCodeUnresolvable;
if (isPointerType(typeName))
return TypeCodePointer;
if (isArrayType(typeName))
return TypeCodeArray;
if (typeName.find("<function>") == 0)
return TypeCodeFunction;
if (isIntegralType(typeName))
return TypeCodeIntegral;
if (isFloatType(typeName))
return TypeCodeFloat;
IDebugSymbolGroup2 *sg = 0;
if (FAILED(ExtensionCommandContext::instance()->symbols()->CreateSymbolGroup2(&sg)))
return TypeCodeStruct;
if (knownType(name(), 0) != KT_Unknown)
return TypeCodeStruct;
const std::string helperValueName = SymbolGroupValue::pointedToSymbolName(0, name(true));
ULONG index = DEBUG_ANY_ID;
if (SUCCEEDED(sg->AddSymbol(helperValueName.c_str(), &index)))
m_tag = PyValue(index, sg).tag();
sg->Release();
}
switch (m_tag) {
case SymTagUDT: return TypeCodeStruct;
case SymTagEnum: return TypeCodeEnum;
case SymTagTypedef: return TypeCodeTypedef;
case SymTagFunctionType: return TypeCodeFunction;
case SymTagPointerType: return TypeCodePointer;
case SymTagArrayType: return TypeCodeArray;
case SymTagBaseType: return isIntegralType(name()) ? TypeCodeIntegral : TypeCodeFloat;
default: break;
}
return TypeCodeStruct;
}
// cdbext python module
static PyObject *cdbext_parseAndEvaluate(PyObject *, PyObject *args) // -> Value
{
char *expr;
if (!PyArg_ParseTuple(args, "s", &expr))
Py_RETURN_NONE;
if (debugPyCdbextModule)
DebugPrint() << "evaluate expression: " << expr;
CIDebugControl *control = ExtensionCommandContext::instance()->control();
ULONG oldExpressionSyntax;
control->GetExpressionSyntax(&oldExpressionSyntax);
control->SetExpressionSyntax(DEBUG_EXPR_CPLUSPLUS);
IDebugSymbolGroup2 *symbolGroup = CurrentSymbolGroup::get();
ULONG index = DEBUG_ANY_ID;
HRESULT hr = symbolGroup->AddSymbol(expr, &index);
control->SetExpressionSyntax(oldExpressionSyntax);
if (FAILED(hr))
Py_RETURN_NONE;
return createPythonObject(PyValue(index, symbolGroup));
}
static PyObject *cdbext_call(PyObject *, PyObject *args)
{
char *function;
if (!PyArg_ParseTuple(args, "s", &function))
return NULL;
std::wstring woutput;
std::string error;
if (!ExtensionContext::instance().call(function, 0, &woutput, &error)) {
DebugPrint() << "Failed to call function '" << function << "' error: " << error;
Py_RETURN_NONE;
}
CIDebugRegisters *registers = ExtensionCommandContext::instance()->registers();
ULONG retRegIndex;
if (FAILED(registers->GetPseudoIndexByName("$callret", &retRegIndex)))
Py_RETURN_NONE;
ULONG64 module;
ULONG typeId;
if (FAILED(registers->GetPseudoDescription(retRegIndex, NULL, 0, NULL, &module, &typeId)))
Py_RETURN_NONE;
DEBUG_VALUE value;
if (FAILED(registers->GetPseudoValues(DEBUG_REGSRC_EXPLICIT, 1, NULL, retRegIndex, &value)))
Py_RETURN_NONE;
ULONG index = DEBUG_ANY_ID;
const std::string name = SymbolGroupValue::pointedToSymbolName(
value.I64, PyType(module, typeId).name());
if (debugPyCdbextModule)
DebugPrint() << "Call ret value expression: " << name;
IDebugSymbolGroup2 *symbolGroup = CurrentSymbolGroup::get();
if (FAILED(symbolGroup->AddSymbol(name.c_str(), &index)))
Py_RETURN_NONE;
return createPythonObject(PyValue(index, symbolGroup));
}
