windows-xp/Source/XPSP1/NT/sdktools/sdv/filelog.cpp

/*****************************************************************************
 *
 *  filelog.cpp
 *
 *      View a filelog.
 *
 *****************************************************************************/

#include "sdview.h"

/*****************************************************************************
 *
 *  LogEntry
 *
 *  A single item in a filelog treelist.
 *
 *****************************************************************************/

class LogEntry : public TreeItem {

public:
    LogEntry(LPCTSTR pszRev,
             LPCTSTR pszChange,
             LPCTSTR pszOp,
             LPCTSTR pszDate,
             LPCTSTR pszDev);
    LogEntry() { }

    int GetRev() const { return _iRev; }

    void SetChildPath(LPCTSTR pszChildPath);
    const StringCache& GetChildPath() const { return _scChildPath; }

    void SetIntegrateType(LPCTSTR pszType);
    void SetIsDonor() { _fDonor = TRUE; }
    void SetComment(LPCTSTR pszComment) { _scComment = pszComment; }
    void SetDev(LPCTSTR pszDev) { _scDev = pszDev; }
    void SetFullDescription(LPCTSTR pszFullDescription) {  _scFullDescription = pszFullDescription; }
    void SetChurn(int cAdded, int cDeleted) { _cAdded = cAdded; _cDeleted = cDeleted; }
    BOOL IsChurnSet() const { return _cAdded >= 0; }

    LRESULT GetDispInfo(NMTREELIST *pdi, int iColumn);
    LRESULT GetInfoTip(NMTREELIST *pdi);

    LPCTSTR GetChange() const { return _scChange; }
    LPCTSTR GetComment() const { return _scComment; }

private:
    void GetRevDispInfo(NMTREELIST *ptl);
    void GetChurnDispInfo(NMTREELIST *ptl);
    void GetImage(NMTREELIST *ptl);
private:
    int         _iRev;                  // File revision number
    int         _cDeleted;              // Number of lines deleted
    int         _cAdded;                // Number of lines added
    int         _iOp;                   // Checkin operation
    BOOL        _fDonor;                // Is integration donor
    StringCache _scChange;              // Change number
    StringCache _scOp;                  // Checkin operation (edit, delete, tc.)
    StringCache _scDate;                // Checkin date
    StringCache _scDev;                 // Checkin dev
    StringCache _scComment;             // Checkin comment
    StringCache _scFullDescription;     // Full checkin description
    StringCache _scChildPath;           // Depot path of child items
};

void LogEntry::SetChildPath(LPCTSTR pszChildPath)
{
    String str(pszChildPath);

    LPTSTR pszSharp = StrChr(str, TEXT('#'));
    if (pszSharp) {
        LPTSTR pszComma = StrChr(pszSharp, TEXT(','));

        if (!pszComma) {
            String strT(pszSharp);
            str << TEXT(",") << strT;
        }
    }

    _scChildPath = str;

    SetExpandable();
}

LogEntryImageMap c_rgleim[] = {
    {   TEXT("?")                   ,      -1       },  // OP_UNKNOWN
    {   TEXT("edit")                ,       0       },  // OP_EDIT
    {   TEXT("delete")              ,       1       },  // OP_DELETE
    {   TEXT("add")                 ,       2       },  // OP_ADD
    {   TEXT("integrate")           ,       3       },  // OP_INTEGRATE
    {   TEXT("merge")               ,       3       },  // OP_MERGE
    {   TEXT("branch")              ,       4       },  // OP_BRANCH
    {   TEXT("copy")                ,       5       },  // OP_COPY
    {   TEXT("ignored")             ,       6       },  // OP_IGNORED
};

int ParseOp(LPCTSTR psz)
{
    int i;
    for (i = ARRAYSIZE(c_rgleim) - 1; i > 0; i--) {
        if (StrCmp(c_rgleim[i]._pszOp, psz) == 0) {
            break;
        }
    }
    return i;
}

