Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

829 lines
23 KiB

/*****************************************************************************
*
* 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);
}