lua_debugger_utils.h

Go to the documentation of this file.

/* lua_debugger_utils.h
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

 
#ifndef LUA_DEBUGGER_UTILS_H
#define LUA_DEBUGGER_UTILS_H
 
#include <QBrush>
#include <QChar>
#include <QColor>
#include <QFont>
#include <QHash>
#include <QIcon>
#include <QKeySequence>
#include <QModelIndex>
#include <QSet>
#include <QStandardItem>
#include <QStandardItemModel>
#include <QString>
#include <QStringList>
#include <QTreeView>
#include <QVariant>
#include <QtGlobal>
 
#include "epan/wslua/wslua_debugger.h"
 
class LuaDebuggerDialog;
class QFont;
class QKeyEvent;
class QObject;
class QPalette;
class QPainter;
class QToolButton;
class QTreeView;
class QWidget;
 
namespace Ui
{
class LuaDebuggerDialog;
}
 
/* ===== from internal ===== */
 


inline QStandardItem *luaDbgWatchRootItem(QStandardItem *item)
{
    while (item && item->parent())
    {
        item = item->parent();
    }
    return item;
}

struct LuaDbgTreeSectionExpansionState
{
    bool rootExpanded = false;
    QStringList subpaths;
};

void luaDbgRecordTreeSectionRootExpansion(QHash<QString, LuaDbgTreeSectionExpansionState> &map, const QString &rootKey,
                                          bool expanded);

void luaDbgRecordTreeSectionSubpathExpansion(QHash<QString, LuaDbgTreeSectionExpansionState> &map,
                                             const QString &rootKey, const QString &key, bool expanded);

QStringList luaDbgTreeSectionExpandedSubpaths(const QHash<QString, LuaDbgTreeSectionExpansionState> &map,
                                              const QString &rootKey);


QString luaDebuggerSettingsFilePath();
 
namespace LuaDebuggerSettingsKeys
{
constexpr const char *DebuggerEnabled = "debuggerEnabled";
constexpr const char *MainSplitter = "mainSplitterState";
constexpr const char *LeftSplitter = "leftSplitterState";
constexpr const char *EvalSplitter = "evalSplitterState";
constexpr const char *SectionVariables = "sectionVariables";
constexpr const char *SectionStack = "sectionStack";
constexpr const char *SectionFiles = "sectionFiles";
constexpr const char *SectionBreakpoints = "sectionBreakpoints";
constexpr const char *SectionEval = "sectionEval";
constexpr const char *SectionWatch = "sectionWatch";
constexpr const char *Breakpoints = "breakpoints";
constexpr const char *Watches = "watches";
constexpr const char *BreakOnError = "breakOnError";
} // namespace LuaDebuggerSettingsKeys
 
// Tree widget UserRoles (must stay stable for persisted settings / model code).
constexpr qint32 FileTreePathRole = static_cast<qint32>(Qt::UserRole);
constexpr qint32 FileTreeIsDirectoryRole = static_cast<qint32>(Qt::UserRole + 1);
constexpr qint32 BreakpointFileRole = static_cast<qint32>(Qt::UserRole + 2);
constexpr qint32 BreakpointLineRole = static_cast<qint32>(Qt::UserRole + 3);
constexpr qint32 BreakpointConditionRole = static_cast<qint32>(Qt::UserRole + 30);
constexpr qint32 BreakpointHitCountRole = static_cast<qint32>(Qt::UserRole + 31);
constexpr qint32 BreakpointHitTargetRole = static_cast<qint32>(Qt::UserRole + 32);
constexpr qint32 BreakpointConditionErrRole = static_cast<qint32>(Qt::UserRole + 33);
constexpr qint32 BreakpointLogMessageRole = static_cast<qint32>(Qt::UserRole + 34);
constexpr qint32 BreakpointHitModeRole = static_cast<qint32>(Qt::UserRole + 35);
constexpr qint32 BreakpointLogAlsoPauseRole = static_cast<qint32>(Qt::UserRole + 36);
constexpr qint32 StackItemFileRole = static_cast<qint32>(Qt::UserRole + 4);
constexpr qint32 StackItemLineRole = static_cast<qint32>(Qt::UserRole + 5);
constexpr qint32 StackItemNavigableRole = static_cast<qint32>(Qt::UserRole + 6);
constexpr qint32 StackItemLevelRole = static_cast<qint32>(Qt::UserRole + 7);
constexpr qint32 VariablePathRole = static_cast<qint32>(Qt::UserRole + 8);
constexpr qint32 VariableTypeRole = static_cast<qint32>(Qt::UserRole + 9);
constexpr qint32 VariableCanExpandRole = static_cast<qint32>(Qt::UserRole + 10);
constexpr qint32 WatchSpecRole = static_cast<qint32>(Qt::UserRole + 11);
constexpr qint32 WatchSubpathRole = static_cast<qint32>(Qt::UserRole + 13);
constexpr qint32 WatchPendingNewRole = static_cast<qint32>(Qt::UserRole + 15);
constexpr qint32 ChangedFlashSerialRole = static_cast<qint32>(Qt::UserRole + 20);
 