void LogEntry::SetIntegrateType(LPCTSTR pszType)
{
    if (_iOp == OP_INTEGRATE) {
        _iOp = ParseOp(pszType);
    }
}

LogEntry::LogEntry(
             LPCTSTR pszRev,
             LPCTSTR pszChange,
             LPCTSTR pszOp,
             LPCTSTR pszDate,
             LPCTSTR pszDev)
    : _iRev(StrToInt(pszRev))
    , _scChange(pszChange)
    , _iOp(ParseOp(pszOp))
    , _scDate(pszDate)
    , _scDev(pszDev)
    , _cAdded(-1)
{
}

void LogEntry::GetImage(NMTREELIST *ptl)
{
    ptl->iSubItem = c_rgleim[_iOp]._iImage;
    ptl->cchTextMax = INDEXTOOVERLAYMASK(_fDonor);
}

//
// Combine the pszParent and the pszRev to form the real pszRev
// Since the rev is the more important thing, I will display it
// in the form
//
//      19 Lab06_DEV/foo.cpp
//
//

void LogEntry::GetRevDispInfo(NMTREELIST *ptl)
{
    OutputStringBuffer str(ptl->pszText, ptl->cchTextMax);
    str << _iRev;
    LogEntry *ple = SAFECAST(LogEntry*, Parent());
    if (ple->GetChildPath()) {
        str << TEXT(" ") << BranchOf(ple->GetChildPath()) <<
               TEXT("/") << FilenameOf(ple->GetChildPath());
    }
}

void LogEntry::GetChurnDispInfo(NMTREELIST *ptl)
{
    if (_cAdded >= 0) {
        OutputStringBuffer str(ptl->pszText, ptl->cchTextMax);
        str << _cDeleted << TEXT('/') << _cAdded;
    }
}


LRESULT LogEntry::GetDispInfo(NMTREELIST *ptl, int iColumn)
{
    switch (iColumn) {
    case -1: GetImage(ptl); break;
    case 0: GetRevDispInfo(ptl); break;
    case 1: ptl->pszText = _scChange; break;
    case 2: ptl->pszText = CCAST(LPTSTR, c_rgleim[_iOp]._pszOp); break;
    case 3: ptl->pszText = _scDate; break;
    case 4: ptl->pszText = _scDev; break;
    case 5: GetChurnDispInfo(ptl); break;
    case 6: ptl->pszText = _scComment; break;
    }
    return 0;
}


LRESULT LogEntry::GetInfoTip(NMTREELIST *ptl)
{
    ptl->pszText = _scFullDescription;
    return 0;
}

/*****************************************************************************
 *
 *  class CFileLog
 *
 *****************************************************************************/

class CFileLog : public TLFrame {

    friend DWORD CALLBACK CFileLog_ThreadProc(LPVOID lpParameter);

protected:
    LRESULT HandleMessage(UINT uiMsg, WPARAM wParam, LPARAM lParam);

private:

    enum {
        FL_INITIALIZE = WM_APP
    };

    typedef TLFrame super;

    LRESULT ON_WM_CREATE(UINT uiMsg, WPARAM wParam, LPARAM lParam);
    LRESULT ON_WM_COMMAND(UINT uiMsg, WPARAM wParam, LPARAM lParam);
    LRESULT ON_WM_INITMENU(UINT uiMsg, WPARAM wParam, LPARAM lParam);
    LRESULT ON_WM_NOTIFY(UINT uiMsg, WPARAM wParam, LPARAM lParam);
    LRESULT ON_FL_INITIALIZE(UINT uiMsg, WPARAM wParam, LPARAM lParam);

private:                            /* Helpers */
    CFileLog() : TLFrame(new LogEntry)
    {
        SetAcceleratorTable(MAKEINTRESOURCE(IDA_FILELOG));
    }

    LogEntry *LEGetCurSel() { return SAFECAST(LogEntry*, TLGetCurSel()); }

    // -ds support was added in version 1.50
    BOOL IsChurnEnabled()
        { return GlobalSettings.IsChurnEnabled() &&
                 GlobalSettings.IsVersion(1, 50); }

