2557 lines
72 KiB
C++
2557 lines
72 KiB
C++
//====== Copyright © 1996-2005, Valve Corporation, All rights reserved. =======
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
// prevent Error function from being defined, since it inteferes with the P4 API
|
|
#define Error Warning
|
|
#include "p4lib/ip4.h"
|
|
#include "tier1/utlvector.h"
|
|
#include "tier1/utlsymbol.h"
|
|
#include "tier1/utlbuffer.h"
|
|
#include "tier1/utlstring.h"
|
|
#include "tier1/utlmap.h"
|
|
#include "tier1/characterset.h"
|
|
|
|
#include "filesystem.h"
|
|
#undef Error
|
|
|
|
#undef Verify
|
|
#include "clientapi.h"
|
|
|
|
#include <time.h>
|
|
#include <ctype.h>
|
|
#include <io.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <windows.h>
|
|
|
|
#define CLIENTSPEC_BUFFER_SIZE (16 * 1024)
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Stores info about the client path
|
|
//-----------------------------------------------------------------------------
|
|
struct CClientPathRecord
|
|
{
|
|
char m_szDepotPath[MAX_PATH];
|
|
char m_szClientPath[MAX_PATH];
|
|
bool m_bNegative;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Global interfaces
|
|
//-----------------------------------------------------------------------------
|
|
#if defined(STANDALONE_VPC)
|
|
#include "../utils/vpc/sys_utils.h"
|
|
#define FileExists( arg ) Sys_Exists( arg )
|
|
#define ReadFile( path, unused, buf ) Sys_LoadFileIntoBuffer( path, buf, false )
|
|
#else
|
|
static IFileSystem *g_pFileSystem;
|
|
#define FileExists( arg ) g_pFileSystem->FileExists( arg )
|
|
#define ReadFile( path, unused, buf ) g_pFilesystem->ReadFile( path, unused, buf )
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Interface to accessing P4 commands
|
|
//-----------------------------------------------------------------------------
|
|
class CP4 : public CBaseAppSystem<IP4>
|
|
{
|
|
public:
|
|
// Destructor
|
|
virtual ~CP4();
|
|
|
|
// Methods of IAppSystem
|
|
virtual bool Connect( CreateInterfaceFn factory );
|
|
virtual InitReturnVal_t Init();
|
|
virtual void *QueryInterface( const char *pInterfaceName );
|
|
virtual void Shutdown();
|
|
virtual void Disconnect();
|
|
|
|
// Inherited from IP4
|
|
P4Client_t &GetActiveClient();
|
|
virtual void RefreshActiveClient();
|
|
virtual void SetActiveClient(const char *clientname);
|
|
virtual void GetDepotFilePath(char *depotFilePath, const char *filespec, int size);
|
|
virtual void GetClientFilePath(char *clientFilePath, const char *filespec, int size);
|
|
virtual void GetLocalFilePath(char *localFilePath, const char *filespec, int size);
|
|
virtual CUtlVector<P4File_t> &GetFileList(const char *path);
|
|
virtual CUtlVector<P4File_t> &GetFileListUsingClientSpec( const char *pPath, const char *pClientSpec );
|
|
virtual void GetOpenedFileList( CUtlVector<P4File_t> &fileList, bool bDefaultChangeOnly );
|
|
virtual void GetOpenedFileList( const char *pRootDirectory, CUtlVector<P4File_t> &fileList );
|
|
virtual void GetOpenedFileListInPath( const char *pPathID, CUtlVector<P4File_t> &fileList );
|
|
virtual void GetFileListInChangelist( unsigned int changeListNumber, CUtlVector<P4File_t> &fileList );
|
|
|
|
virtual CUtlVector<P4Revision_t> &GetRevisionList(const char *path, bool bIsDir);
|
|
virtual CUtlVector<P4Client_t> &GetClientList();
|
|
virtual void RemovePathFromActiveClientspec(const char *path);
|
|
virtual void SetOpenFileChangeList( const char *pChangeListName );
|
|
virtual bool OpenFileForAdd( const char *fullpath );
|
|
virtual bool OpenFileForEdit(const char *fullpath);
|
|
virtual bool OpenFileForDelete(const char *fullpath);
|
|
virtual bool SyncFile( const char *pFullPath, int nRevision = -1 );
|
|
virtual bool SubmitFile( const char *pFullPath, const char *pDescription );
|
|
virtual bool RevertFile( const char *pFullPath );
|
|
virtual bool OpenFilesForAdd( int nCount, const char **ppFullPathList );
|
|
virtual bool OpenFilesForEdit( int nCount, const char **ppFullPathList );
|
|
virtual bool OpenFilesForDelete( int nCount, const char **ppFullPathList );
|
|
virtual bool SubmitFiles( int nCount, const char **ppFullPathList, const char *pDescription );
|
|
virtual bool RevertFiles( int nCount, const char **ppFullPathList );
|
|
virtual bool IsFileInPerforce( const char *fullpath );
|
|
virtual P4FileState_t GetFileState( const char *pFullPath );
|
|
virtual bool GetFileInfo( const char *pFullPath, P4File_t *pFileInfo );
|
|
|
|
virtual const char *GetDepotRoot();
|
|
virtual int GetDepotRootLength();
|
|
virtual const char *GetLocalRoot();
|
|
virtual int GetLocalRootLength();
|
|
virtual const char *String( CUtlSymbol s ) const;
|
|
virtual bool GetClientSpecForFile( const char *pFullPath, char *pClientSpec, int nMaxLen );
|
|
virtual bool GetClientSpecForDirectory( const char *pFullPathDir, char *pClientSpec, int nMaxLen );
|
|
virtual bool GetClientSpecForPath( const char *pPathId, char *pClientSpec, int nMaxLen );
|
|
virtual void OpenFileInP4Win( const char *pFullPath );
|
|
virtual bool IsConnectedToServer( bool bRetry = true );
|
|
virtual const char *GetLastError();
|
|
char const * GetOpenFileChangeListNum(); // Returns NULL for default
|
|
|
|
// Convert a depot file to a local file user the current client mapping
|
|
bool DepotFileToLocalFile( const char *pDepotFile, char *pLocalFile, int nBufLen );
|
|
|
|
// Accessors
|
|
ClientApi &GetClientApi() { return m_Client; }
|
|
ClientUser &GetClientUser() { return m_User; }
|
|
|
|
private:
|
|
// Helper for operations on multiple files
|
|
typedef void (*PerforceOp_t)( int nCount, const char **ppFullPathList, const char *pDescription );
|
|
bool PerformPerforceOp( PerforceOp_t op, int nCount, const char **ppFullPathList, const char *pDescription );
|
|
bool PerformPerforceOp( const char *pOperation, int nCount, const char **ppFullPathList );
|
|
bool PerformPerforceOp( const char *pOperation, const char *pFullPath );
|
|
|
|
bool PerformPerforceOpCurChangeList( const char *pOperation, int nCount, const char **ppFullPathList );
|
|
bool PerformPerforceOpCurChangeList( const char *pOperation, const char *pFullPath );
|
|
|
|
void RefreshClientData();
|
|
|
|
bool m_bConnectedToServer;
|
|
P4Client_t m_ActiveClient;
|
|
CUtlVector< CClientPathRecord > m_ClientMapping;
|
|
char m_szDepotRoot[_MAX_PATH];
|
|
char m_szLocalRoot[_MAX_PATH];
|
|
int m_iDepotRootLength;
|
|
int m_iLocalRootLength;
|
|
CUtlString m_sChangeListName, m_sCachedChangeListNum;
|
|
int m_nCachedChangeListNumber;
|
|
|
|
// internal
|
|
ClientApi m_Client;
|
|
ClientUser m_User;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// global instance
|
|
//-----------------------------------------------------------------------------
|
|
CP4 s_p4;
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CP4, IP4, P4_INTERFACE_VERSION, s_p4 );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Scoped class to push and pop a particular client spec
|
|
//-----------------------------------------------------------------------------
|
|
class CScopedClientSpec
|
|
{
|
|
public:
|
|
CScopedClientSpec( const char *pClientSpec );
|
|
~CScopedClientSpec();
|
|
|
|
private:
|
|
char m_pOldClientSpec[MAX_PATH];
|
|
bool m_bClientSpecNeedsRestore;
|
|
};
|
|
|
|
CScopedClientSpec::CScopedClientSpec( const char *pClientSpec )
|
|
{
|
|
m_bClientSpecNeedsRestore = false;
|
|
V_strncpy( m_pOldClientSpec, s_p4.GetClientApi().GetClient().Text(), sizeof(m_pOldClientSpec) );
|
|
if ( V_stricmp( m_pOldClientSpec, pClientSpec ) )
|
|
{
|
|
s_p4.SetActiveClient( pClientSpec );
|
|
m_bClientSpecNeedsRestore = true;
|
|
}
|
|
}
|
|
|
|
CScopedClientSpec::~CScopedClientSpec()
|
|
{
|
|
if ( m_bClientSpecNeedsRestore )
|
|
{
|
|
s_p4.SetActiveClient( m_pOldClientSpec );
|
|
}
|
|
}
|
|
|
|
|
|
class CScopedFileClientSpec
|
|
{
|
|
public:
|
|
CScopedFileClientSpec( const char *pFullPath );
|
|
~CScopedFileClientSpec();
|
|
|
|
private:
|
|
char m_pOldClientSpec[MAX_PATH];
|
|
bool m_bClientSpecNeedsRestore;
|
|
};
|
|
|
|
CScopedFileClientSpec::CScopedFileClientSpec( const char *pFullPath )
|
|
{
|
|
m_bClientSpecNeedsRestore = false;
|
|
char pClientSpec[MAX_PATH];
|
|
if ( s_p4.GetClientSpecForFile( pFullPath, pClientSpec, sizeof(pClientSpec) ) )
|
|
{
|
|
V_strncpy( m_pOldClientSpec, s_p4.GetClientApi().GetClient().Text(), sizeof(m_pOldClientSpec) );
|
|
if ( V_stricmp( m_pOldClientSpec, pClientSpec ) )
|
|
{
|
|
s_p4.SetActiveClient( pClientSpec );
|
|
m_bClientSpecNeedsRestore = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
CScopedFileClientSpec::~CScopedFileClientSpec()
|
|
{
|
|
if ( m_bClientSpecNeedsRestore )
|
|
{
|
|
s_p4.SetActiveClient( m_pOldClientSpec );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Scoped class to push and pop a particular client spec
|
|
//-----------------------------------------------------------------------------
|
|
class CScopedDirClientSpec
|
|
{
|
|
public:
|
|
CScopedDirClientSpec( const char *pFullPathDir );
|
|
~CScopedDirClientSpec();
|
|
|
|
private:
|
|
char m_pOldClientSpec[MAX_PATH];
|
|
bool m_bClientSpecNeedsRestore;
|
|
};
|
|
|
|
CScopedDirClientSpec::CScopedDirClientSpec( const char *pFullPathDir )
|
|
{
|
|
m_bClientSpecNeedsRestore = false;
|
|
char pClientSpec[MAX_PATH];
|
|
if ( s_p4.GetClientSpecForDirectory( pFullPathDir, pClientSpec, sizeof(pClientSpec) ) )
|
|
{
|
|
V_strncpy( m_pOldClientSpec, s_p4.GetClientApi().GetClient().Text(), sizeof(m_pOldClientSpec) );
|
|
if ( V_stricmp( m_pOldClientSpec, pClientSpec ) )
|
|
{
|
|
s_p4.SetActiveClient( pClientSpec );
|
|
m_bClientSpecNeedsRestore = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
CScopedDirClientSpec::~CScopedDirClientSpec()
|
|
{
|
|
if ( m_bClientSpecNeedsRestore )
|
|
{
|
|
s_p4.SetActiveClient( m_pOldClientSpec );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Scoped class to push and pop a particular client spec
|
|
//-----------------------------------------------------------------------------
|
|
class CScopedPathClientSpec
|
|
{
|
|
public:
|
|
CScopedPathClientSpec( const char *pPathID );
|
|
~CScopedPathClientSpec();
|
|
|
|
private:
|
|
char m_pOldClientSpec[MAX_PATH];
|
|
bool m_bClientSpecNeedsRestore;
|
|
};
|
|
|
|
CScopedPathClientSpec::CScopedPathClientSpec( const char *pPathID )
|
|
{
|
|
m_bClientSpecNeedsRestore = false;
|
|
char pClientSpec[MAX_PATH];
|
|
if ( s_p4.GetClientSpecForPath( pPathID, pClientSpec, sizeof(pClientSpec) ) )
|
|
{
|
|
V_strncpy( m_pOldClientSpec, s_p4.GetClientApi().GetClient().Text(), sizeof(m_pOldClientSpec) );
|
|
s_p4.SetActiveClient( pClientSpec );
|
|
m_bClientSpecNeedsRestore = true;
|
|
}
|
|
}
|
|
|
|
CScopedPathClientSpec::~CScopedPathClientSpec()
|
|
{
|
|
if ( m_bClientSpecNeedsRestore )
|
|
{
|
|
s_p4.SetActiveClient( m_pOldClientSpec );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: utility function to split a typical P4 line output into var and value
|
|
//-----------------------------------------------------------------------------
|
|
static void SplitP4Output(const char *data, char *pszCmd, char *pszInfo, int bufLen)
|
|
{
|
|
V_strncpy(pszCmd, data, bufLen);
|
|
|
|
char *mid = V_strstr(pszCmd, " ");
|
|
if (mid)
|
|
{
|
|
*mid = 0;
|
|
V_strncpy(pszInfo, data + (mid - pszCmd) + 1, bufLen);
|
|
}
|
|
else
|
|
{
|
|
pszInfo[0] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: base class for parse input from the P4 server
|
|
//-----------------------------------------------------------------------------
|
|
template< class T >
|
|
class CDataRetrievalUser : public ClientUser
|
|
{
|
|
public:
|
|
CUtlVector<T> &GetData()
|
|
{
|
|
return m_Data;
|
|
}
|
|
|
|
// call this to start retrieving data
|
|
void InitRetrievingData()
|
|
{
|
|
m_bAwaitingNewRecord = true;
|
|
m_pData = &m_Data;
|
|
m_pData->RemoveAll();
|
|
}
|
|
|
|
// call this to start retrieving data into an external piece of memory
|
|
void InitRetrievingData( CUtlVector<T> *pData )
|
|
{
|
|
m_bAwaitingNewRecord = true;
|
|
m_pData = pData;
|
|
m_pData->RemoveAll();
|
|
}
|
|
|
|
T *ForceNextRecord()
|
|
{
|
|
int index = m_pData->AddToTail();
|
|
if ( m_pData->Count() > 1 )
|
|
{
|
|
m_pData->Element(index) = m_pData->Element(0);
|
|
}
|
|
return &m_pData->Element(index);
|
|
}
|
|
// implement this to parse out input from the server into the specified object
|
|
virtual void OutputRecord(T &obj, const char *pszVar, const char *pszInfo) = 0;
|
|
|
|
|
|
private:
|
|
bool m_bAwaitingNewRecord;
|
|
CUtlVector<T> m_Data;
|
|
CUtlVector<T> *m_pData;
|
|
|
|
virtual void OutputInfo( char level, const char *data )
|
|
{
|
|
if ( V_strlen(data) < 1 )
|
|
{
|
|
// end of a record, await the new one
|
|
m_bAwaitingNewRecord = true;
|
|
return;
|
|
}
|
|
|
|
if ( m_bAwaitingNewRecord )
|
|
{
|
|
// add in the new record
|
|
T &record = m_pData->Element( m_pData->AddToTail() );
|
|
memset( &record, 0, sizeof( record ) );
|
|
Construct( &record );
|
|
m_bAwaitingNewRecord = false;
|
|
}
|
|
|
|
// parse
|
|
char szVar[_MAX_PATH];
|
|
char szInfo[_MAX_PATH];
|
|
SplitP4Output( data, szVar, szInfo, sizeof( szVar ) );
|
|
|
|
// emit
|
|
T &record = m_pData->Element( m_pData->Count() - 1 );
|
|
OutputRecord( record, szVar, szInfo );
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieves a file list
|
|
//-----------------------------------------------------------------------------
|
|
class CFileUser : public CDataRetrievalUser<P4File_t>
|
|
{
|
|
public:
|
|
void RetrieveDir(const char *dir)
|
|
{
|
|
// clear the list
|
|
InitRetrievingData();
|
|
|
|
// search for the paths - this string gets all revisions of a file,
|
|
// from the version they have locally to the current version
|
|
// this is so we can see if the local files are out of date
|
|
char szSearch[MAX_PATH];
|
|
V_snprintf(szSearch, sizeof(szSearch), "%s/*", dir);
|
|
|
|
// gets directories first
|
|
char *argv[] = { "-C", (char *)szSearch, NULL };
|
|
s_p4.GetClientApi().SetArgv( 2, argv );
|
|
s_p4.GetClientApi().Run("dirs", this);
|
|
|
|
// now get files, '-Rc' restricts files to client mapping
|
|
char *argv2[] = { "-Rc", "-Op", (char *)szSearch, NULL };
|
|
s_p4.GetClientApi().SetArgv( 3, argv2 );
|
|
s_p4.GetClientApi().Run("fstat", this);
|
|
|
|
ComputeLocalDirectoryNames( GetData() );
|
|
}
|
|
|
|
void RetrieveFile(const char *filespec)
|
|
{
|
|
// clear the list
|
|
InitRetrievingData();
|
|
|
|
// now get files, '-Rc' restricts files to client mapping
|
|
char *argv2[] = { "-Rc", "-Op", (char *)filespec, NULL };
|
|
s_p4.GetClientApi().SetArgv( 3, argv2 );
|
|
s_p4.GetClientApi().Run("fstat", this);
|
|
ComputeLocalDirectoryNames( GetData() );
|
|
}
|
|
// Show how file names map through the client view
|
|
// For each file in filespec, three names are produced:
|
|
// depotFile the name in the depot
|
|
// clientFile the name on the client in Perforce syntax
|
|
// localFile the name on the client in local syntax
|
|
void RetrieveWhereabouts(const char *filespec)
|
|
{
|
|
// clear the list
|
|
InitRetrievingData();
|
|
|
|
// figure out where filespec is
|
|
char *argv[] = { (char *)filespec, NULL };
|
|
s_p4.GetClientApi().SetArgv( 1, argv );
|
|
s_p4.GetClientApi().Run("where", this);
|
|
}
|
|
|
|
void RetrieveOpenedFiles( const char *filespec )
|
|
{
|
|
// clear the list
|
|
InitRetrievingData();
|
|
char *argv[] = { (char *)filespec, NULL };
|
|
s_p4.GetClientApi().SetArgv( 1, argv );
|
|
s_p4.GetClientApi().Run("opened", this);
|
|
ComputeLocalFileNames( GetData() );
|
|
}
|
|
|
|
void BeginChangelistProcess()
|
|
{
|
|
m_bChangesRecord = true;
|
|
m_nChangesIndex = 0;
|
|
}
|
|
void EndChangelistProcess()
|
|
{
|
|
m_bChangesRecord = false;
|
|
m_nChangesIndex = -1;
|
|
}
|
|
|
|
void RetrieveOpenedFiles( CUtlVector<P4File_t> &fileList, bool bDefaultChangeOnly )
|
|
{
|
|
// clear the list
|
|
InitRetrievingData( &fileList );
|
|
if ( bDefaultChangeOnly )
|
|
{
|
|
char *argv[] = { (char *)"-c", (char*)"default", NULL };
|
|
s_p4.GetClientApi().SetArgv( 2, argv );
|
|
}
|
|
s_p4.GetClientApi().Run( "opened", this );
|
|
ComputeLocalFileNames( fileList );
|
|
}
|
|
|
|
void RetrieveFilesInChangelist( unsigned int changeListNumber, CUtlVector<P4File_t> &fileList )
|
|
{
|
|
BeginChangelistProcess();
|
|
InitRetrievingData( &fileList );
|
|
char changeListString[32];
|
|
V_snprintf( changeListString, sizeof(changeListString), "%d", changeListNumber );
|
|
char *argv[] = { (char *)"-s", changeListString, NULL };
|
|
s_p4.GetClientApi().SetArgv( 2, argv );
|
|
s_p4.GetClientApi().Run( "describe", this );
|
|
EndChangelistProcess();
|
|
}
|
|
|
|
|
|
private:
|
|
void ComputeLocalFileNames( CUtlVector<P4File_t> &fileList )
|
|
{
|
|
// Need to construct valid local paths since opened doesn't do it for us
|
|
char pMatchPattern[MAX_PATH];
|
|
V_snprintf( pMatchPattern, sizeof(pMatchPattern), "//%s/", s_p4.GetClientApi().GetClient().Text() );
|
|
int nLen = V_strlen( pMatchPattern );
|
|
|
|
int nCount = fileList.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( fileList[i].m_bDir )
|
|
continue;
|
|
|
|
const char *pClientPath = s_p4.String( fileList[i].m_sClientFile );
|
|
if ( V_stristr( pClientPath, pMatchPattern ) != pClientPath )
|
|
continue;
|
|
|
|
char pLocalPath[MAX_PATH];
|
|
V_ComposeFileName( s_p4.GetLocalRoot(), pClientPath + nLen, pLocalPath, sizeof(pLocalPath) );
|
|
V_FixSlashes( pLocalPath );
|
|
fileList[i].m_sLocalFile = pLocalPath;
|
|
}
|
|
}
|
|
|
|
void ComputeLocalDirectoryNames( CUtlVector<P4File_t> &fileList )
|
|
{
|
|
// Need to construct valid local paths since opened doesn't do it for us
|
|
int nCount = fileList.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( !fileList[i].m_bDir )
|
|
continue;
|
|
|
|
char pLocalPath[MAX_PATH];
|
|
const char *pDepotPath = s_p4.String( fileList[i].m_sDepotFile );
|
|
if ( !s_p4.DepotFileToLocalFile( pDepotPath, pLocalPath, sizeof(pLocalPath) ) )
|
|
continue;
|
|
|
|
fileList[i].m_sLocalFile = pLocalPath;
|
|
}
|
|
}
|
|
|
|
void OutputRecordInternal(P4File_t &file, const char *szCmd, const char *szInfo)
|
|
{
|
|
if (!V_strcmp(szCmd, "headRev"))
|
|
{
|
|
file.m_iHeadRevision = atoi(szInfo);
|
|
}
|
|
else if (!V_strcmp(szCmd, "haveRev"))
|
|
{
|
|
file.m_iHaveRevision = atoi(szInfo);
|
|
}
|
|
else if (!V_strcmp(szCmd, "headAction") && !V_strcmp(szInfo, "delete"))
|
|
{
|
|
file.m_bDeleted = true;
|
|
}
|
|
else if (!V_strcmp(szCmd, "action"))
|
|
{
|
|
if (!V_strcmp(szInfo, "edit"))
|
|
{
|
|
file.m_eOpenState = P4FILE_OPENED_FOR_EDIT;
|
|
}
|
|
else if (!V_strcmp(szInfo, "delete"))
|
|
{
|
|
file.m_eOpenState = P4FILE_OPENED_FOR_DELETE;
|
|
}
|
|
else if (!V_strcmp(szInfo, "add"))
|
|
{
|
|
file.m_eOpenState = P4FILE_OPENED_FOR_ADD;
|
|
}
|
|
else if (!V_strcmp(szInfo, "integrate"))
|
|
{
|
|
file.m_eOpenState = P4FILE_OPENED_FOR_INTEGRATE;
|
|
}
|
|
}
|
|
else if (!V_strcmp(szCmd, "change"))
|
|
{
|
|
file.m_iChangelist = atoi(szInfo);
|
|
}
|
|
else if ( !V_strcmp( szCmd, "otherOpen" ) )
|
|
{
|
|
file.m_bOpenedByOther = atoi( szInfo ) != 0;
|
|
}
|
|
else if ( m_bChangesRecord && (!V_strcmp(szCmd, "user") || !V_strcmp(szCmd,"client") || !V_strcmp(szCmd, "time") ||
|
|
!V_strcmp(szCmd, "desc") || !V_strcmp(szCmd, "status") || !V_strcmp(szCmd, "oldChange") ||
|
|
!V_strcmp(szCmd,"type") || !V_strcmp(szCmd,"rev")) )
|
|
{
|
|
// ignore these, processing changelist description
|
|
}
|
|
else
|
|
{
|
|
// extract the path
|
|
char pFilePath[_MAX_PATH];
|
|
V_strncpy( pFilePath, szInfo, sizeof( pFilePath ) );
|
|
char *pFileName = V_strrchr(pFilePath, '/');
|
|
if (pFileName)
|
|
{
|
|
++pFileName;
|
|
}
|
|
|
|
if ( !V_stricmp( szCmd, "dir" ) )
|
|
{
|
|
// new directory, add to the list
|
|
file.m_sPath = pFilePath;
|
|
file.m_sDepotFile = pFilePath;
|
|
file.m_sName = pFileName;
|
|
file.m_bDir = true;
|
|
}
|
|
else if ( !V_strcmp( szCmd, "depotFile" ) )
|
|
{
|
|
if ( m_bChangesRecord )
|
|
{
|
|
char pLocalPath[MAX_PATH];
|
|
if ( s_p4.DepotFileToLocalFile( szInfo, pLocalPath, sizeof(pLocalPath) ) )
|
|
{
|
|
file.m_sLocalFile = pLocalPath;
|
|
}
|
|
}
|
|
char *pCruft = V_strstr( pFilePath, "//%%1" );
|
|
if (pCruft)
|
|
*pCruft = 0;
|
|
file.m_sDepotFile = pFilePath;
|
|
// Now that we've stored off the depot file, split file into path + name
|
|
if (pFileName)
|
|
{
|
|
*(pFileName - 1) = 0;
|
|
}
|
|
|
|
file.m_sPath = pFilePath;
|
|
file.m_sName = pFileName;
|
|
file.m_bDir = false;
|
|
}
|
|
else if (!V_stricmp(szCmd, "clientFile"))
|
|
{
|
|
char *pCruft = V_strstr( pFilePath, "//%%1" );
|
|
if (pCruft)
|
|
*pCruft = 0;
|
|
file.m_sClientFile = pFilePath;
|
|
}
|
|
else if (!V_stricmp(szCmd, "path"))
|
|
{
|
|
char *pCruft = V_strstr(pFilePath, "\\%%1");
|
|
if (pCruft)
|
|
*pCruft = 0;
|
|
file.m_sLocalFile = pFilePath;
|
|
}
|
|
}
|
|
}
|
|
virtual void OutputRecord(P4File_t &file, const char *szCmd, const char *szInfo)
|
|
{
|
|
P4File_t *pFile = &file;
|
|
if ( m_bChangesRecord )
|
|
{
|
|
char tmpCmd[1024];
|
|
int end = V_strlen(szCmd)-1;
|
|
if ( end < ARRAYSIZE(tmpCmd) )
|
|
{
|
|
const char *pChar = szCmd + end;
|
|
while ( isdigit(*pChar) && pChar > szCmd )
|
|
{
|
|
pChar--;
|
|
}
|
|
int pos = pChar - szCmd;
|
|
if ( pos > 0 && pos < end )
|
|
{
|
|
int newChangeIndex = atoi(pChar+1);
|
|
V_strncpy( tmpCmd, szCmd, sizeof(tmpCmd) );
|
|
tmpCmd[pos+1] = 0;
|
|
szCmd = tmpCmd;
|
|
if ( newChangeIndex != m_nChangesIndex )
|
|
{
|
|
pFile = ForceNextRecord();
|
|
m_nChangesIndex = newChangeIndex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OutputRecordInternal( *pFile, szCmd, szInfo );
|
|
}
|
|
|
|
int m_nChangesIndex;
|
|
bool m_bChangesRecord;
|
|
};
|
|
CFileUser g_FileUser;
|
|
CFileUser g_WhereUser;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieves a history list
|
|
//-----------------------------------------------------------------------------
|
|
class CRevisionHistoryUser : public CDataRetrievalUser<P4Revision_t>
|
|
{
|
|
public:
|
|
void RetrieveHistory(const char *path, bool bDir)
|
|
{
|
|
InitRetrievingData();
|
|
|
|
// search for the paths - this string gets all revisions of a file,
|
|
// from the version they have locally to the current version
|
|
// this is so we can see if the local files are out of date
|
|
char szSearch[MAX_PATH];
|
|
if (bDir)
|
|
{
|
|
V_snprintf(szSearch, sizeof(szSearch), "%s/...", path);
|
|
}
|
|
else
|
|
{
|
|
V_snprintf(szSearch, sizeof(szSearch), "%s", path);
|
|
}
|
|
|
|
// set to view long output, to show the time, and to have a maximum number of results
|
|
char *argv[] = { "-l", "-t", "-m", "50", (char *)szSearch, NULL };
|
|
s_p4.GetClientApi().SetArgv( 5, argv );
|
|
s_p4.GetClientApi().Run("changes", this);
|
|
|
|
}
|
|
|
|
private:
|
|
virtual void OutputRecord(P4Revision_t &revision, const char *szCmd, const char *szInfo)
|
|
{
|
|
if (!V_strcmp(szCmd, "change"))
|
|
{
|
|
revision.m_iChange = atoi(szInfo);
|
|
}
|
|
else if (!V_strcmp(szCmd, "user"))
|
|
{
|
|
revision.m_sUser = szInfo;
|
|
}
|
|
else if (!V_strcmp(szCmd, "client"))
|
|
{
|
|
revision.m_sClient = szInfo;
|
|
}
|
|
else if (!V_strcmp(szCmd, "status"))
|
|
{
|
|
}
|
|
else if (!V_strcmp(szCmd, "desc"))
|
|
{
|
|
revision.m_Description = szInfo;
|
|
}
|
|
else if (!V_strcmp(szCmd, "time"))
|
|
{
|
|
int64 iTime = atoi(szInfo);
|
|
|
|
struct tm *gmt = gmtime(reinterpret_cast<time_t*>(&iTime));
|
|
|
|
revision.m_nYear = gmt->tm_year + 1900;
|
|
revision.m_nMonth = gmt->tm_mon + 1;
|
|
revision.m_nDay = gmt->tm_mday;
|
|
revision.m_nHour = gmt->tm_hour;
|
|
revision.m_nMinute = gmt->tm_min;
|
|
revision.m_nSecond = gmt->tm_sec;
|
|
}
|
|
}
|
|
};
|
|
CRevisionHistoryUser g_RevisionHistoryUser;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retreives list of clients
|
|
//-----------------------------------------------------------------------------
|
|
class CClientSpecUser : public CDataRetrievalUser<P4Client_t>
|
|
{
|
|
public:
|
|
void RetrieveClients()
|
|
{
|
|
InitRetrievingData();
|
|
|
|
// we just get the entire list
|
|
s_p4.GetClientApi().Run("clients", this);
|
|
}
|
|
|
|
private:
|
|
virtual void OutputRecord(P4Client_t &client, const char *szCmd, const char *szInfo)
|
|
{
|
|
if (!V_strcmp(szCmd, "client"))
|
|
{
|
|
client.m_sName = szInfo;
|
|
}
|
|
else if (!V_strcmp(szCmd, "Owner"))
|
|
{
|
|
client.m_sUser = szInfo;
|
|
}
|
|
else if (!V_strcmp(szCmd, "Root"))
|
|
{
|
|
client.m_sLocalRoot = szInfo;
|
|
}
|
|
else if (!V_strcmp(szCmd, "Host"))
|
|
{
|
|
client.m_sHost = szInfo;
|
|
}
|
|
else
|
|
{
|
|
Msg("Unknown field %s = %s\n", szCmd, szInfo);
|
|
}
|
|
}
|
|
};
|
|
CClientSpecUser g_ClientspecUser;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: holder and modifier of clientspec file mapings
|
|
//-----------------------------------------------------------------------------
|
|
class CClientspecMap
|
|
{
|
|
public:
|
|
char m_szFullClientspec[CLIENTSPEC_BUFFER_SIZE];
|
|
int m_iFullClientspecWritePosition;
|
|
CUtlVector<CClientPathRecord> m_PathMap;
|
|
char m_szLocalPath[_MAX_PATH];
|
|
|
|
void ResetFullClientSpec( void )
|
|
{
|
|
m_szFullClientspec[0] = '\0';
|
|
m_iFullClientspecWritePosition = 0;
|
|
m_PathMap.RemoveAll();
|
|
m_szLocalPath[0] = '\0';
|
|
}
|
|
|
|
void AddVarToFullClientSpec( const char *variable, const char *data )
|
|
{
|
|
V_snprintf( &m_szFullClientspec[m_iFullClientspecWritePosition], CLIENTSPEC_BUFFER_SIZE - m_iFullClientspecWritePosition, "%s: %s\n\n", variable, data );
|
|
m_iFullClientspecWritePosition += strlen( &m_szFullClientspec[m_iFullClientspecWritePosition] );
|
|
}
|
|
|
|
void AddStringToFullClientSpec( const char *szString )
|
|
{
|
|
V_strncpy( &m_szFullClientspec[m_iFullClientspecWritePosition], szString, CLIENTSPEC_BUFFER_SIZE - m_iFullClientspecWritePosition );
|
|
m_iFullClientspecWritePosition += strlen( &m_szFullClientspec[m_iFullClientspecWritePosition] );
|
|
}
|
|
|
|
void ReadRoot( const char *clientRoot )
|
|
{
|
|
V_strncpy( m_szLocalPath, clientRoot, _MAX_PATH );
|
|
}
|
|
|
|
void ReadViewLine( const char *viewLine )
|
|
{
|
|
CUtlBuffer parse(viewLine, V_strlen(viewLine), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
|
|
|
|
CClientPathRecord record;
|
|
record.m_bNegative = false;
|
|
|
|
// get the depot path
|
|
parse.GetString(record.m_szDepotPath, sizeof(record.m_szDepotPath));
|
|
if (V_strlen(record.m_szDepotPath) < 1)
|
|
return;
|
|
|
|
if (!V_stricmp(record.m_szDepotPath, "-"))
|
|
{
|
|
// it's the negation sign, get the next line
|
|
parse.GetString(record.m_szDepotPath, sizeof(record.m_szDepotPath));
|
|
record.m_bNegative = true;
|
|
}
|
|
if (record.m_szDepotPath[0] == '-')
|
|
{
|
|
// negation sign is stuck on the end, remove
|
|
record.m_bNegative = true;
|
|
memmove(record.m_szDepotPath, record.m_szDepotPath + 1, sizeof(record.m_szDepotPath) - 1);
|
|
}
|
|
|
|
// get the next sign
|
|
parse.GetString(record.m_szClientPath, sizeof(record.m_szClientPath));
|
|
|
|
// append to list
|
|
m_PathMap.AddToTail(record);
|
|
}
|
|
|
|
void ReadClientspec(const char *clientspec)
|
|
{
|
|
// Get the local path
|
|
char *pszSearch = "\n\nRoot:";
|
|
char *pStr = V_strstr( clientspec, pszSearch );
|
|
if (pStr)
|
|
{
|
|
pStr += V_strlen( pszSearch );
|
|
|
|
// parse out next satring
|
|
CUtlBuffer parse(pStr, V_strlen(pStr), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
|
|
|
|
// get the local path
|
|
parse.GetString( m_szLocalPath, sizeof(m_szLocalPath) );
|
|
}
|
|
|
|
pszSearch = "\n\nView:\n";
|
|
pStr = V_strstr(clientspec, pszSearch);
|
|
if (pStr)
|
|
{
|
|
pStr += V_strlen(pszSearch);
|
|
|
|
// take a full copy of the string
|
|
V_strncpy(m_szFullClientspec, clientspec, sizeof(m_szFullClientspec));
|
|
|
|
// parse out strings
|
|
CUtlBuffer parse(pStr, V_strlen(pStr), CUtlBuffer::TEXT_BUFFER|CUtlBuffer::READ_ONLY);
|
|
|
|
while (parse.IsValid())
|
|
{
|
|
CClientPathRecord record;
|
|
record.m_bNegative = false;
|
|
|
|
// get the depot path
|
|
parse.GetString(record.m_szDepotPath, sizeof(record.m_szDepotPath));
|
|
if (V_strlen(record.m_szDepotPath) < 1)
|
|
break;
|
|
|
|
if (!V_stricmp(record.m_szDepotPath, "-"))
|
|
{
|
|
// it's the negation sign, get the next line
|
|
parse.GetString(record.m_szDepotPath, sizeof(record.m_szDepotPath));
|
|
record.m_bNegative = true;
|
|
}
|
|
if (record.m_szDepotPath[0] == '-')
|
|
{
|
|
// negation sign is stuck on the end, remove
|
|
record.m_bNegative = true;
|
|
memmove(record.m_szDepotPath, record.m_szDepotPath + 1, sizeof(record.m_szDepotPath) - 1);
|
|
}
|
|
|
|
// get the next sign
|
|
parse.GetString(record.m_szClientPath, sizeof(record.m_szClientPath));
|
|
|
|
// append to list
|
|
m_PathMap.AddToTail(record);
|
|
}
|
|
}
|
|
}
|
|
|
|
void WriteClientspec(char *pszDest, int destSize)
|
|
{
|
|
// assemble the new view
|
|
char szView[CLIENTSPEC_BUFFER_SIZE] = { 0 };
|
|
for (int i = 0; i < m_PathMap.Count(); i++)
|
|
{
|
|
CClientPathRecord &record = m_PathMap[i];
|
|
|
|
V_strncat(szView, " ", sizeof(szView), COPY_ALL_CHARACTERS);
|
|
if (record.m_bNegative)
|
|
{
|
|
V_strncat(szView, "-", sizeof(szView), COPY_ALL_CHARACTERS);
|
|
}
|
|
V_strncat(szView, record.m_szDepotPath, sizeof(szView), COPY_ALL_CHARACTERS);
|
|
V_strncat(szView, " ", sizeof(szView), COPY_ALL_CHARACTERS);
|
|
V_strncat(szView, record.m_szClientPath, sizeof(szView), COPY_ALL_CHARACTERS);
|
|
V_strncat(szView, " \n", sizeof(szView), COPY_ALL_CHARACTERS);
|
|
}
|
|
|
|
// find the place the view is set
|
|
char *pszSearch = "\n\nView:\n";
|
|
char *pStr = V_strstr(m_szFullClientspec, pszSearch);
|
|
if (pStr)
|
|
{
|
|
char *pDest = (pStr + strlen(pszSearch));
|
|
|
|
// replace the view with the new view
|
|
V_strncpy(pDest, szView, sizeof(m_szFullClientspec) - (pDest - m_szFullClientspec));
|
|
}
|
|
|
|
// emit
|
|
V_strncpy(pszDest, m_szFullClientspec, destSize);
|
|
}
|
|
|
|
void RemovePathFromClient(const char *path)
|
|
{
|
|
// work out how the path record contains the specified path
|
|
for (int i = 0; i < m_PathMap.Count(); i++)
|
|
{
|
|
// look for the first path that matches, comparing the two strings up to before the "/..." in szDepotPath
|
|
if (!V_strnicmp(m_PathMap[i].m_szDepotPath, path, V_strlen(m_PathMap[i].m_szDepotPath) - 4))
|
|
{
|
|
CClientPathRecord &baseRecord = m_PathMap[i];
|
|
|
|
// we have a match, build the negative case
|
|
CClientPathRecord negativeRecord;
|
|
negativeRecord.m_bNegative = true;
|
|
V_snprintf(negativeRecord.m_szDepotPath, sizeof(negativeRecord.m_szDepotPath), "%s/...", path);
|
|
|
|
// build the clientspec side of the mapping
|
|
|
|
// aa/b/... //client/BAH/...
|
|
//- aa/b/d/... //client/BAH/d/
|
|
|
|
// find the common strings in both
|
|
int iPos = 0;
|
|
while (baseRecord.m_szDepotPath[iPos] == negativeRecord.m_szDepotPath[iPos])
|
|
++iPos;
|
|
|
|
char *pszNegPaths = negativeRecord.m_szDepotPath + iPos;
|
|
|
|
// append the neg paths to the existing baseRecord.szClientPath
|
|
V_strncpy(negativeRecord.m_szClientPath, baseRecord.m_szClientPath, sizeof(negativeRecord.m_szClientPath));
|
|
// strip off the last slash
|
|
char *pszDir = V_strstr(negativeRecord.m_szClientPath, "/...");
|
|
if (pszDir)
|
|
{
|
|
*pszDir = 0;
|
|
}
|
|
|
|
// append the new client paths to negate
|
|
V_strncat(negativeRecord.m_szClientPath, "/", sizeof(negativeRecord.m_szClientPath), COPY_ALL_CHARACTERS);
|
|
V_strncat(negativeRecord.m_szClientPath, pszNegPaths, sizeof(negativeRecord.m_szClientPath), COPY_ALL_CHARACTERS);
|
|
|
|
m_PathMap.InsertAfter(i, negativeRecord);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// calculates the depot root
|
|
void GetCommonDepotRoot(char *pszDest, int destSize)
|
|
{
|
|
int nCount = m_PathMap.Count();
|
|
if ( nCount == 0 )
|
|
{
|
|
pszDest[0] = 0;
|
|
return;
|
|
}
|
|
|
|
// walk each mapping, and find the longest common starting substring
|
|
V_strncpy(pszDest, m_PathMap[0].m_szDepotPath, destSize);
|
|
for (int i = 1; i < nCount; i++)
|
|
{
|
|
if ( m_PathMap[i].m_bNegative )
|
|
continue;
|
|
|
|
// see how much we compare
|
|
for (char *pszD = pszDest, *pszS = m_PathMap[i].m_szDepotPath; *pszD && *pszS; ++pszD, ++pszS)
|
|
{
|
|
if (*pszD != *pszS)
|
|
{
|
|
*pszD = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// remove any "..." at the end
|
|
char *pszD = V_strstr(pszDest, "...");
|
|
if (pszD)
|
|
{
|
|
*pszD = 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: tool for editing clientspecs
|
|
//-----------------------------------------------------------------------------
|
|
class CClientspecEditUser : public ClientUser
|
|
{
|
|
public:
|
|
CClientspecEditUser( void ) : m_bReadDataVar( false ) {};
|
|
void RetrieveClient(const char *pszClient)
|
|
{
|
|
m_Map.ResetFullClientSpec();
|
|
|
|
// we just get the entire list
|
|
char *argv[] = { "-o", (char *)pszClient, NULL };
|
|
s_p4.GetClientApi().SetArgv( 2, argv );
|
|
s_p4.GetClientApi().Run("client", this);
|
|
}
|
|
|
|
// saves out the new path spec to the
|
|
void WriteClientspec()
|
|
{
|
|
// write out the new clientspec
|
|
char *argv[] = { "-i", NULL, NULL };
|
|
s_p4.GetClientApi().SetArgv( 1, argv );
|
|
s_p4.GetClientApi().Run("client", this);
|
|
}
|
|
|
|
CClientspecMap m_Map;
|
|
bool m_bReadDataVar; //if we encountered a "data" variable, turn off the other parsing
|
|
|
|
private:
|
|
virtual void OutputInfo( char level, const char *data )
|
|
{
|
|
char szVar[CLIENTSPEC_BUFFER_SIZE], szInfo[CLIENTSPEC_BUFFER_SIZE];
|
|
SplitP4Output(data, szVar, szInfo, sizeof(szInfo));
|
|
|
|
if( szVar[0] != '\0' )
|
|
{
|
|
if (!V_stricmp(szVar, "data"))
|
|
{
|
|
m_bReadDataVar = true;
|
|
m_Map.ReadClientspec(szInfo);
|
|
}
|
|
else if( !m_bReadDataVar )
|
|
{
|
|
if( !V_stricmp( szVar, "root" ) )
|
|
{
|
|
m_Map.ReadRoot( szInfo );
|
|
m_Map.AddVarToFullClientSpec( szVar, szInfo );
|
|
}
|
|
else if( !V_strnicmp( szVar, "view", 4 ) )
|
|
{
|
|
if( !V_stricmp( szVar, "view" ) || !V_stricmp( szVar, "view0" ) )
|
|
{
|
|
//cheat a bit
|
|
m_Map.AddStringToFullClientSpec( "View:\n" );
|
|
}
|
|
m_Map.ReadViewLine( szInfo );
|
|
m_Map.AddStringToFullClientSpec( "\t" );
|
|
m_Map.AddStringToFullClientSpec( szInfo );
|
|
m_Map.AddStringToFullClientSpec( "\n" );
|
|
}
|
|
else
|
|
{
|
|
m_Map.AddVarToFullClientSpec( szVar, szInfo );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// called to read data
|
|
virtual void InputData( StrBuf *strbuf, Error *e )
|
|
{
|
|
char szView[CLIENTSPEC_BUFFER_SIZE];
|
|
m_Map.WriteClientspec(szView, sizeof(szView));
|
|
strbuf->Set(szView);
|
|
e->Clear();
|
|
}
|
|
|
|
virtual void OutputError( const char *errBuf )
|
|
{
|
|
Msg("s_p4 error: %s", errBuf);
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retreives list of clients
|
|
//-----------------------------------------------------------------------------
|
|
class CInfoUser : public ClientUser
|
|
{
|
|
public:
|
|
void RetrieveInfo()
|
|
{
|
|
memset(&m_Client, 0, sizeof(m_Client));
|
|
|
|
// we just get the entire list
|
|
s_p4.GetClientApi().Run("info", this);
|
|
}
|
|
|
|
P4Client_t m_Client;
|
|
|
|
private:
|
|
virtual void OutputInfo(char level, const char *data)
|
|
{
|
|
char szCmd[_MAX_PATH];
|
|
char szInfo[_MAX_PATH];
|
|
|
|
SplitP4Output(data, szCmd, szInfo, sizeof(szCmd));
|
|
|
|
if (!V_stricmp(szCmd, "userName"))
|
|
{
|
|
m_Client.m_sUser = szInfo;
|
|
}
|
|
else if (!V_stricmp(szCmd, "clientName"))
|
|
{
|
|
m_Client.m_sName = szInfo;
|
|
}
|
|
else if (!V_stricmp(szCmd, "clientHost"))
|
|
{
|
|
m_Client.m_sHost = szInfo;
|
|
}
|
|
else if (!V_stricmp(szCmd, "clientRoot"))
|
|
{
|
|
m_Client.m_sLocalRoot = szInfo;
|
|
}
|
|
}
|
|
};
|
|
CInfoUser g_InfoUser;
|
|
|
|
|
|
// Changelist description structure
|
|
struct ChangelistDesc_t
|
|
{
|
|
int id;
|
|
time_t m_tTimeStamp;
|
|
CUtlSymbol m_sUser;
|
|
CUtlSymbol m_sClient;
|
|
CUtlSymbol m_sStatus;
|
|
CUtlSymbol m_sDescription;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: tool for creating new changelists
|
|
//-----------------------------------------------------------------------------
|
|
class CChangelistCreateUser : public CDataRetrievalUser<int>
|
|
{
|
|
public:
|
|
void CreateChangelist( const char *pDescription )
|
|
{
|
|
InitRetrievingData();
|
|
|
|
// Will force InputData to be called
|
|
m_pDescription = ( pDescription && pDescription[0] ) ? pDescription : "I'm a loser who didn't type a description. Mock me at your earliest convenience.";
|
|
char *argv[] = { "-i", NULL };
|
|
s_p4.GetClientApi().SetArgv( 1, argv );
|
|
s_p4.GetClientApi().Run("change", this);
|
|
}
|
|
|
|
private:
|
|
// called to read data from stdin
|
|
virtual void InputData( StrBuf *strbuf, Error *e )
|
|
{
|
|
char svChangelist[ P4_MAX_INPUT_BUFFER_SIZE + 2048 ];
|
|
P4Client_t &activeClient = s_p4.GetActiveClient();
|
|
|
|
V_snprintf( svChangelist, sizeof(svChangelist),
|
|
"Change:\tnew\n\nClient:\t%s\n\nUser:\t%s\n\nStatus:\tnew\n\n"
|
|
"Description:\n\t%s\n\nFiles:\n\n",
|
|
activeClient.m_sName.String(), activeClient.m_sUser.String(), m_pDescription );
|
|
|
|
strbuf->Set(svChangelist);
|
|
e->Clear();
|
|
}
|
|
|
|
virtual void OutputRecord( int &nChangelist, const char *szCmd, const char *szInfo)
|
|
{
|
|
if (!V_strcmp(szCmd, "Change"))
|
|
{
|
|
nChangelist = atoi(szInfo);
|
|
}
|
|
}
|
|
|
|
const char *m_pDescription;
|
|
};
|
|
CChangelistCreateUser g_ChangelistCreateUser;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: tool for finding an existing changelist
|
|
//-----------------------------------------------------------------------------
|
|
class CChangelistFindUser : public CDataRetrievalUser<ChangelistDesc_t>
|
|
{
|
|
public:
|
|
void ListChangelists( void )
|
|
{
|
|
InitRetrievingData();
|
|
|
|
char *argv[] = { "-l", "-t", "-s", "pending", "-c", s_p4.GetClientApi().GetClient().Text(), NULL };
|
|
s_p4.GetClientApi().SetArgv( 6, argv );
|
|
s_p4.GetClientApi().Run("changes", this);
|
|
}
|
|
|
|
private:
|
|
virtual void OutputRecord( ChangelistDesc_t &cl, const char *szCmd, const char *szInfo)
|
|
{
|
|
if ( !V_strcmp( szCmd, "change" ) )
|
|
{
|
|
cl.id = atoi( szInfo );
|
|
}
|
|
else if ( !V_strcmp( szCmd, "time" ) )
|
|
{
|
|
cl.m_tTimeStamp = atoi( szInfo );
|
|
}
|
|
else if ( !V_strcmp( szCmd, "user" ) )
|
|
{
|
|
cl.m_sUser = szInfo;
|
|
}
|
|
else if ( !V_strcmp( szCmd, "client" ) )
|
|
{
|
|
cl.m_sClient = szInfo;
|
|
}
|
|
else if ( !V_strcmp( szCmd, "status" ) )
|
|
{
|
|
cl.m_sStatus = szInfo;
|
|
}
|
|
else if ( !V_strcmp( szCmd, "desc" ) )
|
|
{
|
|
CUtlVector<char> arrInfo;
|
|
arrInfo.SetCount( 1 + strlen( szInfo ) );
|
|
memcpy( arrInfo.Base(), szInfo, arrInfo.Count() );
|
|
for ( int nCount = arrInfo.Count() - 1; nCount -- > 0; )
|
|
{
|
|
if ( isspace( arrInfo[ nCount ] ) )
|
|
arrInfo[ nCount ] = 0;
|
|
else
|
|
break;
|
|
}
|
|
|
|
cl.m_sDescription = arrInfo.Base();
|
|
}
|
|
}
|
|
};
|
|
CChangelistFindUser g_ChangelistFindUser;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: only used to handle the error callback
|
|
//-----------------------------------------------------------------------------
|
|
class CErrorHandlerUser : public ClientUser
|
|
{
|
|
public:
|
|
CErrorHandlerUser() : m_errorSeverity( E_EMPTY ), m_uiFlags( 0 ) {}
|
|
|
|
virtual void OutputError( const char *errBuf )
|
|
{
|
|
m_errorSeverity = max( m_errorSeverity, E_WARN ); // this is a guess - it could have been E_FATAL or E_FAILED
|
|
|
|
Msg("s_p4 error: %s", errBuf);
|
|
|
|
m_errorBuf.Append( errBuf );
|
|
}
|
|
virtual void HandleError( Error *err )
|
|
{
|
|
m_errorSeverity = max( m_errorSeverity, ( ErrorSeverity )err->GetSeverity() );
|
|
|
|
StrBuf buf;
|
|
err->Fmt( buf, EF_NEWLINE );
|
|
|
|
if ( V_strstr( buf.Text(), "can't edit exclusive file already opened" ) )
|
|
{
|
|
m_errorSeverity = max( m_errorSeverity, E_WARN ); // s_p4 sends this is an info message, even though the file doesn't get edited!
|
|
}
|
|
|
|
if ( ( m_uiFlags & eDisableFiltering ) || ShallOutputErrorStringBuffer( buf ) )
|
|
Msg( "%s: %s", err->FmtSeverity(), buf.Text() );
|
|
|
|
m_errorBuf.Append( &buf );
|
|
}
|
|
|
|
// Message is the only method that gets called on a s_p4 error
|
|
// even though the s_p4 documentation claims that HandleError (and therefore OutputError)
|
|
// should get called via the defalt Message implementation
|
|
virtual void Message( Error *err )
|
|
{
|
|
HandleError( err );
|
|
}
|
|
|
|
void ResetErrorState()
|
|
{
|
|
m_errorSeverity = E_EMPTY;
|
|
m_errorBuf.Clear();
|
|
}
|
|
ErrorSeverity GetErrorState()
|
|
{
|
|
return m_errorSeverity;
|
|
}
|
|
const char *GetErrorString()
|
|
{
|
|
return m_errorBuf.Text();
|
|
}
|
|
void SetErrorString( const char *errStr, ErrorSeverity severity )
|
|
{
|
|
m_errorBuf.Set( errStr );
|
|
m_errorSeverity = severity;
|
|
}
|
|
|
|
enum Flags {
|
|
eDisableFiltering = 1 << 0, // Disable filtering output
|
|
eFilterClUselessSpew = 1 << 1, // Filter "already opened", "add of exisiting", "can't change" msgs
|
|
};
|
|
|
|
// Sets the new flag mask, add prevails over remove if the flag specified in both.
|
|
// SetFlags( x, 0 ) - enables flag x
|
|
// SetFlags( 0, x ) - removes flag x
|
|
// SetFlags( mask, ~0 ) - completely sets the flag mask
|
|
uint32 SetFlags( uint32 uiAdd, uint32 uiRemove ) { uint32 uiOld = m_uiFlags; m_uiFlags = ( ( m_uiFlags & ~uiRemove ) | uiAdd ); return uiOld; }
|
|
|
|
protected:
|
|
// Performs filtering before the message is output to screen,
|
|
// if "ShallOutputErrorStringBuffer" returns false, then the message
|
|
// is not printed on screen, otherwise the modified strbug is printed.
|
|
virtual bool ShallOutputErrorStringBuffer( StrBuf &buf );
|
|
|
|
private:
|
|
ErrorSeverity m_errorSeverity;
|
|
StrBuf m_errorBuf;
|
|
uint32 m_uiFlags;
|
|
};
|
|
CErrorHandlerUser g_ErrorHandlerUser;
|
|
|
|
bool CErrorHandlerUser::ShallOutputErrorStringBuffer( StrBuf &buf )
|
|
{
|
|
char const *pText = buf.Text();
|
|
|
|
if ( m_uiFlags & eFilterClUselessSpew )
|
|
{
|
|
if ( V_strstr( pText, "already opened for edit" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "already opened for add" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "currently opened for edit" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "currently opened for add" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "add of existing file" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "add existing file" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "can't change from" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "no such file" ) )
|
|
return false;
|
|
if ( V_strstr( pText, "not on client" ) )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: tool for creating new changelists
|
|
//-----------------------------------------------------------------------------
|
|
class CSubmitUser : public ClientUser
|
|
{
|
|
public:
|
|
void Submit( int nChangeList )
|
|
{
|
|
// NOTE: -i doesn't appear to work with -c
|
|
// We have to set up the description when creating the changelist in the first place
|
|
m_pDescription = NULL;
|
|
char pBuf[128];
|
|
V_snprintf( pBuf, sizeof(pBuf), "%d", nChangeList );
|
|
char *argv[] = { "-c", pBuf, NULL };
|
|
s_p4.GetClientApi().SetArgv( 2, argv );
|
|
s_p4.GetClientApi().Run( "submit", &g_ErrorHandlerUser );
|
|
}
|
|
|
|
private:
|
|
// called to read data from stdin
|
|
virtual void InputData( StrBuf *strbuf, Error *e )
|
|
{
|
|
Assert( m_pDescription );
|
|
|
|
char svChangelist[1024];
|
|
P4Client_t &activeClient = s_p4.GetActiveClient();
|
|
|
|
V_snprintf( svChangelist, sizeof(svChangelist),
|
|
"Change:\tnew\n\nClient:\t%s\n\nUser:\t%s\n\nStatus:\tnew\n\n"
|
|
"Description:\n\t%s\n\nFiles:\n\n",
|
|
activeClient.m_sName.String(), activeClient.m_sUser.String(), m_pDescription );
|
|
|
|
strbuf->Set(svChangelist);
|
|
e->Clear();
|
|
}
|
|
|
|
const char *m_pDescription;
|
|
};
|
|
CSubmitUser g_SubmitUser;
|
|
|
|
|
|
int FindOrCreateChangelist( const char *pDescription )
|
|
{
|
|
int iCreatedEmptyCl = 0, iFoundChangelist = 0;
|
|
CUtlMap<int, ChangelistDesc_t const *> mapFoundChangelists( DefLessFunc( int ) );
|
|
|
|
CUtlSymbol symDesc = pDescription;
|
|
|
|
find_changelists:
|
|
mapFoundChangelists.RemoveAll();
|
|
g_ChangelistFindUser.ListChangelists();
|
|
for ( int k = 0; k < g_ChangelistFindUser.GetData().Count(); ++ k )
|
|
{
|
|
ChangelistDesc_t const &cl = g_ChangelistFindUser.GetData()[ k ];
|
|
|
|
if ( symDesc == cl.m_sDescription )
|
|
mapFoundChangelists.Insert( cl.id, &cl );
|
|
}
|
|
|
|
if ( mapFoundChangelists.Count() )
|
|
iFoundChangelist = mapFoundChangelists.Key( mapFoundChangelists.FirstInorder() );
|
|
else if ( iCreatedEmptyCl > 0 )
|
|
return iCreatedEmptyCl;
|
|
|
|
if ( iFoundChangelist > 0 )
|
|
{
|
|
// Check if we created a changelist that has to be deleted
|
|
if ( iCreatedEmptyCl > 0 && iCreatedEmptyCl != iFoundChangelist )
|
|
{
|
|
// Delete changelist
|
|
char chClNumber[50];
|
|
sprintf( chClNumber, "%d", iCreatedEmptyCl );
|
|
char *argv[] = { "-d", chClNumber, NULL };
|
|
s_p4.GetClientApi().SetArgv( 2, argv );
|
|
s_p4.GetClientApi().Run( "change", &g_ErrorHandlerUser );
|
|
}
|
|
|
|
return iFoundChangelist;
|
|
}
|
|
else
|
|
{
|
|
// We did not find a changelist, create a new one
|
|
g_ChangelistCreateUser.CreateChangelist( pDescription );
|
|
|
|
iCreatedEmptyCl = g_ChangelistCreateUser.GetData().Count() ? g_ChangelistCreateUser.GetData()[0] : 0;
|
|
if ( !iCreatedEmptyCl )
|
|
return 0;
|
|
|
|
// Now we have a changelist created, check again to avoid multithreading bugs
|
|
goto find_changelists;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CP4::~CP4()
|
|
{
|
|
// Prevents a hang if Shutdown isn't called before the process exits
|
|
if ( m_bConnectedToServer )
|
|
{
|
|
Shutdown();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Connect, disconnect
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::Connect( CreateInterfaceFn factory )
|
|
{
|
|
#if !defined(STANDALONE_VPC)
|
|
g_pFileSystem = (IFileSystem*)factory( FILESYSTEM_INTERFACE_VERSION, NULL );
|
|
return ( g_pFileSystem != NULL );
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
void CP4::Disconnect()
|
|
{
|
|
#if !defined(STANDALONE_VPC)
|
|
g_pFileSystem = NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Startup
|
|
//-----------------------------------------------------------------------------
|
|
InitReturnVal_t CP4::Init()
|
|
{
|
|
// set the protocol return all data as key/value pairs
|
|
m_Client.SetProtocol( "tag", "" );
|
|
|
|
// connect to the s_p4 server
|
|
Error e;
|
|
m_Client.Init( &e );
|
|
m_bConnectedToServer = e.Test() == 0 && m_Client.Dropped() == 0;
|
|
|
|
RefreshClientData();
|
|
|
|
return INIT_OK;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Cleanup
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::Shutdown()
|
|
{
|
|
Error e;
|
|
m_Client.Final(&e);
|
|
m_bConnectedToServer = false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: refreshes client data
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::RefreshClientData()
|
|
{
|
|
if ( !m_bConnectedToServer )
|
|
return;
|
|
|
|
// retrieve our login info
|
|
g_InfoUser.RetrieveInfo();
|
|
m_ActiveClient = g_InfoUser.m_Client;
|
|
|
|
// calculate our common depot root
|
|
CClientspecEditUser user;
|
|
user.RetrieveClient( GetActiveClient().m_sName.String() );
|
|
|
|
user.m_Map.GetCommonDepotRoot(m_szDepotRoot, sizeof(m_szDepotRoot));
|
|
m_iDepotRootLength = V_strlen(m_szDepotRoot);
|
|
m_ClientMapping = user.m_Map.m_PathMap;
|
|
V_strncpy( m_szLocalRoot, user.m_Map.m_szLocalPath, sizeof(m_szLocalRoot) );
|
|
m_iLocalRootLength = V_strlen(m_szLocalRoot);
|
|
|
|
SetOpenFileChangeList( m_sChangeListName.String() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Convert a depot file to a local file user the current client mapping
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::DepotFileToLocalFile( const char *pDepotFile, char *pLocalPath, int nBufLen )
|
|
{
|
|
// Need to construct valid local paths since opened doesn't do it for us
|
|
char pClientPattern[MAX_PATH];
|
|
V_snprintf( pClientPattern, sizeof(pClientPattern), "//%s/", m_Client.GetClient().Text() );
|
|
int nClientLen = V_strlen( pClientPattern );
|
|
|
|
int nMatchCount = 0;
|
|
int nCount = m_ClientMapping.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
const char *pDepotPath = m_ClientMapping[i].m_szDepotPath;
|
|
int nLen = V_strlen( pDepotPath );
|
|
if ( nMatchCount > nLen )
|
|
continue;
|
|
|
|
bool bRecursive = !V_stricmp( &pDepotPath[nLen-4], "/..." );
|
|
bool bInDirectory = !V_stricmp( &pDepotPath[nLen-2], "/*" );
|
|
if ( !bRecursive && !bInDirectory )
|
|
continue;
|
|
|
|
// FIXME: Do this fixup when we create m_ClientMapping?
|
|
char pMatchingString[MAX_PATH];
|
|
V_strncpy( pMatchingString, pDepotPath, bRecursive ? nLen-2 : nLen );
|
|
if ( V_stristr( pDepotFile, pMatchingString ) != pDepotFile )
|
|
continue;
|
|
|
|
// Skip subdirectories if it's in the directory
|
|
if ( bInDirectory )
|
|
{
|
|
const char *pRelativePath = pDepotFile + nLen - 1;
|
|
if ( strchr( pRelativePath, '\\' ) || strchr( pRelativePath, '/' ) )
|
|
continue;
|
|
}
|
|
|
|
const char *pClientPath = s_p4.String( m_ClientMapping[i].m_szClientPath );
|
|
int nPathLen = V_strlen( pClientPath );
|
|
|
|
bool bClientRecursive = !V_stricmp( &pClientPath[nPathLen-4], "/..." );
|
|
bool bClientInDirectory = !V_stricmp( &pClientPath[nPathLen-2], "/*" );
|
|
if ( !bClientRecursive && !bClientInDirectory )
|
|
continue;
|
|
|
|
char pTruncatedClientPath[MAX_PATH];
|
|
V_strncpy( pTruncatedClientPath, pClientPath, bClientRecursive ? nPathLen-2 : nPathLen );
|
|
if ( V_stristr( pTruncatedClientPath, pClientPattern ) != pTruncatedClientPath )
|
|
continue;
|
|
|
|
// This is necessary if someone has a trailing slash on their root as in c:\valve\main\
|
|
// Otherwise it'll return something like c:\valve\main\\src\blah.cpp and confuse VPC.
|
|
char szLocalRootWithoutSlashes[MAX_PATH];
|
|
V_strncpy( szLocalRootWithoutSlashes, s_p4.GetLocalRoot(), sizeof( szLocalRootWithoutSlashes ) );
|
|
V_StripTrailingSlash( szLocalRootWithoutSlashes );
|
|
|
|
if ( nClientLen < nPathLen - 3 )
|
|
{
|
|
V_snprintf( pLocalPath, nBufLen, "%s\\%s%s", szLocalRootWithoutSlashes, pTruncatedClientPath + nClientLen, bRecursive ? pDepotFile + nLen - 3 : pDepotFile + nLen - 1 );
|
|
}
|
|
else
|
|
{
|
|
V_snprintf( pLocalPath, nBufLen, "%s\\%s", szLocalRootWithoutSlashes, bRecursive ? pDepotFile + nLen - 3 : pDepotFile + nLen - 1 );
|
|
}
|
|
V_FixSlashes( pLocalPath );
|
|
nMatchCount = nLen;
|
|
}
|
|
|
|
return ( nMatchCount > 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Refreshes the current client from s_p4 settings
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::RefreshActiveClient()
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return;
|
|
|
|
RefreshClientData();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Query interface
|
|
//-----------------------------------------------------------------------------
|
|
void *CP4::QueryInterface( const char *pInterfaceName )
|
|
{
|
|
return Sys_GetFactoryThis()( pInterfaceName, NULL );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets a string for a symbol
|
|
//-----------------------------------------------------------------------------
|
|
const char *CP4::String( CUtlSymbol s ) const
|
|
{
|
|
return s.String();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: data accessor
|
|
//-----------------------------------------------------------------------------
|
|
const char *CP4::GetDepotRoot()
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return NULL;
|
|
|
|
return m_szDepotRoot;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: data accessor
|
|
//-----------------------------------------------------------------------------
|
|
int CP4::GetDepotRootLength()
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return -1;
|
|
|
|
return m_iDepotRootLength;
|
|
}
|
|
|
|
const char *CP4::GetLocalRoot()
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return NULL;
|
|
|
|
return m_szLocalRoot;
|
|
}
|
|
|
|
int CP4::GetLocalRootLength()
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return -1;
|
|
|
|
return m_iLocalRootLength;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: translates filespecs to depotFile paths
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::GetDepotFilePath(char *depotFilePath, const char *filespec, int size)
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
if ( size > 0 )
|
|
{
|
|
depotFilePath[ 0 ] = '\0';
|
|
}
|
|
return;
|
|
}
|
|
|
|
g_WhereUser.RetrieveWhereabouts(filespec);
|
|
V_strncpy(depotFilePath, g_WhereUser.GetData()[0].m_sDepotFile.String(), size);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: translates filespecs to clientFile paths
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::GetClientFilePath(char *clientFilePath, const char *filespec, int size)
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
if ( size > 0 )
|
|
{
|
|
clientFilePath[ 0 ] = '\0';
|
|
}
|
|
return;
|
|
}
|
|
|
|
g_WhereUser.RetrieveWhereabouts(filespec);
|
|
V_strncpy(clientFilePath, g_WhereUser.GetData()[0].m_sClientFile.String(), size);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: translates filespecs to localFile paths
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::GetLocalFilePath(char *localFilePath, const char *filespec, int size)
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
if ( size > 0 )
|
|
{
|
|
localFilePath[ 0 ] = '\0';
|
|
}
|
|
return;
|
|
}
|
|
|
|
g_WhereUser.RetrieveWhereabouts(filespec);
|
|
V_strncpy(localFilePath, g_WhereUser.GetData()[0].m_sLocalFile.String(), size);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns a list of files
|
|
//-----------------------------------------------------------------------------
|
|
CUtlVector<P4File_t> &CP4::GetFileList( const char *pPath )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
static CUtlVector< P4File_t > dummy;
|
|
return dummy;
|
|
}
|
|
|
|
CScopedDirClientSpec spec( pPath );
|
|
g_FileUser.RetrieveDir( pPath );
|
|
return g_FileUser.GetData();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// retreives the list of files in a path, using a known client spec
|
|
//-----------------------------------------------------------------------------
|
|
CUtlVector<P4File_t> &CP4::GetFileListUsingClientSpec( const char *pPath, const char *pClientSpec )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
static CUtlVector< P4File_t > dummy;
|
|
return dummy;
|
|
}
|
|
|
|
CScopedClientSpec spec( pClientSpec );
|
|
g_FileUser.RetrieveDir( pPath );
|
|
return g_FileUser.GetData();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the list of files opened for edit/integrate/delete
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::GetOpenedFileList( CUtlVector<P4File_t> &fileList, bool bDefaultChangeOnly )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
fileList.RemoveAll();
|
|
return;
|
|
}
|
|
|
|
g_FileUser.RetrieveOpenedFiles( fileList, bDefaultChangeOnly );
|
|
}
|
|
|
|
void CP4::GetFileListInChangelist( unsigned int changeListNumber, CUtlVector<P4File_t> &fileList )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
fileList.RemoveAll();
|
|
return;
|
|
}
|
|
g_FileUser.RetrieveFilesInChangelist( changeListNumber, fileList );
|
|
}
|
|
|
|
|
|
void CP4::GetOpenedFileList( const char *pRootDirectory, CUtlVector<P4File_t> &fileList )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
fileList.RemoveAll();
|
|
return;
|
|
}
|
|
|
|
CScopedDirClientSpec spec( pRootDirectory );
|
|
g_FileUser.RetrieveOpenedFiles( fileList, false );
|
|
}
|
|
|
|
void CP4::GetOpenedFileListInPath( const char *pPathID, CUtlVector<P4File_t> &fileList )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
fileList.RemoveAll();
|
|
return;
|
|
}
|
|
|
|
CScopedPathClientSpec spec( pPathID );
|
|
g_FileUser.RetrieveOpenedFiles( fileList, false );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: file history
|
|
//-----------------------------------------------------------------------------
|
|
CUtlVector<P4Revision_t> &CP4::GetRevisionList(const char *path, bool bIsDir)
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
static CUtlVector< P4Revision_t > dummy;
|
|
return dummy;
|
|
}
|
|
|
|
g_RevisionHistoryUser.RetrieveHistory(path, bIsDir);
|
|
return g_RevisionHistoryUser.GetData();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns a list of clients
|
|
//-----------------------------------------------------------------------------
|
|
CUtlVector<P4Client_t> &CP4::GetClientList()
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
static CUtlVector< P4Client_t > dummy;
|
|
return dummy;
|
|
}
|
|
|
|
g_ClientspecUser.RetrieveClients();
|
|
return g_ClientspecUser.GetData();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: sets the active client
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::SetActiveClient(const char *clientname)
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return;
|
|
|
|
m_Client.SetClient(clientname);
|
|
RefreshClientData();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the name of the currently opened clientspec
|
|
//-----------------------------------------------------------------------------
|
|
P4Client_t &CP4::GetActiveClient()
|
|
{
|
|
return m_ActiveClient;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: cloaks a folder from the current view
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::RemovePathFromActiveClientspec(const char *path)
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return;
|
|
|
|
// read in the clientspec
|
|
CClientspecEditUser user;
|
|
user.RetrieveClient(GetActiveClient().m_sName.String());
|
|
|
|
// get the extra info
|
|
user.m_Map.RemovePathFromClient(path);
|
|
|
|
// refresh the list
|
|
user.WriteClientspec();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finds a client spec for a directory. Is destructive to the passed-in directory
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::GetClientSpecForDirectory( const char *pFullPathDir, char *pClientSpec, int nMaxLen )
|
|
{
|
|
if ( nMaxLen == 0 )
|
|
return false;
|
|
|
|
pClientSpec[ 0 ] = '\0';
|
|
|
|
if ( !IsConnectedToServer() )
|
|
return false;
|
|
|
|
char pCurPath[ MAX_PATH ];
|
|
V_strncpy( pCurPath, pFullPathDir, sizeof(pCurPath) );
|
|
V_StripTrailingSlash( pCurPath );
|
|
characterset_t breaks;
|
|
CharacterSetBuild( &breaks, "=\n");
|
|
do
|
|
{
|
|
char pP4ConfigPath[MAX_PATH];
|
|
V_strncpy( pP4ConfigPath, pCurPath, MAX_PATH );
|
|
V_strncat( pP4ConfigPath, "\\p4config", MAX_PATH, MAX_PATH );
|
|
if ( FileExists( pP4ConfigPath ) )
|
|
{
|
|
char temp[1024];
|
|
CUtlBuffer buf( temp, sizeof(temp), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::EXTERNAL_GROWABLE );
|
|
if ( ReadFile( pP4ConfigPath, NULL, buf ) )
|
|
{
|
|
while ( buf.IsValid() )
|
|
{
|
|
char token[256], value[256];
|
|
if ( !buf.ParseToken( &breaks, token, sizeof(token) ) )
|
|
break;
|
|
if ( !buf.GetToken("=") )
|
|
break;
|
|
if ( !buf.ParseToken( &breaks, value, sizeof(value) ) )
|
|
break;
|
|
if ( !V_stricmp(token, "p4client") )
|
|
{
|
|
V_strncpy( pClientSpec, value, nMaxLen );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Warning( "Unable to read file %s!\n", pP4ConfigPath );
|
|
}
|
|
}
|
|
|
|
V_StripLastDir( pCurPath, sizeof(pCurPath) );
|
|
V_StripTrailingSlash( pCurPath );
|
|
if ( V_strlen( pCurPath ) <= 2 )
|
|
break;
|
|
|
|
} while (true);
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns which clientspec a file lies under
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::GetClientSpecForFile( const char *pFullPath, char *pClientSpec, int nMaxLen )
|
|
{
|
|
// Strip off the file name
|
|
char pCurPath[MAX_PATH];
|
|
V_strncpy( pCurPath, pFullPath, sizeof(pCurPath) );
|
|
V_StripFilename( pCurPath );
|
|
|
|
// Recursively search subdirectories until we find a p4config file.
|
|
return GetClientSpecForDirectory( pCurPath, pClientSpec, nMaxLen );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns which clientspec a filesystem path ID lies under
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::GetClientSpecForPath( const char *pPathId, char *pClientSpec, int nMaxLen )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
if ( nMaxLen > 0 )
|
|
{
|
|
pClientSpec[ 0 ] = '\0';
|
|
}
|
|
return false;
|
|
}
|
|
|
|
char pPathBuf[2048];
|
|
#if defined( STANDALONE_VPC )
|
|
V_strncpy( pPathBuf, ".", V_ARRAYSIZE( pPathBuf ) );
|
|
#else
|
|
if ( g_pFileSystem->GetSearchPath( pPathId, false, pPathBuf, sizeof(pPathBuf) ) == 0 )
|
|
return false;
|
|
#endif
|
|
// FIXME: Would be faster to not check for duplication and just
|
|
// pick the first client spec it sees. Should I not test the additional paths?
|
|
bool bFirstPath = true;
|
|
bool bFoundClientSpec = false;
|
|
char pTempClientSpec[MAX_PATH];
|
|
char *pPath = pPathBuf;
|
|
while ( pPath )
|
|
{
|
|
// Find the next path
|
|
char *pCurPath = pPath;
|
|
char *pSemi = strchr( pPath, ';' );
|
|
if ( pSemi )
|
|
{
|
|
*pSemi = 0;
|
|
pPath = pSemi+1;
|
|
}
|
|
else
|
|
{
|
|
pPath = NULL;
|
|
}
|
|
|
|
// Recursively search subdirectories until we find a p4config file.
|
|
if ( GetClientSpecForDirectory( pCurPath, pClientSpec, nMaxLen ) )
|
|
{
|
|
bFoundClientSpec = true;
|
|
if ( bFirstPath )
|
|
{
|
|
V_strncpy( pTempClientSpec, pClientSpec, sizeof(pTempClientSpec) );
|
|
}
|
|
else
|
|
{
|
|
// Paths are on different client specs
|
|
if ( V_stricmp( pClientSpec, pTempClientSpec ) )
|
|
{
|
|
pClientSpec[0] = 0;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return bFoundClientSpec;
|
|
}
|
|
|
|
void CP4::SetOpenFileChangeList( const char *pChangeListName )
|
|
{
|
|
if ( !m_sChangeListName.Length() ||
|
|
!pChangeListName || !*pChangeListName ||
|
|
strcmp( m_sChangeListName.String(), pChangeListName ) ||
|
|
pChangeListName == m_sChangeListName.String() )
|
|
{
|
|
m_sChangeListName.Set( pChangeListName );
|
|
m_sCachedChangeListNum.Set( "0" );
|
|
m_nCachedChangeListNumber = 0;
|
|
|
|
// Valid changelist
|
|
{
|
|
uint32 uiSpewFlag = CErrorHandlerUser::eFilterClUselessSpew;
|
|
int bAdd = m_sChangeListName.Length();
|
|
g_ErrorHandlerUser.SetFlags( bAdd ? uiSpewFlag : 0, bAdd ? 0 : uiSpewFlag );
|
|
}
|
|
}
|
|
}
|
|
|
|
char const * CP4::GetOpenFileChangeListNum()
|
|
{
|
|
if ( m_sChangeListName.Length() )
|
|
{
|
|
if ( !m_nCachedChangeListNumber )
|
|
{
|
|
m_nCachedChangeListNumber = FindOrCreateChangelist( m_sChangeListName.String() );
|
|
if ( m_nCachedChangeListNumber )
|
|
m_sCachedChangeListNum.Format( "%d", m_nCachedChangeListNumber );
|
|
}
|
|
|
|
if ( m_nCachedChangeListNumber )
|
|
return m_sCachedChangeListNum.String();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static bool MakeFilesWritable( int nCount, const char **ppFullPathList )
|
|
{
|
|
bool bResult = true;
|
|
|
|
// Make sure we can make as many files writable as possible
|
|
for ( int k = 0; k < nCount; ++ k )
|
|
{
|
|
char const *szFile = ppFullPathList[ k ];
|
|
if ( !access( szFile, 02 ) )
|
|
continue;
|
|
if ( !chmod( szFile, _S_IWRITE | _S_IREAD ) )
|
|
continue;
|
|
bResult = false;
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::OpenFileForAdd( const char *fullpath )
|
|
{
|
|
return PerformPerforceOpCurChangeList( "add", fullpath );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::OpenFileForEdit( const char *fullpath )
|
|
{
|
|
if ( !PerformPerforceOpCurChangeList( "edit", fullpath ) )
|
|
return false;
|
|
|
|
return MakeFilesWritable( 1, &fullpath );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::OpenFileForDelete( const char *pFullPath )
|
|
{
|
|
return PerformPerforceOpCurChangeList( "delete", pFullPath );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::SyncFile( const char *pFullPath, int nRevision )
|
|
{
|
|
char szFileOptions[ MAX_PATH + 128 ];
|
|
|
|
if ( nRevision >= 0 )
|
|
{ // sync to a specific revision
|
|
V_snprintf( szFileOptions, sizeof( szFileOptions ), "%s#%d", pFullPath, nRevision );
|
|
}
|
|
else
|
|
{ // sync to the head revision
|
|
V_snprintf( szFileOptions, sizeof( szFileOptions ), "%s#head", pFullPath );
|
|
}
|
|
|
|
return PerformPerforceOp( "sync", szFileOptions );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Submit file
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::SubmitFile( const char *pFullPath, const char *pDescription )
|
|
{
|
|
return SubmitFiles( 1, &pFullPath, pDescription );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Revert file
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::RevertFile( const char *pFullPath )
|
|
{
|
|
return PerformPerforceOp( "revert", pFullPath );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper for operations on multiple files
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::PerformPerforceOp( PerforceOp_t op, int nCount, const char **ppFullPathList, const char *pDescription )
|
|
{
|
|
g_ErrorHandlerUser.ResetErrorState();
|
|
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
g_ErrorHandlerUser.SetErrorString( "Not connected to P4 server\n", E_FATAL );
|
|
return false;
|
|
}
|
|
|
|
if ( nCount == 0 )
|
|
return true;
|
|
|
|
char pOldClientSpec[MAX_PATH];
|
|
V_strncpy( pOldClientSpec, m_Client.GetClient().Text(), sizeof(pOldClientSpec) );
|
|
|
|
char pCurrentClientSpec[MAX_PATH];
|
|
V_strncpy( pCurrentClientSpec, pOldClientSpec, sizeof(pCurrentClientSpec) );
|
|
|
|
int nFirstIndex = 0;
|
|
while ( nFirstIndex < nCount )
|
|
{
|
|
char pClientSpec[MAX_PATH];
|
|
|
|
bool bChangeSpec = false;
|
|
int i;
|
|
for ( i = nFirstIndex; i < nCount; ++i )
|
|
{
|
|
if ( s_p4.GetClientSpecForFile( ppFullPathList[i], pClientSpec, sizeof(pClientSpec) ) )
|
|
{
|
|
if ( V_stricmp( pCurrentClientSpec, pClientSpec ) )
|
|
{
|
|
bChangeSpec = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( i != nFirstIndex )
|
|
{
|
|
op( i - nFirstIndex, &ppFullPathList[nFirstIndex], pDescription );
|
|
nFirstIndex = i;
|
|
}
|
|
|
|
if ( bChangeSpec )
|
|
{
|
|
s_p4.SetActiveClient( pClientSpec );
|
|
V_strncpy( pCurrentClientSpec, pClientSpec, sizeof(pCurrentClientSpec) );
|
|
}
|
|
}
|
|
|
|
if ( V_stricmp( pCurrentClientSpec, pOldClientSpec ) )
|
|
{
|
|
s_p4.SetActiveClient( pOldClientSpec );
|
|
}
|
|
|
|
return g_ErrorHandlerUser.GetErrorState() < E_WARN;
|
|
}
|
|
|
|
static const char *s_pOperation;
|
|
void SimplePerforceOp( int nCount, const char **ppFullPathList, const char *pDescription )
|
|
{
|
|
s_p4.GetClientApi().SetArgv( nCount, const_cast<char**>( ppFullPathList ) );
|
|
s_p4.GetClientApi().Run( s_pOperation, &g_ErrorHandlerUser );
|
|
}
|
|
|
|
bool CP4::PerformPerforceOp( const char *pOperation, int nCount, const char **ppFullPathList )
|
|
{
|
|
s_pOperation = pOperation;
|
|
return PerformPerforceOp( SimplePerforceOp, nCount, ppFullPathList, NULL );
|
|
}
|
|
|
|
void SimplePerforceOpCurChangeList( int nCount, const char **ppFullPathList, const char *pDescription )
|
|
{
|
|
if ( char const *szClNum = s_p4.GetOpenFileChangeListNum() )
|
|
{
|
|
CUtlVector< const char * > arrArgv;
|
|
arrArgv.SetCount( nCount + 3 );
|
|
arrArgv[0] = "-c";
|
|
arrArgv[1] = szClNum;
|
|
for ( int k = 0; k < nCount; ++ k )
|
|
arrArgv[ 2 + k ] = ppFullPathList[ k ];
|
|
arrArgv[ nCount + 2 ] = NULL;
|
|
|
|
s_p4.GetClientApi().SetArgv( nCount + 2, const_cast<char**>( arrArgv.Base() ) );
|
|
s_p4.GetClientApi().Run( s_pOperation, &g_ErrorHandlerUser );
|
|
}
|
|
else
|
|
{
|
|
s_p4.GetClientApi().SetArgv( nCount, const_cast<char**>( ppFullPathList ) );
|
|
s_p4.GetClientApi().Run( s_pOperation, &g_ErrorHandlerUser );
|
|
}
|
|
}
|
|
|
|
bool CP4::PerformPerforceOpCurChangeList( const char *pOperation, int nCount, const char **ppFullPathList )
|
|
{
|
|
if ( m_sChangeListName.Length() )
|
|
{
|
|
s_pOperation = pOperation;
|
|
return PerformPerforceOp( SimplePerforceOpCurChangeList, nCount, ppFullPathList, NULL );
|
|
}
|
|
else
|
|
{
|
|
return PerformPerforceOp( pOperation, nCount, ppFullPathList );
|
|
}
|
|
}
|
|
|
|
bool CP4::PerformPerforceOp( const char *pOperation, const char *pFullPath )
|
|
{
|
|
g_ErrorHandlerUser.ResetErrorState();
|
|
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
g_ErrorHandlerUser.SetErrorString( "Not connected to P4 server\n", E_FATAL );
|
|
return false;
|
|
}
|
|
|
|
CScopedFileClientSpec spec( pFullPath );
|
|
|
|
char *argv[] = { (char *)pFullPath, NULL };
|
|
m_Client.SetArgv( 1, argv );
|
|
m_Client.Run( pOperation, &g_ErrorHandlerUser );
|
|
|
|
return g_ErrorHandlerUser.GetErrorState() < E_WARN;
|
|
}
|
|
|
|
bool CP4::PerformPerforceOpCurChangeList( const char *pOperation, const char *pFullPath )
|
|
{
|
|
g_ErrorHandlerUser.ResetErrorState();
|
|
|
|
if ( !IsConnectedToServer() )
|
|
{
|
|
g_ErrorHandlerUser.SetErrorString( "Not connected to P4 server\n", E_FATAL );
|
|
return false;
|
|
}
|
|
|
|
CScopedFileClientSpec spec( pFullPath );
|
|
|
|
char *argv[] = { "-c", "", (char *)pFullPath, NULL }, **pArgv = argv;
|
|
int numArgv = 3;
|
|
|
|
if ( char const *szClNum = GetOpenFileChangeListNum() )
|
|
{
|
|
argv[ 1 ] = const_cast< char * >( szClNum );
|
|
}
|
|
else
|
|
{
|
|
pArgv += 2;
|
|
numArgv -= 2;
|
|
}
|
|
|
|
m_Client.SetArgv( numArgv, pArgv );
|
|
m_Client.Run( pOperation, &g_ErrorHandlerUser );
|
|
|
|
return g_ErrorHandlerUser.GetErrorState() < E_WARN;
|
|
}
|
|
|
|
bool CP4::OpenFilesForAdd( int nCount, const char **ppFullPathList )
|
|
{
|
|
return PerformPerforceOpCurChangeList( "add", nCount, ppFullPathList );
|
|
}
|
|
|
|
bool CP4::OpenFilesForEdit( int nCount, const char **ppFullPathList )
|
|
{
|
|
if ( !PerformPerforceOpCurChangeList( "edit", nCount, ppFullPathList ) )
|
|
return false;
|
|
|
|
return MakeFilesWritable( nCount, ppFullPathList );
|
|
}
|
|
|
|
bool CP4::OpenFilesForDelete( int nCount, const char **ppFullPathList )
|
|
{
|
|
return PerformPerforceOpCurChangeList( "delete", nCount, ppFullPathList );
|
|
}
|
|
|
|
bool CP4::RevertFiles( int nCount, const char **ppFullPathList )
|
|
{
|
|
return PerformPerforceOp( "revert", nCount, ppFullPathList );
|
|
}
|
|
|
|
|
|
void SubmitPerforceOp( int nCount, const char **ppFullPathList, const char *pDescription )
|
|
{
|
|
Assert( nCount > 0 );
|
|
if ( nCount <= 0 )
|
|
return;
|
|
|
|
// First, create a new changelist
|
|
g_ChangelistCreateUser.CreateChangelist( pDescription );
|
|
if ( g_ChangelistCreateUser.GetData().Count() == 0 )
|
|
{
|
|
g_ErrorHandlerUser.SetErrorString( "Failed to create changelist for submit operation", E_FATAL );
|
|
return;
|
|
}
|
|
|
|
int nChangeList = g_ChangelistCreateUser.GetData()[0];
|
|
|
|
// Next, move all files to that new changelist
|
|
char pBuf[128];
|
|
V_snprintf( pBuf, sizeof(pBuf), "%d", nChangeList );
|
|
char **ppArgv = (char **)_alloca( (nCount + 2) * sizeof(char*) );
|
|
ppArgv[0] = "-c";
|
|
ppArgv[1] = pBuf;
|
|
memcpy( &ppArgv[2], ppFullPathList, nCount * sizeof(char*) );
|
|
s_p4.GetClientApi().SetArgv( nCount+2, ppArgv );
|
|
s_p4.GetClientApi().Run( "reopen", &g_ErrorHandlerUser );
|
|
|
|
// Finally, submit that changelist
|
|
g_SubmitUser.Submit( nChangeList );
|
|
}
|
|
|
|
bool CP4::SubmitFiles( int nCount, const char **ppFullPathList, const char *pDescription )
|
|
{
|
|
return PerformPerforceOp( SubmitPerforceOp, nCount, ppFullPathList, pDescription );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Opens a file in s_p4 win
|
|
//-----------------------------------------------------------------------------
|
|
void CP4::OpenFileInP4Win( const char *pFullPath )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return;
|
|
|
|
char pClientSpec[MAX_PATH];
|
|
char pSystem[512];
|
|
if ( GetClientSpecForFile( pFullPath, pClientSpec, sizeof(pClientSpec) ) )
|
|
{
|
|
V_snprintf( pSystem, sizeof(pSystem), "p4win -q -c %s -s %s", pClientSpec, pFullPath );
|
|
}
|
|
else
|
|
{
|
|
V_snprintf( pSystem, sizeof(pSystem), "p4win -q -s %s", pFullPath );
|
|
}
|
|
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
|
|
ZeroMemory( &si, sizeof(si) );
|
|
si.cb = sizeof(si);
|
|
ZeroMemory( &pi, sizeof(pi) );
|
|
|
|
// Start the child process.
|
|
CreateProcess( NULL, // No module name (use command line).
|
|
pSystem, // Command line.
|
|
NULL, // Process handle not inheritable.
|
|
NULL, // Thread handle not inheritable.
|
|
FALSE, // Set handle inheritance to FALSE.
|
|
0, // No creation flags.
|
|
NULL, // Use parent's environment block.
|
|
NULL, // Use parent's starting directory.
|
|
&si, // Pointer to STARTUPINFO structure.
|
|
&pi ); // Pointer to PROCESS_INFORMATION structure.
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is this file in perforce?
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::IsFileInPerforce( const char *fullpath )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return false;
|
|
|
|
CScopedFileClientSpec spec( fullpath );
|
|
|
|
g_FileUser.RetrieveFile( fullpath );
|
|
if ( g_FileUser.GetData().Count() == 0 )
|
|
return false;
|
|
|
|
// Return deleted files as not being in perforce
|
|
return !g_FileUser.GetData()[0].m_bDeleted;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is this file opened for edit?
|
|
//-----------------------------------------------------------------------------
|
|
P4FileState_t CP4::GetFileState( const char *pFullPath )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return P4FILE_UNOPENED;
|
|
|
|
CScopedFileClientSpec spec( pFullPath );
|
|
|
|
g_FileUser.RetrieveOpenedFiles( pFullPath );
|
|
if ( g_FileUser.GetData().Count() == 0 )
|
|
return P4FILE_UNOPENED;
|
|
return g_FileUser.GetData()[0].m_eOpenState;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns file information for a single file
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::GetFileInfo( const char *pFullPath, P4File_t *pFileInfo )
|
|
{
|
|
if ( !IsConnectedToServer() )
|
|
return false;
|
|
|
|
CScopedFileClientSpec spec( pFullPath );
|
|
|
|
g_FileUser.RetrieveFile( pFullPath );
|
|
if ( g_FileUser.GetData().Count() != 1 )
|
|
return false;
|
|
|
|
memcpy( pFileInfo, &g_FileUser.GetData()[0], sizeof(P4File_t) );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Are we connected to the server? (and should we reconnect?)
|
|
//-----------------------------------------------------------------------------
|
|
bool CP4::IsConnectedToServer( bool bRetry )
|
|
{
|
|
if ( bRetry && m_bConnectedToServer )
|
|
{
|
|
// don't comment this back in until it's called less often to avoid spamming the server
|
|
// (currently, this is called every time the ifm file menu is opened)
|
|
// this means that we won't detect losing the server until after a failed Run() cmd
|
|
// -jd
|
|
|
|
// m_Client.Run( "monitor show" ); // do something to test if the server's still up
|
|
if ( m_Client.Dropped() )
|
|
{
|
|
Shutdown();
|
|
}
|
|
}
|
|
|
|
if ( !m_bConnectedToServer && bRetry )
|
|
{
|
|
Init();
|
|
}
|
|
|
|
return m_bConnectedToServer;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// retrieves the last error from the last op (which is likely to span multiple lines)
|
|
// this is only valid after OpenFile[s]For{Add,Edit,Delete} or {Submit,Revert}File[s]
|
|
//-----------------------------------------------------------------------------
|
|
const char *CP4::GetLastError()
|
|
{
|
|
return g_ErrorHandlerUser.GetErrorString();
|
|
}
|