constexpr qsizetype WATCH_TOOLTIP_MAX_CHARS = 4096;
constexpr int WATCH_EXPR_MAX_CHARS = 65536;
constexpr int CHANGED_FLASH_MS = 500;
constexpr int WATCH_PLACEHOLDER_DEFER_MS = 250;
constexpr QChar CHANGE_KEY_SEP = QChar(0x1F);

constexpr int kLuaDbgEvalOutputMaxLines = 5000;
 
extern const QKeySequence kLuaDbgCtxGoToLine;
extern const QKeySequence kLuaDbgCtxRunToLine;
extern const QKeySequence kLuaDbgCtxWatchEdit;
extern const QKeySequence kLuaDbgCtxWatchCopyValue;
extern const QKeySequence kLuaDbgCtxWatchDuplicate;
extern const QKeySequence kLuaDbgCtxWatchRemoveAll;
extern const QKeySequence kLuaDbgCtxAddWatch;
extern const QKeySequence kLuaDbgCtxToggleBreakpoint;
extern const QKeySequence kLuaDbgCtxReloadLuaPlugins;
extern const QKeySequence kLuaDbgCtxRemoveAllBreakpoints;

QKeySequence luaDbgSeqFromKeyEvent(const QKeyEvent *ke);
 
/* ===== from item_utils ===== */
 
namespace LuaDebuggerItems
{

inline QString rowColumnDisplayText(const QModelIndex &indexInRow, int col)
{
    if (!indexInRow.isValid())
    {
        return QString();
    }
    return indexInRow.sibling(indexInRow.row(), col).data(Qt::DisplayRole).toString();
}

inline QStandardItem *rowCol0(QStandardItemModel *model, QStandardItem *cell)
{
    if (!model || !cell)
    {
        return nullptr;
    }
    const QModelIndex ix = model->indexFromItem(cell);
    if (!ix.isValid())
    {
        return nullptr;
    }
    return model->itemFromIndex(ix.sibling(ix.row(), 0));
}

inline QStandardItem *cellAt(QStandardItemModel *model, QStandardItem *col0, int col)
{
    if (!model || !col0 || col0->column() != 0)
    {
        return nullptr;
    }
    QStandardItem *par = col0->parent();
    if (!par)
    {
        return model->item(col0->row(), col);
    }
    return par->child(col0->row(), col);
}

inline QString text(QStandardItemModel *model, QStandardItem *col0, int col)
{
    QStandardItem *c = cellAt(model, col0, col);
    return c ? c->text() : QString();
}

inline void setText(QStandardItemModel *model, QStandardItem *col0, int col, const QString &t)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setText(t);
    }
}

inline void setToolTip(QStandardItemModel *model, QStandardItem *col0, int col, const QString &tip)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setToolTip(tip);
    }
}

inline void setFont(QStandardItemModel *model, QStandardItem *col0, int col, const QFont &font)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setFont(font);
    }
}

inline void setForeground(QStandardItemModel *model, QStandardItem *col0, int col, const QBrush &brush)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setForeground(brush);
    }
}

inline void setBackground(QStandardItemModel *model, QStandardItem *col0, int col, const QBrush &brush)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setBackground(brush);
    }
}

inline void setIcon(QStandardItemModel *model, QStandardItem *col0, int col, const QIcon &icon)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setIcon(icon);
    }
}