    BOOL _ChooseColumns();
    BOOL _ParseQuery();
    LRESULT _FillChildren(LogEntry *pleRoot, LPCTSTR pszRootPath);
    LRESULT _OnItemActivate(LogEntry *ple);
    LRESULT _OnGetContextMenu(LogEntry *ple);

    BOOL _IsViewFileLogEnabled(LogEntry *ple);
    LRESULT _ViewFileLog(LogEntry *ple);
    LRESULT _ViewChangelist(LogEntry *ple);
    void _AdjustMenu(HMENU hmenu, LogEntry *ple, BOOL fContextMenu);

    int _GetChangeNumber(LogEntry *ple);
    int _GetBugNumber(LogEntry *ple);

    struct FLCOLUMN {
        const LVFCOLUMN*    _rgcol;
        const int *         _rgColMap;
        int                 _ccol;
    };

private:
    const FLCOLUMN*     _pflc;
    BOOL                _fIsRestrictedRoot;

    // Used during initialization
    int                 _iHighlightRev;
    LogEntry *          _pleHighlight;
    StringCache         _scSwitches;
    StringCache         _scPath;
};

BOOL CFileLog::_ChooseColumns()
{
    static const LVFCOLUMN c_rgcolChurn[] = {
        { 30 ,IDS_COL_REV       ,LVCFMT_LEFT    },
        {  7 ,IDS_COL_CHANGE    ,LVCFMT_RIGHT   },
        {  7 ,IDS_COL_OP        ,LVCFMT_LEFT    },
        { 15 ,IDS_COL_DATE      ,LVCFMT_LEFT    },
        { 10 ,IDS_COL_DEV       ,LVCFMT_LEFT    },
        {  7 ,IDS_COL_CHURN     ,LVCFMT_LEFT    },
        { 30 ,IDS_COL_COMMENT   ,LVCFMT_LEFT    },
        {  0 ,0                 ,0              },
    };

    static const int c_rgiChurn[] = { 0, 1, 2, 3, 4, 5, 6 };

    static const FLCOLUMN c_flcChurn = {
        c_rgcolChurn,
        c_rgiChurn,
        ARRAYSIZE(c_rgiChurn),
    };

    static const LVFCOLUMN c_rgcolNoChurn[] = {
        { 30 ,IDS_COL_REV       ,LVCFMT_LEFT    },
        {  7 ,IDS_COL_CHANGE    ,LVCFMT_RIGHT   },
        {  7 ,IDS_COL_OP        ,LVCFMT_LEFT    },
        { 15 ,IDS_COL_DATE      ,LVCFMT_LEFT    },
        { 10 ,IDS_COL_DEV       ,LVCFMT_LEFT    },
        { 30 ,IDS_COL_COMMENT   ,LVCFMT_LEFT    },
        {  0 ,0                 ,0              },
    };

    static const int c_rgiNoChurn[] = { 0, 1, 2, 3, 4, 6 };

    static const FLCOLUMN c_flcNoChurn = {
        c_rgcolNoChurn,
        c_rgiNoChurn,
        ARRAYSIZE(c_rgiNoChurn),
    };

    if (IsChurnEnabled()) {
        _pflc = &c_flcChurn;
    } else {
        _pflc = &c_flcNoChurn;
    }

    return AddColumns(_pflc->_rgcol);
}


LRESULT CFileLog::ON_WM_CREATE(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
    LRESULT lres;

    if (_ParseQuery()) {
        lres = super::HandleMessage(uiMsg, wParam, lParam);
        if (lres == 0 &&
            _tree.GetRoot() &&
            SetWindowMenu(MAKEINTRESOURCE(IDM_FILELOG)) &&
            CreateChild(LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS |
                        LVS_NOSORTHEADER,
                        LVS_EX_LABELTIP | LVS_EX_HEADERDRAGDROP |
                        LVS_EX_INFOTIP | LVS_EX_FULLROWSELECT) &&
            _ChooseColumns()) {
            PostMessage(_hwnd, FL_INITIALIZE, 0, 0);
        } else {
            lres = -1;
        }
    } else {
        Help(_hwnd, TEXT("#filel"));
        lres = -1;
    }
    return lres;
}

LRESULT CFileLog::ON_FL_INITIALIZE(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
    _FillChildren(SAFECAST(LogEntry*, _tree.GetRoot()), _scPath);
    _tree.Expand(_tree.GetRoot());

    // Clean out the stuff that's used only for the initial root expand
    _scSwitches = NULL;
    _iHighlightRev = 0;
    if (_pleHighlight) {
        _tree.SetCurSel(_pleHighlight);
    } else {
        ListView_SetCurSel(_hwndChild, 0);
    }
    return 0;
}

int CFileLog::_GetBugNumber(LogEntry *ple)
{
    if (ple) {
        return ParseBugNumber(ple->GetComment());
    } else {
        return 0;
    }
}

int CFileLog::_GetChangeNumber(LogEntry *ple)
{
    if (ple) {
        return StrToInt(ple->GetChange());
    } else {
        return 0;
    }
}

//
//  View Filelog is enabled if it would show you something different
//  from what you're looking at right now.
//
BOOL CFileLog::_IsViewFileLogEnabled(LogEntry *ple)
{
    if (!ple) {
        return FALSE;               // not even an item!
    }

    if (_fIsRestrictedRoot) {
        return TRUE;                // View Filelog shows unrestricted
    }

    //
    //  Short-circuit the common case where you are already at top-level.
    //
    if (ple->Parent() == _tree.GetRoot()) {
        return FALSE;               // You're looking at it already
    }

    //
    //  Watch out for the loopback scenario where you chase integrations
    //  out and then back in...
    //
    LPCTSTR pszRoot = SAFECAST(LogEntry *, _tree.GetRoot())->GetChildPath();
    LPCTSTR pszThis = SAFECAST(LogEntry *, ple->Parent())->GetChildPath();
    int cchRoot = lstrlen(pszRoot);

    if (StrCmpNI(pszRoot, pszThis, cchRoot) == 0 &&
        (pszThis[cchRoot] == TEXT('#') || pszThis[cchRoot] == TEXT('\0'))) {
        return FALSE;
    }

    return TRUE;
}

LRESULT CFileLog::_ViewFileLog(LogEntry *ple)
{
    if (!_IsViewFileLogEnabled(ple)) {
        return 0;
    }

    Substring ss;
    if (Parse(TEXT("$P"), SAFECAST(LogEntry *, ple->Parent())->GetChildPath(), &ss)) {
        String str;
        str << TEXT("-#") << ple->GetRev() << TEXT(" ") << ss;
        LaunchThreadTask(CFileLog_ThreadProc, str);
    }
    return 0;
}

LRESULT CFileLog::_ViewChangelist(LogEntry *ple)
{
    if (ple) {
        LaunchThreadTask(CDescribe_ThreadProc, ple->GetChange());
    }
    return 0;
}

LRESULT CFileLog::ON_WM_COMMAND(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
    int iChange, iBug;

    switch (GET_WM_COMMAND_ID(wParam, lParam)) {
    case IDM_VIEWDESC:
        return _ViewChangelist(LEGetCurSel());

    case IDM_VIEWFILEDIFF:
        return _OnItemActivate(LEGetCurSel());

    case IDM_VIEWWINDIFF:
        WindiffChangelist(_GetChangeNumber(LEGetCurSel()));
        return 0;

    case IDM_VIEWBUG:
        iBug = _GetBugNumber(LEGetCurSel());
        if (iBug) {
            OpenBugWindow(_hwnd, iBug);
        }
        break;

    case IDM_VIEWFILELOG:
        _ViewFileLog(LEGetCurSel());
        break;
    }
    return super::HandleMessage(uiMsg, wParam, lParam);
}