inline void setTextAlignment(QStandardItemModel *model, QStandardItem *col0, int col, Qt::Alignment align)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setTextAlignment(align);
    }
}

inline QModelIndex indexCol0(QStandardItemModel *model, QStandardItem *col0)
{
    if (!model || !col0 || col0->column() != 0)
    {
        return QModelIndex();
    }
    return model->indexFromItem(col0);
}

inline bool isExpanded(QTreeView *tree, QStandardItemModel *model, QStandardItem *col0)
{
    const QModelIndex ix = indexCol0(model, col0);
    return ix.isValid() && tree->isExpanded(ix);
}

inline void setExpanded(QTreeView *tree, QStandardItemModel *model, QStandardItem *col0, bool expanded)
{
    const QModelIndex ix = indexCol0(model, col0);
    if (ix.isValid())
    {
        tree->setExpanded(ix, expanded);
    }
}
 
} // namespace LuaDebuggerItems
 
/* ===== from path_utils ===== */
 
namespace LuaDebuggerPath
{

struct LuaDbgInvalidFilterColors
{
    QColor fg; 
    QColor bg; 
};

LuaDbgInvalidFilterColors invalidFilterColors();

bool watchSpecIsGlobalScoped(const QString &spec);

bool variablesPathIsGlobalScoped(const QString &path);

QString changeKey(int stackLevel, const QString &path);

QString watchSpecFromChangeKey(const QString &key);

QString stripWatchExpressionErrorPrefix(const QString &errStr);

template <class Key, class Map>
bool shouldMarkChanged(const Map &baseline, const Key &key, const QString &newVal, bool flashNew = false)
{
    const auto it = baseline.constFind(key);
    if (it != baseline.constEnd())
    {
        return *it != newVal;
    }
    return flashNew && !baseline.isEmpty();
}

QString variableSectionRootKeyFromItem(const QStandardItem *item);

bool watchSpecUsesPathResolution(const QString &spec);

QString variableTreeChildPath(const QString &parentPath, const QString &nameText);

QString expressionWatchChildSubpath(const QString &parentSubpath, const QString &nameText);

bool variableChildrenShouldSortByName(const QString &parentPath);

struct VariableRowFields
{
    QString name;               
    QString value;              
    QString type;               
    bool canExpand = false;     
    QString childPath;          
};

VariableRowFields readVariableRowFields(const wslua_variable_t &v, const QString &parentPath);

void applyVariableExpansionIndicator(QStandardItem *anchor, bool canExpand, bool enabledOnlyPlaceholder,
                                     int columnCount = 3);

QString watchVariablePathForSpec(const QString &spec);

QString watchResolvedVariablePathForTooltip(const QString &spec);

void watchRootSetVariablePathRoleFromSpec(QStandardItem *row, const QString &spec);

QString watchPathOriginSuffix(const QStandardItem *item, const QString &spec);

QString capWatchTooltipText(const QString &s);

QString watchPathParentKey(const QString &path);

void applyWatchChildRowTextAndTooltip(QStandardItem *specItem, const QString &rawVal, const QString &typeText);

int watchSubpathBoundaryCount(const QString &subpath);

QStandardItem *findWatchItemBySubpathOrPathKey(QStandardItem *subtree, const QString &key);

QStandardItem *findVariableTreeItemByPathKey(QStandardItem *subtree, const QString &key);
 
using TreePathKeyFinder = QStandardItem *(*)(QStandardItem *, const QString &);

void reexpandTreeDescendantsByPathKeys(QTreeView *tree, QStandardItemModel *model, QStandardItem *subtree,
                                       QStringList pathKeys, TreePathKeyFinder findByKey);

void reexpandWatchDescendantsByPathKeys(QTreeView *tree, QStandardItemModel *model, QStandardItem *subtree,
                                        QStringList pathKeys);

void clearWatchFilterErrorChrome(QStandardItem *specItem, QTreeView *tree);

void applyWatchFilterErrorChrome(QStandardItem *specItem, QTreeView *tree);

void setupWatchRootItemFromSpec(QStandardItem *specItem, QStandardItem *valueItem, const QString &spec);

QStandardItem *findVariableItemByPathRecursive(QStandardItem *node, const QString &path);

QString watchItemExpansionKey(const QStandardItem *item);
 
} // namespace LuaDebuggerPath
 
/* ===== from header_styles ===== */

extern const QString kLuaDbgHeaderToolButtonStyle;
QIcon luaDbgCircleIcon(bool actions, const QColor &fill, const QColor &outline);

void luaDbgDrawBreakpointDot(QPainter &painter, qreal dotLeft, qreal dotTop, qreal radius, bool enabled,
                             const QColor &outlineColor, bool hasExtras = false, int alpha = 255);

enum class LuaDbgBpHeaderIconMode
{
    NoBreakpoints, 
    ActivateAll,   
    DeactivateAll, 
};

QIcon luaDbgBreakpointHeaderIconForMode(LuaDbgBpHeaderIconMode mode);

void styleLuaDebuggerHeaderIconOnlyButton(QToolButton *btn, int side, int iconGrow = 0);
 
/* ===== from key_router ===== */

class LuaDebuggerKeyRouter
{
public:
    explicit LuaDebuggerKeyRouter(LuaDebuggerDialog *host);

    void attach(Ui::LuaDebuggerDialog *ui, QTreeView *breakpointsTree);

    bool reserveShortcutOverride(const QKeyEvent *ke) const;

    bool handleKeyPress(QObject *obj, const QKeyEvent *ke);
 
private:
    LuaDebuggerDialog *host_;
    Ui::LuaDebuggerDialog *ui_ = nullptr;
    QTreeView *breakpointsTree_ = nullptr;
};
 
/* ===== from change_tracker ===== */

class LuaDebuggerChangeHighlightTracker
{
  public:
    LuaDebuggerChangeHighlightTracker() = default;

    void refreshChangedValueBrushes(QTreeView *watchTree, QWidget *paletteFallback);

    void snapshotBaselinesOnPauseEntry();

    void updatePauseEntryFrameIdentity();

    void setPauseEntryStackLevel(int level) { pauseEntryStackLevel_ = level; }

    void setPauseEntryRefresh(bool active) { isPauseEntryRefresh_ = active; }

    void applyChangedVisuals(QObject *timerOwner, QStandardItem *anchor, bool changed);

    void clearAllChangeBaselines();

    void clearWatchBaselines();

    void clearChangeBaselinesForWatchSpec(const QString &spec);

    void pruneChangeBaselinesToLiveWatchSpecs(QStandardItemModel *watchModel);

    bool changeHighlightAllowed(int stackSelectionLevel) const;

    bool observeWatchRootValue(const QString &rootKey, const QString &value);

    bool observeWatchChildParent(const QString &rootKey, const QString &parentPath);

    bool observeWatchChildValue(const QString &rootKey, const QString &childPath, const QString &value,
                                bool parentVisited);

    bool observeVariablesParent(const QString &parentKey);

    bool observeVariablesValue(const QString &variablesKey, const QString &value, bool parentVisited);
 
  private:
    QHash<QString /* rootKey */, QString> watchRootBaseline_;

    QHash<QString /* rootKey */, QString> watchRootCurrent_;

    QHash<QString /* rootKey */, QHash<QString /* childPath */, QString>> watchChildBaseline_;

    QHash<QString /* rootKey */, QHash<QString /* childPath */, QString>> watchChildCurrent_;

    QHash<QString /* variablesKey */, QString> variablesBaseline_;

    QHash<QString /* variablesKey */, QString> variablesCurrent_;

    QSet<QString /* variablesKey of parent */> variablesBaselineParents_;

    QSet<QString /* variablesKey of parent */> variablesCurrentParents_;

    QHash<QString /* rootKey */, QSet<QString /* parentPath */>> watchChildBaselineParents_;

    QHash<QString /* rootKey */, QSet<QString /* parentPath */>> watchChildCurrentParents_;

    QBrush changedValueBrush_;

    QBrush changedFlashBrush_;

    bool isPauseEntryRefresh_ = false;

    qint32 flashSerial_ = 0;

    int pauseEntryStackLevel_ = 0;

    QString pauseEntryFrame0Identity_;

    bool pauseEntryFrame0MatchesPrev_ = false;
};
 
#endif