void CFileLog::_AdjustMenu(HMENU hmenu, LogEntry *ple, BOOL fContextMenu)
{
    AdjustBugMenu(hmenu, _GetBugNumber(ple), fContextMenu);

    // Disable IDM_VIEWFILELOG if it would just show you the same window
    // you're looking at right now.
    BOOL fEnable = _IsViewFileLogEnabled(ple);
    EnableDisableOrRemoveMenuItem(hmenu, IDM_VIEWFILELOG, fEnable, fContextMenu);
}

LRESULT CFileLog::ON_WM_INITMENU(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
    _AdjustMenu(RECAST(HMENU, wParam), LEGetCurSel(), FALSE);
    return 0;
}

LRESULT CFileLog::_OnGetContextMenu(LogEntry *ple)
{
    HMENU hmenu = LoadPopupMenu(MAKEINTRESOURCE(IDM_FILELOG_POPUP));
    if (hmenu) {
        _AdjustMenu(hmenu, ple, TRUE);
    }
    return RECAST(LRESULT, hmenu);
}

LRESULT CFileLog::_OnItemActivate(LogEntry *ple)
{
    if (ple) {
        LogEntry *pleParent = SAFECAST(LogEntry*, ple->Parent());

        // Trim the parent path to remove the sharp.
        String strPath(pleParent->GetChildPath());
        LPTSTR pszSharp = StrChr(strPath, TEXT('#'));
        if (pszSharp) {
            strPath.SetLength((int)(pszSharp - strPath));
        }

        // Append the version we care about
        strPath << TEXT('#') << ple->GetRev();

        // And ask windiff to view it

        WindiffOneChange(strPath);
    }
    return 0;
}

LRESULT CFileLog::ON_WM_NOTIFY(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
    NMTREELIST *ptl = RECAST(NMTREELIST*, lParam);
    LogEntry *ple;

    switch (ptl->hdr.code) {
    case TLN_GETDISPINFO:
        ple = SAFECAST(LogEntry*, ptl->pti);
        if (ptl->iSubItem < 0) {
            return ple->GetDispInfo(ptl, ptl->iSubItem);
        } else if (ptl->iSubItem < _pflc->_ccol) {
            return ple->GetDispInfo(ptl, _pflc->_rgColMap[ptl->iSubItem]);
        } else {
            ASSERT(0); // invalid column
            return 0;
        }

    case TLN_FILLCHILDREN:
        ple = SAFECAST(LogEntry*, ptl->pti);
        return _FillChildren(ple, ple->GetChildPath());

    case TLN_ITEMACTIVATE:
        ple = SAFECAST(LogEntry*, ptl->pti);
        return _OnItemActivate(ple);

    case TLN_GETINFOTIP:
        ple = SAFECAST(LogEntry*, ptl->pti);
        return ple->GetInfoTip(ptl);

    case TLN_DELETEITEM:
        ple = SAFECAST(LogEntry*, ptl->pti);
        delete ple;
        return 0;

    case TLN_GETCONTEXTMENU:
        ple = SAFECAST(LogEntry*, ptl->pti);
        return _OnGetContextMenu(ple);
    }

    return super::HandleMessage(uiMsg, wParam, lParam);
}

LRESULT
CFileLog::HandleMessage(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uiMsg) {
    FW_MSG(WM_CREATE);
    FW_MSG(WM_COMMAND);
    FW_MSG(WM_INITMENU);
    FW_MSG(WM_NOTIFY);
    FW_MSG(FL_INITIALIZE);
    }

    return super::HandleMessage(uiMsg, wParam, lParam);
}

//
//  A private helper class that captures the parsing state machine.
//

class FileLogParseState : public CommentParser
{
public:
    FileLogParseState() : _pleCurrent(NULL), _pleInsertAfter(NULL) { }

    LogEntry *GetCurrentLogEntry() const { return _pleCurrent; }

    void Flush()
    {
        if (_pleCurrent) {
            //
            //  Trim the trailing CRLF off the last line of the full
            //  description.
            //
            _strFullDescription.Chomp();
            _pleCurrent->SetFullDescription(_strFullDescription);
            _pleCurrent = NULL;
        }
        _cAdded = _cDeleted = 0;
        CommentParser::Reset();
        _strFullDescription.Reset();
    }

    void AddEntry(Tree &tree, LogEntry *pleRoot, String& str, Substring *rgss)
    {
        LPCTSTR pszChildPath = pleRoot->GetChildPath();
        _strFullDescription.Append(pszChildPath, StrCSpn(pszChildPath, TEXT("#")));
        _strFullDescription << TEXT("\r\n") << str;
        LogEntry *ple = new LogEntry(rgss[0].Finalize(),    // Rev
                                     rgss[1].Finalize(),    // Change
                                     rgss[2].Finalize(),    // Op
                                     rgss[3].Finalize(),    // Date
                                     rgss[4].Finalize());   // Dev
        if (ple) {
            if (tree.Insert(ple, pleRoot, _pleInsertAfter)) {
                _pleInsertAfter = _pleCurrent = ple;
            } else {
                delete ple;
            }
        }
    }

    void AddLine(const String& str)
    {
        _strFullDescription << str;
    }

    void SetDev(LPCTSTR psz)
    {
        if (_pleCurrent) {
            _pleCurrent->SetDev(psz);
        }
    }

    void SetComment(LPCTSTR psz)
    {
        if (_pleCurrent) {
            _pleCurrent->SetComment(psz);
        }
    }


    void SetIntegrateType(LPCTSTR pszType, LPCTSTR pszDepotPath)
    {
        if (_pleCurrent) {
            _pleCurrent->SetIntegrateType(pszType);
            _pleCurrent->SetChildPath(pszDepotPath);
        }
    }

    void SetIsDonor()
    {
        if (_pleCurrent) {
            _pleCurrent->SetIsDonor();
        }
    }

    void AddedLines(LPCTSTR psz)
    {
        _cAdded += StrToInt(psz);
    }

    void DeletedLines(LPCTSTR psz)
    {
        _cDeleted += StrToInt(psz);
    }

    void SetChurn()
    {
        if (_pleCurrent) {
            _pleCurrent->SetChurn(_cAdded, _cDeleted);
        }
    }

    void ParseDiffResult(String& str)
    {
        Substring rgss[3];

        if (Parse(TEXT("add $d chunks $d"), str, rgss)) {
            AddedLines(rgss[1].Finalize());
        } else if (Parse(TEXT("deleted $d chunks $d"), str, rgss)) {
            DeletedLines(rgss[1].Finalize());
        } else if (Parse(TEXT("changed $d chunks $d / $d"), str, rgss)) {
            DeletedLines(rgss[1].Finalize());
            AddedLines(rgss[2].Finalize());
            SetChurn();
        }
    }

    BOOL GetFinishDiffCommand(LPCTSTR pszRootPath, String& str)
    {
        if (_pleCurrent && !_pleCurrent->IsChurnSet() && _pleCurrent->GetRev() > 1) {
            str = TEXT("diff2 -ds \"");
            int cchRootPath = StrCSpn(pszRootPath, TEXT("#"));
            str.Append(pszRootPath, cchRootPath);
            str << TEXT("#") << (_pleCurrent->GetRev() - 1) << TEXT("\" \"");
            str.Append(pszRootPath, cchRootPath);
            str << TEXT("#") <<  _pleCurrent->GetRev()      << TEXT("\"");
            return TRUE;
        } else {
            return FALSE;
        }
    }

private:
    int         _cAdded;
    int         _cDeleted;
    LogEntry   *_pleCurrent;
    LogEntry   *_pleInsertAfter;
    String      _strFullDescription;
};

BOOL CFileLog::_ParseQuery()
{
    String str;

    /*
     *  Parse the switches as best we can.
     *
     */
    str.Reset();
    GetOpt opt(TEXT("m#"), _pszQuery);
    for (;;) {

        switch (opt.NextSwitch()) {
        case TEXT('m'):
            _fIsRestrictedRoot = TRUE;
            str << TEXT("-m ") << opt.GetValue() << TEXT(" ");
            break;

        case TEXT('#'):
            _iHighlightRev = StrToInt(opt.GetValue());
            break;

        case TEXT('\0'):
            goto L_switch;    // two-level break

        default:
            // Caller will display help for us
            return FALSE;
        }
    }
L_switch:;

    _scSwitches = str;

    str.Reset();
    str << TEXT("sdv filelog ") << _scSwitches << opt.GetTokenizer().Unparsed();
    SetWindowText(_hwnd, str);

    /*
     *  There must be exactly one token remaining and it can't be a
     *  wildcard.
     */
    if (opt.Token() && opt.Finished() && !ContainsWildcards(opt.GetValue())) {
        _scPath = opt.GetValue();
        if (StrChr(_scPath, TEXT('#')) || StrChr(_scPath, TEXT('@'))) {
            _fIsRestrictedRoot = TRUE;
        }

    } else {
        return FALSE;
    }

    return TRUE;
}

LRESULT CFileLog::_FillChildren(LogEntry *pleRoot, LPCTSTR pszRootPath)
{
    LRESULT lres = 0;
    if (!pszRootPath[0]) {
        return -1;
    }

    WaitCursor wait;

    String str("filelog -l ");
    str << _scSwitches;
    if (IsChurnEnabled()) {
        str << TEXT("-ds ");
    }

    str << ResolveBranchAndQuoteSpaces(pszRootPath);

    SDChildProcess proc(str);
    FileLogParseState state;
    IOBuffer buf(proc.Handle());
    while (buf.NextLine(str)) {

        Substring rgss[5];  // Rev, Change, Op, Date, Dev
        LPTSTR pszRest;

        if (Parse(TEXT("... #$d change $d $w on $D by $u"), str, rgss)) {
            state.Flush();
            state.AddEntry(_tree, pleRoot, str, rgss);
            if (state.GetCurrentLogEntry() &&
                state.GetCurrentLogEntry()->GetRev() == _iHighlightRev) {
                _pleHighlight = state.GetCurrentLogEntry();
            }
        } else if (Parse(TEXT("$P"), str, rgss)) {
            if (pleRoot->GetChildPath().IsEmpty()) {
                str.Chomp();
                pleRoot->SetChildPath(rgss[0].Finalize());
            }
        } else {
            state.AddLine(str);
            str.Chomp();
            if (str[0] == TEXT('\t')) {
                state.AddComment(str+1);
            } else if ((pszRest = Parse(TEXT("... ... $w from "), str, rgss)) != NULL) {
                state.SetIntegrateType(rgss[0].Finalize(), pszRest);
            } else if (Parse(TEXT("... ... $w into "), str, rgss) ||
                       Parse(TEXT("... ... ignored by "), str, rgss)) {
                state.SetIsDonor();

                // SUBTLE!  We check for "ignored" after "ignored by".
            } else if ((pszRest = Parse(TEXT("... ... ignored "), str, rgss)) != NULL) {
                state.SetIntegrateType("ignored", pszRest);
            } else {
                state.ParseDiffResult(str);
            }
        }
    }

    // "sd filelog -d" doesn't spit out a diff for the last guy,
    // so kick off a special one-shot "sd diff2" to get that diff.
    if (IsChurnEnabled() &&
        state.GetFinishDiffCommand(pszRootPath, str)) {
        SDChildProcess proc2(str);
        if (proc2.IsRunning()) {
            buf.Init(proc2.Handle());
            while (buf.NextLine(str)) {
                state.AddLine(str);
                state.ParseDiffResult(str);
            }
        }
    }

    state.Flush();

    return lres;
}

DWORD CALLBACK CFileLog_ThreadProc(LPVOID lpParameter)
{
    return FrameWindow::RunThread(new CFileLog, lpParameter);
}