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.
2270 lines
68 KiB
2270 lines
68 KiB
//========= Copyright 1996-2006, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: VPC
|
|
//
|
|
//=====================================================================================//
|
|
|
|
#include "vpc.h"
|
|
#include "dependencies.h"
|
|
#include "p4sln.h"
|
|
#include "ilaunchabledll.h"
|
|
|
|
DEFINE_LOGGING_CHANNEL_NO_TAGS( LOG_VPC, "VPC" );
|
|
|
|
CVPC *g_pVPC;
|
|
CPosixSolutionGenerator g_PosixSolutionGenerator;
|
|
|
|
class CBaseProjectDataCollector;
|
|
CUtlVector<CBaseProjectDataCollector*> g_vecPGenerators;
|
|
|
|
// Stuff that we might encounter in a vpc file that parts of vpc care about
|
|
const char *g_pOption_ImportLibrary = "$ImportLibrary";
|
|
const char *g_pOption_OutputFile = "$OutputFile";
|
|
const char *g_pOption_AdditionalIncludeDirectories = "$AdditionalIncludeDirectories";
|
|
const char *g_pOption_AdditionalProjectDependencies = "$AdditionalProjectDependencies";
|
|
const char *g_pOption_AdditionalOutputFiles = "$AdditionalOutputFiles";
|
|
const char *g_pOption_PreprocessorDefinitions = "$PreprocessorDefinitions";
|
|
char *g_IncludeSeparators[2] = {";",","};
|
|
|
|
#ifdef POSIX
|
|
#define _unlink unlink
|
|
#define _stat stat
|
|
#endif
|
|
|
|
CVPC::CVPC()
|
|
{
|
|
m_pP4Module = NULL;
|
|
m_pFilesystemModule = NULL;
|
|
|
|
m_nArgc = 0;
|
|
m_ppArgv = NULL;
|
|
|
|
m_bVerbose = false;
|
|
m_bQuiet = false;
|
|
m_bUsageOnly = false;
|
|
m_bHelp = false;
|
|
m_bSpewPlatforms = false;
|
|
m_bSpewGames = false;
|
|
m_bSpewGroups = false;
|
|
m_bSpewProjects = false;
|
|
m_bIgnoreRedundancyWarning = false;
|
|
m_bSpewProperties = false;
|
|
m_bTestMode = false;
|
|
m_bGeneratedProject = false;
|
|
m_bAnyProjectQualified = false;
|
|
m_bForceGenerate = false;
|
|
m_bEnableVpcGameMacro = true;
|
|
m_bDecorateProject = false;
|
|
m_bShowDeps = false;
|
|
m_bP4AutoAdd = false;
|
|
m_bP4SlnCheckEverything = false;
|
|
m_bPS3SDKPresent = false;
|
|
m_bXDKPresent = false;
|
|
m_bShowCaseIssues = false;
|
|
|
|
// the default is now 2013
|
|
m_bWants2010 = false;
|
|
m_bUse2010 = false;
|
|
m_bWants2012 = false;
|
|
m_bUse2012 = false;
|
|
m_bWants2013 = true;
|
|
m_bUse2013 = false;
|
|
|
|
// need to check files by default, otherwise dependency failure (due to missing file) cause needles rebuilds
|
|
m_bCheckFiles = true;
|
|
|
|
m_pProjectGenerator = NULL;
|
|
m_pSolutionGenerator = NULL;
|
|
|
|
#ifdef OSX
|
|
m_bForceIterate = true;
|
|
#else
|
|
m_bForceIterate = false;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::Init( int argc, char **argv )
|
|
{
|
|
m_nArgc = argc;
|
|
m_ppArgv = argv;
|
|
|
|
CommandLine()->CreateCmdLine( m_nArgc, m_ppArgv );
|
|
|
|
// vpc operates tersely by preferred company opinion
|
|
// verbosity necessary for debugging
|
|
m_bVerbose = ( HasCommandLineParameter( "/v" ) || HasCommandLineParameter( "/verbose" ) );
|
|
m_bQuiet = ( HasCommandLineParameter( "/q" ) ||
|
|
HasCommandLineParameter( "/quiet" ) ||
|
|
( getenv( "VPC_QUIET" ) && V_stricmp( getenv( "VPC_QUIET" ), "0" ) ) );
|
|
|
|
#ifndef STEAM
|
|
// We don't really need to pop the logging state since the process will terminate when we're done.
|
|
LoggingSystem_PushLoggingState();
|
|
|
|
m_LoggingListener.m_bQuietPrintf = m_bQuiet;
|
|
LoggingSystem_RegisterLoggingListener( &m_LoggingListener );
|
|
#endif
|
|
|
|
// needs to occur early and before any other expensive setup, a crc check just exits with an error code used by caller
|
|
InProcessCRCCheck();
|
|
|
|
LoadPerforceInterface();
|
|
|
|
// vpc may have been run from wrong location, restart self
|
|
bool bIsRestart = false;
|
|
if ( RestartFromCorrectLocation( &bIsRestart ) )
|
|
{
|
|
// successfully ran under restart condition, all done
|
|
return false;
|
|
}
|
|
if ( bIsRestart )
|
|
{
|
|
// this process is the restart child, cull the internal private restart guard option
|
|
// otherwise it gets confused as a build option
|
|
m_nArgc--;
|
|
}
|
|
|
|
Log_Msg( LOG_VPC, "VPC - Valve Project Creator For " );
|
|
#ifdef POSIX
|
|
Log_Msg( LOG_VPC, "XCode and Makefiles (Build: %s %s)\n", __DATE__, __TIME__ );
|
|
#else
|
|
Log_Msg( LOG_VPC, "Visual Studio, Xbox 360, PlayStation 3 (Build: %s %s)\n", __DATE__, __TIME__ );
|
|
#endif
|
|
Log_Msg( LOG_VPC, "(C) Copyright 1996-2010, Valve Corporation, All rights reserved.\n" );
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::Shutdown( bool bHasError )
|
|
{
|
|
if ( !bHasError )
|
|
{
|
|
GetScript().EnsureScriptStackEmpty();
|
|
}
|
|
|
|
if ( !m_TempGroupScriptFilename.IsEmpty() )
|
|
{
|
|
// delete temp work file
|
|
_unlink( m_TempGroupScriptFilename.Get() );
|
|
m_TempGroupScriptFilename.Clear();
|
|
}
|
|
|
|
UnloadPerforceInterface();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::LoadPerforceInterface()
|
|
{
|
|
if ( p4 )
|
|
{
|
|
// already loaded
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// Try to load p4lib.dll and the filesystem since the p4lib relies on it
|
|
//
|
|
char p4libdll[MAX_PATH];
|
|
char filesystemdll[MAX_PATH];
|
|
|
|
#ifdef _WIN32
|
|
// Don't require them to have game\bin in their path. Since we know where vpc.exe is,
|
|
// point directly to p4lib.dll in its rightful place.
|
|
char szModuleBinPath[MAX_PATH];
|
|
GetModuleFileName( NULL, szModuleBinPath, sizeof( szModuleBinPath ) );
|
|
V_ExtractFilePath( szModuleBinPath, p4libdll, sizeof( p4libdll ) );
|
|
V_AppendSlash( p4libdll, sizeof( p4libdll ) );
|
|
V_strncpy( filesystemdll, p4libdll, sizeof( filesystemdll ) );
|
|
V_strncat( p4libdll, "..\\..\\..\\game\\bin\\p4lib.dll", sizeof( p4libdll ) );
|
|
V_strncat( filesystemdll, "..\\..\\..\\game\\bin\\filesystem_stdio.dll", sizeof( filesystemdll ) );
|
|
#else
|
|
V_strncpy( p4libdll, "p4lib", sizeof( p4libdll ) );
|
|
V_strncpy( filesystemdll, "filesystem_stdio", sizeof( filesystemdll ) );
|
|
#endif
|
|
|
|
if ( !Sys_LoadInterface( p4libdll, P4_INTERFACE_VERSION, &m_pP4Module, (void**)&p4 ) )
|
|
{
|
|
#ifdef _WIN32
|
|
// This always fails on non-Windows build machines -- the warning is
|
|
// annoying and not helpful.
|
|
VPCWarning( "Unable to get Perforce interface from p4lib.dll." );
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
// Let the P4 module get its interface to the filesystem - hate this
|
|
|
|
// This method is not available in portal2, but is in source2.
|
|
// p4->SetVerbose( false );
|
|
m_pFilesystemModule = Sys_LoadModule( filesystemdll );
|
|
p4->Connect( Sys_GetFactory( m_pFilesystemModule ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::UnloadPerforceInterface()
|
|
{
|
|
// Unload P4 if it was loaded
|
|
if ( m_pP4Module )
|
|
{
|
|
Sys_UnloadModule( m_pP4Module );
|
|
m_pP4Module = NULL;
|
|
}
|
|
|
|
if ( m_pFilesystemModule )
|
|
{
|
|
Sys_UnloadModule( m_pFilesystemModule );
|
|
m_pFilesystemModule = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
bool VPC_Config_IgnoreOption( const char *pPropertyName )
|
|
{
|
|
char buff[MAX_SYSTOKENCHARS];
|
|
g_pVPC->GetScript().ParsePropertyValue( NULL, buff, sizeof( buff ) );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::VPCError( const char* format, ... )
|
|
{
|
|
va_list argptr;
|
|
char msg[MAX_SYSPRINTMSG];
|
|
|
|
va_start( argptr,format );
|
|
vsprintf( msg,format,argptr );
|
|
va_end( argptr );
|
|
|
|
// spew in red
|
|
Log_Warning( LOG_VPC, Color( 255, 0, 0, 255 ), "ERROR: %s\n", msg );
|
|
|
|
// dump the script stack to assist in user understading of the include chain
|
|
GetScript().SpewScriptStack();
|
|
|
|
// do proper shutdown in an error context
|
|
Shutdown( true );
|
|
|
|
// errors are expected to be fatal by all calling code
|
|
// otherwise it would have been a warning
|
|
exit( 1 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::VPCSyntaxError( const char* format, ... )
|
|
{
|
|
va_list argptr;
|
|
char msg[MAX_SYSPRINTMSG];
|
|
|
|
va_start( argptr, format );
|
|
if ( format )
|
|
{
|
|
vsprintf( msg, format, argptr );
|
|
}
|
|
va_end( argptr );
|
|
|
|
if ( format )
|
|
{
|
|
Log_Warning( LOG_VPC, Color( 255, 0, 0, 255 ), "Bad Syntax: %s\n", msg );
|
|
}
|
|
|
|
// syntax errors are fatal
|
|
VPCError( "Bad Syntax in '%s' line:%d\n", GetScript().GetName(), GetScript().GetLine() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::VPCWarning( const char* format, ... )
|
|
{
|
|
va_list argptr;
|
|
char msg[MAX_SYSPRINTMSG];
|
|
|
|
va_start( argptr,format );
|
|
vsprintf( msg,format,argptr );
|
|
va_end( argptr );
|
|
|
|
if ( m_bIgnoreRedundancyWarning )
|
|
{
|
|
if ( V_stristr( msg, "matches default setting" ) )
|
|
return;
|
|
if ( V_stristr( msg, "already exists in project" ) )
|
|
return;
|
|
}
|
|
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "WARNING: %s\n", msg );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::VPCStatus( bool bAlwaysSpew, const char* format, ... )
|
|
{
|
|
if ( m_bQuiet )
|
|
return;
|
|
|
|
va_list argptr;
|
|
char msg[MAX_SYSPRINTMSG];
|
|
|
|
va_start( argptr,format );
|
|
vsprintf( msg,format,argptr );
|
|
va_end( argptr );
|
|
|
|
if ( bAlwaysSpew || m_bVerbose )
|
|
{
|
|
Log_Msg( LOG_VPC, "%s\n", msg );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Checks to ensure the bin path is in the same tree as the vpc_scripts
|
|
// Returns true if bin path valid
|
|
//-----------------------------------------------------------------------------
|
|
#if !defined( POSIX )
|
|
bool CVPC::CheckBinPath( char *pOutBinPath, int outBinPathSize )
|
|
{
|
|
char szScriptPath[MAX_PATH];
|
|
char szDirectory[MAX_PATH];
|
|
char szLastDirectory[MAX_PATH];
|
|
|
|
// non destructively determine the vpc_scripts directory
|
|
bool bFound = false;
|
|
szLastDirectory[0] = '\0';
|
|
szScriptPath[0] = '\0';
|
|
V_GetCurrentDirectory( szDirectory, sizeof( szDirectory ) );
|
|
while ( 1 )
|
|
{
|
|
V_ComposeFileName( szDirectory, "vpc_scripts", szScriptPath, sizeof( szScriptPath ) );
|
|
struct _stat statBuf;
|
|
if ( _stat( szScriptPath, &statBuf ) != -1 )
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
|
|
// previous dir
|
|
V_ComposeFileName( szDirectory, "..", szScriptPath, sizeof( szScriptPath ) );
|
|
|
|
char fullPath[MAX_PATH];
|
|
if ( _fullpath( fullPath, szScriptPath, sizeof( fullPath ) ) )
|
|
{
|
|
V_strncpy( szDirectory, fullPath, sizeof( szDirectory ) );
|
|
}
|
|
|
|
if ( !V_stricmp( szDirectory, szLastDirectory ) )
|
|
{
|
|
// can back up no further
|
|
break;
|
|
}
|
|
strcpy( szLastDirectory, szDirectory );
|
|
}
|
|
|
|
if ( !bFound )
|
|
{
|
|
VPCError( "Failed to determine source directory from current path. Expecting 'vpc_scripts' in source path." );
|
|
}
|
|
|
|
char szSourcePath[MAX_PATH];
|
|
strcpy( szSourcePath, szDirectory );
|
|
|
|
// check to ensure that executeable and src directory are in the same tree
|
|
// executeable needs to be tightly bound to its vpc_scripts
|
|
char szModuleBinPath[MAX_PATH];
|
|
GetModuleFileName( NULL, szModuleBinPath, sizeof( szModuleBinPath ) );
|
|
|
|
// cannot trust output from GetModuleFileName(), occasionally has ./ or ../ screwing up comparisons
|
|
V_RemoveDotSlashes( szModuleBinPath, '\\' );
|
|
V_strlower( szModuleBinPath );
|
|
V_strncpy( pOutBinPath, szModuleBinPath, outBinPathSize );
|
|
|
|
// allowed to run from a root "devbin", for use with junctions
|
|
if ( Sys_StringPatternMatch( "?:\\devbin\\vpc.exe", szModuleBinPath ) )
|
|
return true;
|
|
|
|
char *pString = V_stristr( szModuleBinPath, "\\devtools\\bin\\" );
|
|
if ( pString )
|
|
{
|
|
// source dirs should match
|
|
char chSave = *pString;
|
|
*pString = '\0';
|
|
bool bSame = V_stricmp( szSourcePath, szModuleBinPath ) == 0;
|
|
*pString = chSave;
|
|
|
|
if ( bSame )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VPCError( "Executable not running from 'devtools/bin' but from unexpected directory '%s'", szModuleBinPath );
|
|
}
|
|
|
|
// mismatched, wierd bin patch could have been a result of user's environment path
|
|
// use expected source path which is based on user's cwd to get the real bin path
|
|
V_strncpy( pOutBinPath, szSourcePath, outBinPathSize );
|
|
V_strncat( pOutBinPath, "\\devtools\\bin\\vpc.exe", outBinPathSize );
|
|
struct _stat statBuf;
|
|
if ( _stat( pOutBinPath, &statBuf ) == -1 )
|
|
{
|
|
VPCError( "Correct executeable missing, should be at '%s'", pOutBinPath );
|
|
}
|
|
|
|
// yikes, wrong executeable was started, agreed behavior was to restart based on user's cwd
|
|
// REALLY want users to see this, it indicates a possible hazard of using the wrong vpc
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "********************************************************************************\n" );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "Wrong Executable '%s' Running!\nRestarting at '%s'\n", szModuleBinPath, pOutBinPath );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "********************************************************************************\n" );
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::DetermineSourcePath()
|
|
{
|
|
char szSourcePath[MAX_PATH];
|
|
char szLastDirectory[MAX_PATH];
|
|
|
|
char szOldPath[MAX_PATH];
|
|
V_GetCurrentDirectory( szOldPath, sizeof( szOldPath ) );
|
|
|
|
// find vpc_scripts from cwd
|
|
szLastDirectory[0] = '\0';
|
|
bool bFound = false;
|
|
while ( 1 )
|
|
{
|
|
V_GetCurrentDirectory( szSourcePath, sizeof( szSourcePath ) );
|
|
if ( !V_stricmp( szSourcePath, szLastDirectory ) )
|
|
{
|
|
// can back up no further
|
|
break;
|
|
}
|
|
V_strncpy( szLastDirectory, szSourcePath, sizeof( szLastDirectory ) );
|
|
|
|
char szTestDir[MAX_PATH];
|
|
V_ComposeFileName( szSourcePath, "vpc_scripts", szTestDir, sizeof( szTestDir ) );
|
|
struct _stat statBuf;
|
|
if ( _stat( szTestDir, &statBuf ) != -1 )
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
|
|
// previous dir
|
|
char szPrevDir[MAX_PATH];
|
|
V_ComposeFileName( szSourcePath, "..", szPrevDir, sizeof( szPrevDir ) );
|
|
V_SetCurrentDirectory( szPrevDir );
|
|
}
|
|
|
|
if ( !bFound )
|
|
{
|
|
VPCError( "Failed to determine source directory from current path. Expecting 'vpc_scripts' in source path." );
|
|
}
|
|
|
|
// Remember the source path and restore the path to where it was.
|
|
m_SourcePath = szSourcePath;
|
|
V_SetCurrentDirectory( szOldPath );
|
|
|
|
// always emit source path, identifies MANY redundant user problems
|
|
// users can easily run from an unintended place due to botched path, mangled directories, etc
|
|
Log_Msg( LOG_VPC, "Source Path: %s\n", m_SourcePath.Get() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the working directory to .../vpc_scripts as all scripts are
|
|
// guaranteed relative to the vpc script directory.
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::SetDefaultSourcePath()
|
|
{
|
|
V_SetCurrentDirectory( m_SourcePath.Get() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::IsProjectCurrent( const char *pOutputFilename )
|
|
{
|
|
// default is project is stale
|
|
if ( !Sys_Exists( pOutputFilename ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Is2010() && !Sys_Exists( CFmtStr( "%s.filters", pOutputFilename ) ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
char errorString[1024];
|
|
bool bCRCValid = VPC_CheckProjectDependencyCRCs( pOutputFilename, m_SupplementalCRCString.Get(), errorString, sizeof( errorString ) );
|
|
|
|
if ( bCRCValid )
|
|
{
|
|
VPCStatus( true, "Valid: '%s' Passes CRC Checks.", pOutputFilename );
|
|
}
|
|
else
|
|
{
|
|
VPCStatus( true, "Stale: '%s' Requires Rebuild.", pOutputFilename );
|
|
}
|
|
|
|
return bCRCValid;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::SpewUsage( void )
|
|
{
|
|
// skip header if user requested specific detail
|
|
bool bNoHeader =
|
|
m_bSpewPlatforms ||
|
|
m_bSpewGames ||
|
|
m_bSpewProjects ||
|
|
m_bSpewGroups ||
|
|
m_bSpewProperties ||
|
|
m_BuildCommands.Count();
|
|
|
|
if ( !bNoHeader )
|
|
{
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
|
|
if ( !m_bHelp )
|
|
{
|
|
// terse
|
|
Log_Msg( LOG_VPC, "Type vpc /h for help...\n" );
|
|
}
|
|
else
|
|
{
|
|
// verbose
|
|
Log_Msg( LOG_VPC, "usage: vpc [options] <+/-/*project or group>\n");
|
|
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
Log_Msg( LOG_VPC, "Examples:\n" );
|
|
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
Log_Msg( LOG_VPC, " Single .vcproj generation:\n" );
|
|
Log_Msg( LOG_VPC, " vpc +client /hl2 <-- Creates a Win32 .vcproj for the HL2 client.\n" );
|
|
Log_Msg( LOG_VPC, " vpc +shaderapi /x360 <-- Creates a Xbox360 .vcproj for the shaderapi.\n" );
|
|
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
Log_Msg( LOG_VPC, " Multiple .vcproj generation - Multiple Projects for Games and Platforms:\n" );
|
|
Log_Msg( LOG_VPC, " vpc +client /hl2 /tf <-- Creates ALL the Win32 .vcprojs for the HL2 and TF client.\n" );
|
|
Log_Msg( LOG_VPC, " vpc +gamedlls /allgames <-- Creates ALL the Win32 .vcprojs for client and server for all GAMES.\n" );
|
|
Log_Msg( LOG_VPC, " vpc +tools -tier0 /win32 /x360 <-- Creates ALL the Win32 and Xbox360 .vcprojs for the tool projects but not the tier0 project.\n" );
|
|
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
Log_Msg( LOG_VPC, " Use +/- to add or remove projects or groups.\n");
|
|
Log_Msg( LOG_VPC, " Use * to add a project and all projects that depend on it.\n");
|
|
Log_Msg( LOG_VPC, " Use @ to add a project and all projects that it depends on.\n");
|
|
Log_Msg( LOG_VPC, " Use /h spew final target build set only (no .vcproj created).\n");
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
Log_Msg( LOG_VPC, " Further details can be found on Valve Internal Wiki on VPC.\n" );
|
|
|
|
Log_Msg( LOG_VPC, "\n--- OPTIONS ---\n" );
|
|
Log_Msg( LOG_VPC, "[/q]: Quiet mode (quiet mode is automatically on if the VPC_QUIET environment variable is set)\n" );
|
|
Log_Msg( LOG_VPC, "[/v]: Verbose\n" );
|
|
Log_Msg( LOG_VPC, "[/f]: Force generate .vcproj, otherwise use crc checks\n" );
|
|
Log_Msg( LOG_VPC, "[/dp]: Decorate project names with platform\n" );
|
|
Log_Msg( LOG_VPC, "[/testmode]: Override output .vcproj file to be named 'test.vcproj'\n" );
|
|
Log_Msg( LOG_VPC, "[/2013]: Generate projects and solutions for Visual Studio 2013 [default]\n" );
|
|
Log_Msg( LOG_VPC, "[/2012]: Generate projects and solutions for Visual Studio 2012\n" );
|
|
Log_Msg( LOG_VPC, "[/2010]: Generate projects and solutions for Visual Studio 2010\n" );
|
|
Log_Msg( LOG_VPC, "[/2005]: Generate projects and solutions for Visual Studio 2005\n" );
|
|
|
|
Log_Msg( LOG_VPC, "\n--- Help ---\n" );
|
|
Log_Msg( LOG_VPC, "[/h]: Help\n" );
|
|
Log_Msg( LOG_VPC, "[/?]: Help\n" );
|
|
Log_Msg( LOG_VPC, "[/platforms]: Spew Platforms\n" );
|
|
Log_Msg( LOG_VPC, "[/games]: Spew Games\n" );
|
|
Log_Msg( LOG_VPC, "[/projects]: Spew Projects\n" );
|
|
Log_Msg( LOG_VPC, "[/groups]: Spew Groups\n" );
|
|
Log_Msg( LOG_VPC, "[/properties]: Spew VS2005 Properties\n" );
|
|
|
|
Log_Msg( LOG_VPC, "\n--- Conditionals ---\n" );
|
|
Log_Msg( LOG_VPC, "[/profile]: Set Reserved $PROFILE=1\n" );
|
|
Log_Msg( LOG_VPC, "[/retail]: Set Reserved $RETAIL=1\n" );
|
|
Log_Msg( LOG_VPC, "[/callcap]: Set Reserved $CALLCAP=1\n" );
|
|
Log_Msg( LOG_VPC, "[/fastcap]: Set Reserved $FASTCAP=1\n" );
|
|
Log_Msg( LOG_VPC, "[/cert]: Set Reserved $CERT=1\n" );
|
|
Log_Msg( LOG_VPC, "[/memtest]: Set Reserved $MEMTEST=1\n" );
|
|
Log_Msg( LOG_VPC, "[/nofpo]: Set Reserved $NOFPO=1\n" );
|
|
Log_Msg( LOG_VPC, "[/lv]: Set Reserved $LV=1\n" );
|
|
Log_Msg( LOG_VPC, "[/demo]: Set Reserved $DEMO=1\n" );
|
|
Log_Msg( LOG_VPC, "[/no_steam]: Set Reserved $NO_STEAM=1\n" );
|
|
Log_Msg( LOG_VPC, "[/qtdebug]: Set Reserved $QTDEBUG=1\n" );
|
|
Log_Msg( LOG_VPC, "[/no_ceg]: Set Reserved $NO_CEG=1\n" );
|
|
Log_Msg( LOG_VPC, "[/upload_ceg]: Set Reserved $UPLOAD_CEG=1\n" );
|
|
|
|
|
|
Log_Msg( LOG_VPC, "\n--- Other ---\n" );
|
|
Log_Msg( LOG_VPC, "[/mksln]: <.sln filename> - make a solution file\n" );
|
|
Log_Msg( LOG_VPC, "[/p4sln]: <.sln filename> <changelists...> - make a solution file based on\n" );
|
|
Log_Msg( LOG_VPC, " the changelist. Changelists can be specific numbers, 0 or \"default\"\n" );
|
|
Log_Msg( LOG_VPC, " for the default changelist, or \"all\" for all active changelists.\n" );
|
|
Log_Msg( LOG_VPC, "[/nop4add]: Don't automatically add project files to Perforce\n" );
|
|
Log_Msg( LOG_VPC, "[/slnitems]: <filename> - adds all files listed in <filename> to generated\n" );
|
|
Log_Msg( LOG_VPC, " solutions\n" );
|
|
Log_Msg( LOG_VPC, "[/showdeps]: Show an example dependency chain for each project that depends\n" );
|
|
Log_Msg( LOG_VPC, " on your p4 change list(s). Use with /p4sln.\n" );
|
|
Log_Msg( LOG_VPC, "[/checkfiles]: Check for the existence of files in $file commands. For debugging vpc files.\n" );
|
|
Log_Msg( LOG_VPC, " Only works if the currrent directory is the project directory.\n" );
|
|
// Log_Msg( LOG_VPC, "[/novpcgame]: Disable reserved vpc macro $VPCGAME and $VPCGAMECAPS.\n" );
|
|
// Log_Msg( LOG_VPC, " By default if a single game is specified on command line, then that specified\n" );
|
|
// Log_Msg( LOG_VPC, " game name will be used as a value for $VPCGAME and $VPCGAMECAPS macros.\n" );
|
|
Log_Msg( LOG_VPC, "[/define:xxx]: Enable a custom conditional $XXX to use for quick testing in VPC files.\n" );
|
|
}
|
|
}
|
|
|
|
if ( m_Conditionals.Count() && m_bSpewPlatforms )
|
|
{
|
|
bool bFirstDefine = false;
|
|
for ( int i = 0; i < m_Conditionals.Count(); i++ )
|
|
{
|
|
if ( m_Conditionals[i].type != CONDITIONAL_PLATFORM )
|
|
continue;
|
|
if ( !bFirstDefine )
|
|
{
|
|
Log_Msg( LOG_VPC, "\n--- PLATFORMS ---\n" );
|
|
bFirstDefine = true;
|
|
}
|
|
Log_Msg( LOG_VPC, "%s%s\n", m_Conditionals[i].upperCaseName.String(), m_Conditionals[i].m_bDefined ? " = 1" : "" );
|
|
}
|
|
}
|
|
|
|
if ( m_Conditionals.Count() && m_bSpewGames )
|
|
{
|
|
bool bFirstGame = false;
|
|
for ( int i = 0; i < m_Conditionals.Count(); i++ )
|
|
{
|
|
if ( m_Conditionals[i].type != CONDITIONAL_GAME )
|
|
continue;
|
|
if ( !bFirstGame )
|
|
{
|
|
Log_Msg( LOG_VPC, "\n--- GAMES ---\n" );
|
|
bFirstGame = true;
|
|
}
|
|
Log_Msg( LOG_VPC, "%s%s\n", m_Conditionals[i].upperCaseName.String(), m_Conditionals[i].m_bDefined ? " = 1" : "" );
|
|
}
|
|
}
|
|
|
|
if ( m_Projects.Count() && m_bSpewProjects )
|
|
{
|
|
// spew all sorted projects
|
|
Log_Msg( LOG_VPC, "\n--- PROJECTS ---\n" );
|
|
CUtlRBTree< const char * > sorted( 0, 0, CaselessStringLessThan );
|
|
for ( int i = 0; i < m_Projects.Count(); i++ )
|
|
{
|
|
sorted.Insert( m_Projects[i].name.String() );
|
|
}
|
|
for ( int i = sorted.FirstInorder(); i != sorted.InvalidIndex(); i = sorted.NextInorder( i ) )
|
|
{
|
|
Log_Msg( LOG_VPC, "[+/-] %s\n", sorted[i] );
|
|
}
|
|
}
|
|
|
|
if ( g_pVPC->m_GroupTags.Count() && m_bSpewGroups )
|
|
{
|
|
// spew all sorted groups
|
|
Log_Msg( LOG_VPC, "\n--- GROUPS ---\n" );
|
|
CUtlRBTree< const char * > sorted( 0, 0, CaselessStringLessThan );
|
|
for ( int i = 0; i < g_pVPC->m_GroupTags.Count(); i++ )
|
|
{
|
|
if ( !g_pVPC->m_GroupTags[i].bSameAsProject )
|
|
{
|
|
sorted.Insert( g_pVPC->m_GroupTags[i].name.String() );
|
|
}
|
|
}
|
|
for ( int i = sorted.FirstInorder(); i != sorted.InvalidIndex(); i = sorted.NextInorder( i ) )
|
|
{
|
|
Log_Msg( LOG_VPC, "[+/-] %s\n", sorted[i] );
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
#if defined( _WIN32 )
|
|
if ( m_bSpewProperties )
|
|
{
|
|
for ( int i = 0; i < KEYWORD_MAX; i++ )
|
|
{
|
|
VPC_Config_SpewProperties( (configKeyword_e)i );
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
if ( m_BuildCommands.Count() )
|
|
{
|
|
// spew details about each command
|
|
Log_Msg( LOG_VPC, "\nUser Build Commands:\n" );
|
|
Log_Msg( LOG_VPC, "--------------------\n" );
|
|
for ( int i = 0; i < m_BuildCommands.Count(); i++ )
|
|
{
|
|
Log_Msg( LOG_VPC, "%s\n", m_BuildCommands[i].String() );
|
|
groupTagIndex_t groupTagIndex = VPC_Group_FindOrCreateGroupTag( m_BuildCommands[i].Get()+1, false );
|
|
if ( groupTagIndex == INVALID_INDEX )
|
|
{
|
|
Log_Msg( LOG_VPC, " ??? (Unknown Group)\n" );
|
|
}
|
|
else
|
|
{
|
|
groupTag_t *pGroupTag = &g_pVPC->m_GroupTags[groupTagIndex];
|
|
for (int j=0; j<pGroupTag->groups.Count(); j++ )
|
|
{
|
|
group_t *pGroup = &m_Groups[pGroupTag->groups[j]];
|
|
for ( int k=0; k<pGroup->projects.Count(); k++ )
|
|
{
|
|
Log_Msg( LOG_VPC, " %s\n", m_Projects[pGroup->projects[k]].name.String() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Log_Msg( LOG_VPC, "\nTarget Projects:\n" );
|
|
Log_Msg( LOG_VPC, "----------------\n" );
|
|
if ( m_TargetProjects.Count() )
|
|
{
|
|
for ( int i=0; i<m_TargetProjects.Count(); i++ )
|
|
{
|
|
Log_Msg( LOG_VPC, "%s\n", m_Projects[m_TargetProjects[i]].name.String() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log_Msg( LOG_VPC, "Empty Set (no output)\n" );
|
|
}
|
|
|
|
Log_Msg( LOG_VPC, "\nTarget Games:\n" );
|
|
Log_Msg( LOG_VPC, "-------------\n" );
|
|
bool bHasDefine = false;
|
|
for ( int i=0; i<m_Conditionals.Count(); i++ )
|
|
{
|
|
if ( m_Conditionals[i].type != CONDITIONAL_GAME )
|
|
continue;
|
|
if ( m_Conditionals[i].m_bDefined )
|
|
{
|
|
Log_Msg( LOG_VPC, "$%s = 1\n", m_Conditionals[i].upperCaseName.String() );
|
|
bHasDefine = true;
|
|
}
|
|
}
|
|
if ( !bHasDefine )
|
|
{
|
|
Log_Msg( LOG_VPC, "No Game Set!\n" );
|
|
}
|
|
|
|
Log_Msg( LOG_VPC, "\nTarget Platforms:\n" );
|
|
Log_Msg( LOG_VPC, "-----------------\n" );
|
|
bHasDefine = false;
|
|
for ( int i=0; i<m_Conditionals.Count(); i++ )
|
|
{
|
|
if ( m_Conditionals[i].type != CONDITIONAL_PLATFORM )
|
|
continue;
|
|
if ( m_Conditionals[i].m_bDefined )
|
|
{
|
|
Log_Msg( LOG_VPC, "$%s = 1\n", m_Conditionals[i].upperCaseName.String() );
|
|
bHasDefine = true;
|
|
}
|
|
}
|
|
if ( !bHasDefine )
|
|
{
|
|
Log_Msg( LOG_VPC, "No Platform Set!\n" );
|
|
}
|
|
|
|
Log_Msg( LOG_VPC, "\nCustom Conditionals:\n" );
|
|
Log_Msg( LOG_VPC, "---------------------\n" );
|
|
bHasDefine = false;
|
|
for ( int i=0; i<m_Conditionals.Count(); i++ )
|
|
{
|
|
if ( m_Conditionals[i].type != CONDITIONAL_CUSTOM )
|
|
continue;
|
|
if ( m_Conditionals[i].m_bDefined )
|
|
{
|
|
Log_Msg( LOG_VPC, "$%s = 1\n", m_Conditionals[i].upperCaseName.String() );
|
|
bHasDefine = true;
|
|
}
|
|
}
|
|
if ( !bHasDefine )
|
|
{
|
|
Log_Msg( LOG_VPC, "No Custom Defines Set!\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::HandleSingleCommandLineArg( const char *pArg )
|
|
{
|
|
if ( ( pArg[0] == '-' ) || ( pArg[0] == '/' ) )
|
|
{
|
|
// skip past arg prefix
|
|
const char *pArgName = pArg+1;
|
|
|
|
// check options
|
|
if ( !V_stricmp( pArgName, "h" ) || !V_stricmp( pArgName, "?" ) || !V_stricmp( pArgName, "help" ) )
|
|
{
|
|
m_bHelp = true;
|
|
m_bUsageOnly = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "v" ) || !V_stricmp( pArgName, "verbose" ) )
|
|
{
|
|
m_bVerbose = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "testmode" ) || !V_stricmp( pArgName, "test" ) )
|
|
{
|
|
m_bTestMode = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "f" ) || !V_stricmp( pArgName, "force" ) )
|
|
{
|
|
m_bForceGenerate = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "novpcgame" ) )
|
|
{
|
|
m_bEnableVpcGameMacro = false;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "checkfiles" ) )
|
|
{
|
|
m_bCheckFiles = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "nocheckfiles" ) )
|
|
{
|
|
m_bCheckFiles = false;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "showcaseissues" ) || !V_stricmp( pArgName, "showcase" ) )
|
|
{
|
|
m_bShowCaseIssues = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "dp" ) )
|
|
{
|
|
m_bDecorateProject = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "dedicated" ) )
|
|
{
|
|
m_bDedicatedBuild = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "platforms" ) || !V_stricmp( pArgName, "plats" ) )
|
|
{
|
|
m_bSpewPlatforms = true;
|
|
m_bUsageOnly = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "games" ) )
|
|
{
|
|
m_bSpewGames = true;
|
|
m_bUsageOnly = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "projects" ) )
|
|
{
|
|
m_bSpewProjects = true;
|
|
m_bUsageOnly = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "groups" ) )
|
|
{
|
|
m_bSpewGroups = true;
|
|
m_bUsageOnly = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "properties" ) )
|
|
{
|
|
m_bSpewProperties = true;
|
|
m_bUsageOnly = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "allgames" ) )
|
|
{
|
|
// shortcut for all games defined
|
|
for ( int j=0; j<m_Conditionals.Count(); j++ )
|
|
{
|
|
if ( m_Conditionals[j].type == CONDITIONAL_GAME )
|
|
{
|
|
m_Conditionals[j].m_bDefined = true;
|
|
}
|
|
}
|
|
}
|
|
else if ( !V_stricmp( pArgName, "showdeps" ) )
|
|
{
|
|
m_bShowDeps = true;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "nop4add" ) )
|
|
{
|
|
m_bP4AutoAdd = false;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "2005" ) )
|
|
{
|
|
m_bWants2010 = false;
|
|
m_bWants2012 = false;
|
|
m_bWants2013 = false;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "2010" ) )
|
|
{
|
|
m_bWants2010 = true;
|
|
m_bWants2012 = false;
|
|
m_bWants2013 = false;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "2012" ) )
|
|
{
|
|
m_bWants2010 = false;
|
|
m_bWants2012 = true;
|
|
m_bWants2013 = false;
|
|
}
|
|
else if ( !V_stricmp( pArgName, "2013" ) )
|
|
{
|
|
m_bWants2010 = false;
|
|
m_bWants2012 = false;
|
|
m_bWants2013 = true;
|
|
}
|
|
else if ( char const *szActualDefineName = StringAfterPrefix( pArgName, "define:" ) )
|
|
{
|
|
// allow setting custom defines straight from command line
|
|
conditional_t *pConditional = FindOrCreateConditional( szActualDefineName, true, CONDITIONAL_CUSTOM );
|
|
if ( pConditional )
|
|
{
|
|
pConditional->m_bDefined = true;
|
|
|
|
m_ExtraOptionsCRCString += "/define:"; // force this into additional CRC string
|
|
m_ExtraOptionsCRCString += pConditional->name.Get(); // force this into additional CRC string
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// not a recogined option, try conditionals
|
|
// find in list of conditionals
|
|
conditional_t *pConditional = FindOrCreateConditional( pArgName, false, CONDITIONAL_NULL );
|
|
if ( !pConditional )
|
|
{
|
|
// not a recognized conditional, add to build commands
|
|
int index = m_BuildCommands.AddToTail();
|
|
m_BuildCommands[index] = pArg;
|
|
}
|
|
else
|
|
{
|
|
// found conditional, mark as defined
|
|
pConditional->m_bDefined = true;
|
|
}
|
|
}
|
|
}
|
|
else if ( pArg[0] == '+' || pArg[0] == '*' || pArg[0] == '@' )
|
|
{
|
|
// add to build commands
|
|
int index = m_BuildCommands.AddToTail();
|
|
m_BuildCommands[index] = pArg;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::ParseBuildOptions( int argc, char *argv[] )
|
|
{
|
|
#if defined( LINUX )
|
|
m_bDedicatedBuild = true;
|
|
#else
|
|
m_bDedicatedBuild = false;
|
|
#endif
|
|
|
|
// parse options
|
|
// prefer +??? or -??? prefix syntax for groups and /??? for options because less confusing for new vpc users
|
|
// for ease we will support -??? prefix syntax for matched options as well
|
|
for ( int i = 1; i < argc; i++ )
|
|
{
|
|
const char *pArg = argv[i];
|
|
|
|
if ( !V_stricmp( pArg, "/mksln" ) )
|
|
{
|
|
if ( !m_P4SolutionFilename.IsEmpty() )
|
|
{
|
|
VPCError( "Can't use /mksln with /p4sln." );
|
|
}
|
|
|
|
if ( (i+1) >= argc )
|
|
{
|
|
VPCError( "/mksln requires a filename after it." );
|
|
}
|
|
|
|
// If the next parameter is a standard + or - or / or * parameter, then we take that to be the name of the solution file.
|
|
// So vpc /mksln +engine would generate engine.sln.
|
|
if ( argv[i+1][0] == '+' || argv[i+1][0] == '-' || argv[i+1][0] == '/' || argv[i+1][0] == '*' || argv[i+1][0] == '@' )
|
|
{
|
|
m_MKSolutionFilename = &argv[i+1][1];
|
|
}
|
|
else
|
|
{
|
|
m_MKSolutionFilename = argv[i+1];
|
|
++i;
|
|
}
|
|
}
|
|
else if ( !V_stricmp( pArg, "/p4sln" ) )
|
|
{
|
|
if ( !m_MKSolutionFilename.IsEmpty() )
|
|
{
|
|
VPCError( "Can't use /mksln with /p4sln." );
|
|
}
|
|
|
|
// Get the solution filename.
|
|
++i;
|
|
if ( i >= argc || argv[i][0] == '+' || argv[i][0] == '-' || argv[i][0] == '/' || argv[i][0] == '*' || argv[i][0] == '@' )
|
|
{
|
|
VPCError( "/p4sln <solution filename> <changelist number>." );
|
|
}
|
|
|
|
m_P4SolutionFilename = argv[i];
|
|
|
|
// Get the changelist number.
|
|
while ( 1 )
|
|
{
|
|
++i;
|
|
|
|
// No more args?
|
|
if ( i >= argc )
|
|
break;
|
|
|
|
// Special syntax for including all changelists.
|
|
if ( V_stricmp( argv[i], "all" ) == 0 )
|
|
{
|
|
m_iP4Changelists.AddToTail( -1 );
|
|
continue;
|
|
}
|
|
|
|
// Special syntax for including default changelists.
|
|
if ( V_stricmp( argv[i], "default" ) == 0 )
|
|
{
|
|
m_iP4Changelists.AddToTail( 0 );
|
|
continue;
|
|
}
|
|
|
|
// This arg isn't a changelist number?
|
|
if ( argv[i][0] < '0' || argv[i][0] > '9' )
|
|
{
|
|
--i;
|
|
break;
|
|
}
|
|
|
|
// Add the changelist number.
|
|
m_iP4Changelists.AddToTail( atoi( argv[i] ) );
|
|
}
|
|
|
|
// Make sure at least one changelist number was specified.
|
|
if ( m_iP4Changelists.Count() == 0 )
|
|
{
|
|
VPCError( "/p4sln <solution filename> <changelist number> [additional changelist numbers]." );
|
|
}
|
|
}
|
|
else if ( !V_stricmp( pArg, "/slnitems" ) )
|
|
{
|
|
// Get the solution items filename
|
|
++i;
|
|
if ( i >= argc || argv[i][0] == '+' || argv[i][0] == '-' || argv[i][0] == '/' || argv[i][0] == '*' || argv[i][0] == '@' )
|
|
{
|
|
VPCError( "/slnitems <solution items filename>." );
|
|
}
|
|
|
|
m_SolutionItemsFilename = argv[i];
|
|
}
|
|
else
|
|
{
|
|
HandleSingleCommandLineArg( pArg );
|
|
}
|
|
}
|
|
|
|
// If they did /p4sln but didn't specify any build commands, then have it check everything.
|
|
if ( m_iP4Changelists.Count() > 0 && m_BuildCommands.Count() == 0 )
|
|
{
|
|
m_bP4SlnCheckEverything = true;
|
|
}
|
|
|
|
CheckForInstalledXDK();
|
|
CheckForInstalledPS3SDK();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Generate a string supplemental to CRC data, derived from command-line options,
|
|
// so varying certain command-line options can cause .VCPROJ rebuilds.
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::GenerateOptionsCRCString()
|
|
{
|
|
m_SupplementalCRCString = "_";
|
|
|
|
conditional_t *pConditional = FindOrCreateConditional( "PROFILE", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Pr";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "RETAIL", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Rt";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "CALLCAP", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Cc";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "FASTCAP", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Fc";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "CERT", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Ct";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "MEMTEST", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Mt";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "NOFPO", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Nf";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "LV", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Lv";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "DEMO", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Dm";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "NO_STEAM", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Ns";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "QTDEBUG", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Qt";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "NO_CEG", false, CONDITIONAL_NULL );
|
|
//
|
|
// !!NEVER INTEGRATE THIS CHANGE TO NON-RELEASE BRANCHES!!
|
|
// !!THIS WILL ENABLE CEG AND BREAK NON-REL BRANCHES!!
|
|
// -AaronN
|
|
//
|
|
//if ( pConditional && pConditional->m_bDefined )
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Nc";
|
|
}
|
|
|
|
pConditional = FindOrCreateConditional( "UPLOAD_CEG", false, CONDITIONAL_NULL );
|
|
if ( pConditional && pConditional->m_bDefined )
|
|
{
|
|
m_SupplementalCRCString += "Uc";
|
|
}
|
|
|
|
if ( !m_ExtraOptionsCRCString.IsEmpty() )
|
|
{
|
|
m_SupplementalCRCString += CFmtStr( "_%s_", m_ExtraOptionsCRCString.Get() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Restart self from correct location and re-run. Returns FALSE if not applicable,
|
|
// otherwise TRUE if restart occurred.
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::RestartFromCorrectLocation( bool *pIsChild )
|
|
{
|
|
#if defined( POSIX )
|
|
return false;
|
|
#else
|
|
// recursive restart guard
|
|
// restart is a hidden internal param, always the last argument
|
|
// presence identifies spawned process
|
|
bool bIsRestart = false;
|
|
if ( !V_stricmp( m_ppArgv[m_nArgc-1], "/restart" ) )
|
|
{
|
|
bIsRestart = true;
|
|
}
|
|
*pIsChild = bIsRestart;
|
|
|
|
char szBinPath[MAX_PATH];
|
|
if ( !CheckBinPath( szBinPath, sizeof( szBinPath ) ) )
|
|
{
|
|
if ( bIsRestart )
|
|
{
|
|
VPCError( "Cyclical Restart: Tell A Programmer!, Aborting." );
|
|
}
|
|
|
|
// replicate arguments, add -restart as a recursion guard for the new process
|
|
char *newArgs[128];
|
|
if ( m_nArgc >= Q_ARRAYSIZE( newArgs ) - 2 )
|
|
{
|
|
VPCError( "Excessive Arguments: Tell A Programmer!, Aborting." );
|
|
}
|
|
int i;
|
|
for ( i = 0; i < m_nArgc; i++ )
|
|
{
|
|
newArgs[i] = m_ppArgv[i];
|
|
}
|
|
newArgs[i++] = "/restart";
|
|
newArgs[i++] = NULL;
|
|
|
|
// restart using synchronous semantic, async semantic causes wierd hang
|
|
int status = _spawnv( _P_WAIT, szBinPath, newArgs );
|
|
if ( !status )
|
|
{
|
|
// called process exited normally
|
|
return true;
|
|
}
|
|
else if ( status > 0 )
|
|
{
|
|
// called process exited with error, pass it along
|
|
exit( status );
|
|
}
|
|
|
|
// called process could not be started
|
|
VPCError( "Restart of '%s' failed\n", szBinPath );
|
|
}
|
|
|
|
// process is running from correct location
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::CheckForInstalledXDK()
|
|
{
|
|
#ifndef POSIX
|
|
|
|
// quick and dirty early check for 360 XDK ability
|
|
// can only detect simplistic condition, VPC can't validate a perfect XDK/MSDEV installation
|
|
bool bHasXDK = false;
|
|
const char *pXDK = getenv( "XEDK" );
|
|
if ( pXDK && pXDK[0] )
|
|
{
|
|
// look for expected compiler
|
|
char fullPath[MAX_PATH];
|
|
Q_strncpy( fullPath, pXDK, sizeof( fullPath ) );
|
|
V_AppendSlash( fullPath, sizeof( fullPath ) );
|
|
V_strncat( fullPath, "bin\\win32\\cl.exe", sizeof( fullPath ) );
|
|
int fileSize = Sys_FileLength( fullPath, false );
|
|
if ( fileSize > 0 )
|
|
{
|
|
bHasXDK = true;
|
|
m_bXDKPresent = true;
|
|
}
|
|
}
|
|
if ( !bHasXDK && IsPlatformDefined( "X360" ) )
|
|
{
|
|
VPCError( "Cannot Build For Xbox 360, XDK is missing or damaged. Remove /x360 from command line." );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::CheckForInstalledPS3SDK()
|
|
{
|
|
#ifndef POSIX
|
|
|
|
// quick and dirty early check for 360 XDK ability
|
|
// can only detect simplistic condition, VPC can't validate a perfect XDK/MSDEV installation
|
|
bool bHasSDK = false;
|
|
const char *pSDK = getenv( "SN_PS3_PATH" );
|
|
if ( pSDK && pSDK[0] )
|
|
{
|
|
// Check for presence of 'src/ps3sdk'
|
|
char ps3SDKDir[MAX_PATH];
|
|
|
|
V_GetCurrentDirectory( ps3SDKDir, sizeof( ps3SDKDir ) );
|
|
V_snprintf( ps3SDKDir, sizeof( ps3SDKDir ), "%s%s", ps3SDKDir, "\\ps3sdk\\cell\\target\\common\\include\\sdk_version.h" );
|
|
if ( Sys_FileLength( ps3SDKDir ) > 0 )
|
|
{
|
|
bHasSDK = true;
|
|
m_bPS3SDKPresent = true;
|
|
}
|
|
}
|
|
|
|
if ( !bHasSDK && IsPlatformDefined( "PS3" ) )
|
|
{
|
|
VPCError( "Cannot Build For PS3, SDK is missing or damaged. Remove /ps3 from command line." );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
void CVPC::CreateOutputFilename( project_t *pProject, const char *pchPlatform, const char *pGameName, const char *pchExtension )
|
|
{
|
|
const char *pProjectFileNamePrefix = m_bTestMode ? "test" : pProject->name.String();
|
|
|
|
m_OutputFilename = pProjectFileNamePrefix;
|
|
|
|
if ( pchPlatform && pchPlatform[0] )
|
|
{
|
|
// non-pc platforms get decorated
|
|
m_OutputFilename += "_";
|
|
m_OutputFilename += pchPlatform;
|
|
}
|
|
|
|
if ( pGameName && pGameName[0] )
|
|
{
|
|
// game projects get decorated
|
|
m_OutputFilename += "_";
|
|
m_OutputFilename += pGameName;
|
|
}
|
|
|
|
if ( pchExtension && pchExtension[0] )
|
|
{
|
|
m_OutputFilename += ".";
|
|
m_OutputFilename += pchExtension;
|
|
}
|
|
}
|
|
|
|
bool CVPC::BuildTargetProject( IProjectIterator *pIterator, projectIndex_t projectIndex, script_t *pProjectScript, const char *pGameName )
|
|
{
|
|
// evaluate the project's script conditional which determines game/platform
|
|
if ( !EvaluateConditionalExpression( pProjectScript->m_condition.String() ) )
|
|
{
|
|
// conditionals prevent this project from consideration
|
|
return false;
|
|
}
|
|
|
|
// set once anything is expected to output
|
|
m_bAnyProjectQualified = true;
|
|
|
|
if ( !m_Projects.IsValidIndex( projectIndex ) )
|
|
{
|
|
// unexpected bad project index
|
|
Assert( 0 );
|
|
return false;
|
|
}
|
|
project_t *pProject = &m_Projects[projectIndex];
|
|
|
|
// track the internal project name, unaffected by user name mangling
|
|
m_ProjectName = pProject->name.String();
|
|
m_LoadAddressName = pProject->name.String();
|
|
|
|
// win32 projects are the most prevalent, so by popular demand they have no decoration
|
|
// all other platforms use their platform name as a suffix
|
|
const char *pPlatformName = NULL;
|
|
if ( !IsPlatformDefined( "win32" ) )
|
|
{
|
|
pPlatformName = GetTargetPlatformName();
|
|
}
|
|
|
|
// create a decorated project filename based on project/game/platform/etc
|
|
CreateOutputFilename(
|
|
pProject,
|
|
pPlatformName,
|
|
pGameName,
|
|
g_pVPC->GetProjectGenerator()->GetProjectFileExtension() );
|
|
|
|
// each vpc script is written with paths relative to their base
|
|
// force each script needs to start relative to their script location
|
|
// this allows vpc to be invoked anywhere, but the groups resolve their projects correctly
|
|
char szScriptPath[MAX_PATH];
|
|
V_ComposeFileName( g_pVPC->GetStartDirectory(), pProjectScript->name.String(), szScriptPath, sizeof( szScriptPath ) );
|
|
V_StripFilename( szScriptPath );
|
|
V_SetCurrentDirectory( szScriptPath );
|
|
|
|
// build it
|
|
char szScriptName[MAX_PATH];
|
|
Sys_StripPath( pProjectScript->name.String(), szScriptName );
|
|
return pIterator->VisitProject( projectIndex, szScriptName );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Iterate and build each of the projects. Game projects can themselves be
|
|
// auto-iterated to apply each of their mod variant.
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::IterateTargetProjects( CUtlVector<projectIndex_t> &projectList, IProjectIterator *pIterator )
|
|
{
|
|
m_bGeneratedProject = false;
|
|
m_bAnyProjectQualified = false;
|
|
|
|
if ( !projectList.Count() )
|
|
{
|
|
// nothing to do
|
|
return;
|
|
}
|
|
|
|
for ( int nProject = 0; nProject < projectList.Count(); nProject++ )
|
|
{
|
|
project_t *pProject = &m_Projects[projectList[nProject]];
|
|
|
|
// each project can have 1 or more scripts that are predicated by game/platform conditionals (i.e. client or server)
|
|
for ( int nScript = 0; nScript < pProject->scripts.Count(); nScript++ )
|
|
{
|
|
script_t *pProjectScript = &pProject->scripts[nScript];
|
|
|
|
// occurrence of game condition(s) dictates iteration behavior
|
|
// client/server would have multiple game conditions
|
|
bool bHasGameCondition = g_pVPC->ConditionHasDefinedType( pProjectScript->m_condition.String(), CONDITIONAL_GAME );
|
|
|
|
if ( !bHasGameCondition )
|
|
{
|
|
// no game condition
|
|
BuildTargetProject( pIterator, projectList[nProject], pProjectScript, NULL );
|
|
}
|
|
else
|
|
{
|
|
// auto iterate through all defined game conditionals, setting each in turn
|
|
// this provides for building say client for all mod(s) that it can support
|
|
for ( int nTargetGame = 0; nTargetGame < m_Conditionals.Count(); nTargetGame++ )
|
|
{
|
|
if ( m_Conditionals[nTargetGame].type != CONDITIONAL_GAME || !m_Conditionals[nTargetGame].m_bDefined )
|
|
{
|
|
// the game conditions must be defined to be considered
|
|
// i.e. the user has specified to build /hl2 /tf2, but not /portal
|
|
continue;
|
|
}
|
|
|
|
// only one game condition is active during project generation
|
|
for ( int k = 0; k < m_Conditionals.Count(); k++ )
|
|
{
|
|
// unmark all game conditionals
|
|
if ( m_Conditionals[k].type == CONDITIONAL_GAME )
|
|
{
|
|
m_Conditionals[k].m_bGameConditionActive = false;
|
|
}
|
|
}
|
|
m_Conditionals[nTargetGame].m_bGameConditionActive = true;
|
|
|
|
BuildTargetProject( pIterator, projectList[nProject], pProjectScript, m_Conditionals[nTargetGame].name.String() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Build all the projects in m_targetProjects.
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::BuildTargetProjects()
|
|
{
|
|
class CDefaultProjectIterator : public IProjectIterator
|
|
{
|
|
public:
|
|
virtual bool VisitProject( projectIndex_t iProject, const char *pScriptPath )
|
|
{
|
|
Log_Msg( LOG_VPC, "\n" );
|
|
|
|
// check project's crc signature
|
|
if ( !g_pVPC->IsForceGenerate() && !g_pVPC->IsForceIterate() && g_pVPC->IsProjectCurrent( g_pVPC->GetOutputFilename() ) )
|
|
{
|
|
// valid, does not need to build
|
|
return false;
|
|
}
|
|
|
|
return g_pVPC->ParseProjectScript( pScriptPath, 0, false, true );
|
|
}
|
|
};
|
|
|
|
if ( !m_TargetProjects.Count() )
|
|
{
|
|
VPCError( "No recognized project(s) to build. Use /h or /projects or /groups to spew more info." );
|
|
}
|
|
|
|
CDefaultProjectIterator iterator;
|
|
IterateTargetProjects( m_TargetProjects, &iterator );
|
|
|
|
// Catch user attention to notify lack of any expected output
|
|
// Novice users would not be aware of expected conditionals
|
|
if ( !m_bGeneratedProject && !m_bAnyProjectQualified )
|
|
{
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "\n" );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "----------------------------\n" );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "!!! No Project Generated !!!\n" );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "----------------------------\n" );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "\n" );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "Possibly missing game, platform, or other conditional expected by script.\n" );
|
|
Log_Warning( LOG_VPC, Color( 255, 255, 0, 255 ), "Use /h verify desired target build set.\n" );
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Find the project that corresponds to the specified vcproj and setup
|
|
// to build that project.
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::FindProjectFromVCPROJ( const char *pScriptNameVCProj )
|
|
{
|
|
// caller is specifying the output vcproj, i.e. via tool shortcut from within MSDEV to re-gen
|
|
// use the vpc standardized output vcproj name to determine re-gen parameters
|
|
// mod and platform will be seperated by '_' after the project name
|
|
// resolve to correct project, best will be longest match, due to project names like foo_? and foo_bar_?
|
|
char szProject[MAX_PATH];
|
|
unsigned int bestLen = 0;
|
|
for ( int i = 0; i < m_Projects.Count(); i++ )
|
|
{
|
|
if ( V_stristr( pScriptNameVCProj, m_Projects[i].name.String() ) )
|
|
{
|
|
if ( bestLen < strlen( m_Projects[i].name.String() ) )
|
|
{
|
|
bestLen = strlen( m_Projects[i].name.String() );
|
|
strcpy( szProject, m_Projects[i].name.String() );
|
|
}
|
|
}
|
|
}
|
|
if ( bestLen == 0 )
|
|
{
|
|
VPCError( "Could not resolve '%s' to any known projects", pScriptNameVCProj );
|
|
}
|
|
|
|
// skip past known project
|
|
char szBuffer[MAX_PATH];
|
|
V_StripExtension( pScriptNameVCProj + strlen( szProject ), szBuffer, sizeof( szBuffer ) );
|
|
|
|
// each token is seperated by '_'
|
|
int numTokens = 0;
|
|
char *pToken = szBuffer;
|
|
char *pStart = pToken;
|
|
char szTokens[2][MAX_PATH];
|
|
while ( numTokens < 2 )
|
|
{
|
|
if ( pStart[0] == '_' )
|
|
{
|
|
pStart++;
|
|
pToken = strchr( pStart, '_' );
|
|
if ( !pToken )
|
|
{
|
|
strcpy( szTokens[numTokens++], pStart );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
strncpy( szTokens[numTokens], pStart, pToken-pStart );
|
|
szTokens[numTokens][pToken-pStart] = '\0';
|
|
numTokens++;
|
|
pStart = pToken;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// re-build a commandline
|
|
int localArgc = 0;
|
|
char *localArgv[16];
|
|
char argBuffers[16][MAX_PATH];
|
|
for ( int i=0; i<Q_ARRAYSIZE( localArgv ); i++ )
|
|
{
|
|
localArgv[i] = argBuffers[i];
|
|
}
|
|
strcpy( localArgv[localArgc++], "vpc.exe" );
|
|
sprintf( localArgv[localArgc++], "+%s", szProject );
|
|
for ( int i=0; i<numTokens; i++ )
|
|
{
|
|
sprintf( localArgv[localArgc++], "/%s", szTokens[i] );
|
|
}
|
|
|
|
ParseBuildOptions( localArgc, localArgv );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This sets up various defines that are funneled into the .vpc script and the #defines in the engine.
|
|
//
|
|
// VPC makes a distinction between defines and macros (defines are just binary on/off things that are used like this:
|
|
// $File "blah.cpp" [$somedefine]
|
|
//
|
|
// macros are used for substitutions like this:
|
|
// $File "blah.$SOMEMACRO"
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::SetMacrosAndConditionals()
|
|
{
|
|
// Find the target platform.
|
|
conditional_t *pPlatformConditional = NULL;
|
|
for ( int i = 0; i < m_Conditionals.Count(); i++ )
|
|
{
|
|
if ( m_Conditionals[i].type == CONDITIONAL_PLATFORM && m_Conditionals[i].m_bDefined )
|
|
{
|
|
pPlatformConditional = &m_Conditionals[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Only one platform is allowed to be defined.
|
|
for ( int i = 0; i < m_Conditionals.Count(); i++ )
|
|
{
|
|
if ( &m_Conditionals[i] != pPlatformConditional && m_Conditionals[i].type == CONDITIONAL_PLATFORM && m_Conditionals[i].m_bDefined )
|
|
{
|
|
// no no no, the user is not allowed to build multiple platforms simultaneously
|
|
// this prior feature really confused/crapped up the code, so absolutely not supporting that
|
|
VPCWarning( "Detected multiple target platforms...Disabling '%s'", m_Conditionals[i].name.String() );
|
|
m_Conditionals[i].m_bDefined = false;
|
|
}
|
|
}
|
|
|
|
if ( !pPlatformConditional )
|
|
{
|
|
// no user specified platform defined, defaults to primary vpc.exe built platform
|
|
#if defined( WIN32 )
|
|
pPlatformConditional = FindOrCreateConditional( "WIN32", false, CONDITIONAL_PLATFORM );
|
|
#elif defined( OSX )
|
|
pPlatformConditional = FindOrCreateConditional( "OSX32", false, CONDITIONAL_PLATFORM );
|
|
#elif defined( LINUX )
|
|
pPlatformConditional = FindOrCreateConditional( "LINUX32", false, CONDITIONAL_PLATFORM );
|
|
#elif defined( CYGWIN )
|
|
pPlatformConditional = FindOrCreateConditional( "CYGWIN", false, CONDITIONAL_PLATFORM );
|
|
#else
|
|
#error "Unsupported platform."
|
|
#endif
|
|
pPlatformConditional->m_bDefined = true;
|
|
}
|
|
|
|
// save off the platform name (rather than the pointer to the conditional, since it can be invalidated)
|
|
CUtlString platformName = pPlatformConditional->name;
|
|
|
|
VPCStatus( true, "Target Platform: %s", platformName.String() );
|
|
|
|
// src_main doesn't want this #define because it conflicts with Python's SDK.
|
|
// It really should be called something else that won't conflict with the rest of the world.
|
|
bool bIncludePlatformDefineInProjects = false;
|
|
#ifdef STEAM
|
|
bIncludePlatformDefineInProjects = true;
|
|
#endif
|
|
SetMacro( "PLATFORM", platformName.String(), bIncludePlatformDefineInProjects );
|
|
|
|
// create reserved $QUOTE - used for embedding quotes, or use msdev's "
|
|
SetMacro( "QUOTE", "\"", false );
|
|
|
|
if ( !V_stricmp( platformName.String(), "WIN32" ) || !V_stricmp( platformName.String(), "WIN64" ) || !V_stricmp( platformName.String(), "X360" ) )
|
|
{
|
|
// VS2010 is strictly win32/xbox360
|
|
// Set the CRC so that compiler changes will always alter the CRC
|
|
if ( m_bWants2013 )
|
|
{
|
|
m_bUse2013 = true;
|
|
m_ExtraOptionsCRCString += "VS2013";
|
|
}
|
|
else if ( m_bWants2012 )
|
|
{
|
|
m_bUse2012 = true;
|
|
m_ExtraOptionsCRCString += "VS2012";
|
|
}
|
|
else if ( m_bWants2010 )
|
|
{
|
|
m_bUse2010 = true;
|
|
m_ExtraOptionsCRCString += "VS2010";
|
|
}
|
|
else
|
|
m_ExtraOptionsCRCString += "VS2005";
|
|
}
|
|
|
|
// For backwards compatibility with /define:vs2012 don't set this to false if m_bUse2012 isn't set.
|
|
if ( m_bUse2013 )
|
|
{
|
|
SetConditional( "VS2013", true );
|
|
m_bUse2010 = true; // Request the 2010 file-format.
|
|
}
|
|
else if (m_bUse2012)
|
|
{
|
|
SetConditional( "VS2012", true );
|
|
m_bUse2010 = true; // Request the 2010 file-format.
|
|
}
|
|
else if ( m_bUse2010 )
|
|
SetConditional( "VS2010", true );
|
|
else
|
|
SetConditional( "VS2005", true );
|
|
|
|
// create and define various other platform related helper conditionals andmacros
|
|
if ( V_stricmp( platformName.String(), "WIN32" ) == 0 || V_stricmp( platformName.String(), "WIN64" ) == 0 )
|
|
{
|
|
SetConditional( "WINDOWS" );
|
|
|
|
SetMacro( "_DLL_EXT", ".dll", true );
|
|
SetMacro( "_IMPLIB_EXT", ".lib", false );
|
|
|
|
SetMacro( "_IMPLIB_PREFIX", "", false );
|
|
SetMacro( "_IMPLIB_DLL_PREFIX", "", false );
|
|
|
|
SetMacro( "_STATICLIB_EXT", ".lib", false );
|
|
SetMacro( "_EXE_EXT", ".exe", false );
|
|
}
|
|
else if ( V_stricmp( platformName.String(), "X360" ) == 0 )
|
|
{
|
|
SetMacro( "_DLL_EXT", "_360.dll", true );
|
|
SetMacro( "_IMPLIB_EXT", "_360.lib", false );
|
|
|
|
SetMacro( "_IMPLIB_PREFIX", "", false );
|
|
SetMacro( "_IMPLIB_DLL_PREFIX", "", false );
|
|
|
|
SetMacro( "_STATICLIB_EXT", "_360.lib", false );
|
|
SetMacro( "_EXE_EXT", ".exe", false );
|
|
}
|
|
else if ( V_stricmp( platformName.String(), "PS3" ) == 0 )
|
|
{
|
|
SetMacro( "_DLL_EXT", "_ps3.sprx", true );
|
|
SetMacro( "_IMPLIB_EXT", "_ps3.lib", false );
|
|
|
|
SetMacro( "_IMPLIB_PREFIX", "", false );
|
|
SetMacro( "_IMPLIB_DLL_PREFIX", "", false );
|
|
|
|
SetMacro( "_STATICLIB_EXT", "_ps3.lib", false );
|
|
SetMacro( "_EXE_EXT", ".self", false );
|
|
}
|
|
else if ( V_stricmp( platformName.String(), "LINUX32" ) == 0 || V_stricmp( platformName.String(), "LINUX64" ) == 0 )
|
|
{
|
|
SetConditional( "LINUXALL" );
|
|
if ( m_bDedicatedBuild )
|
|
{
|
|
SetConditional( "DEDICATED" );
|
|
}
|
|
SetConditional( "POSIX" );
|
|
|
|
SetMacro( "LINUX", "1", true );
|
|
SetMacro( "_LINUX", "1", true );
|
|
SetMacro( "POSIX", "1", true );
|
|
SetMacro( "_POSIX", "1", true );
|
|
|
|
SetMacro( "_DLL_EXT", ".so", true );
|
|
SetMacro( "_IMPLIB_EXT", ".so", false );
|
|
|
|
SetMacro( "_IMPLIB_PREFIX", "lib", false );
|
|
SetMacro( "_IMPLIB_DLL_PREFIX", "lib", false );
|
|
SetMacro( "_STATICLIB_EXT", ".a", false );
|
|
SetMacro( "_EXE_EXT", "", false );
|
|
SetMacro( "_SYM_EXT", ".dbg", false );
|
|
}
|
|
else if ( V_stricmp( platformName.String(), "OSX32" ) == 0 || V_stricmp( platformName.String(), "OSX64" ) == 0 )
|
|
{
|
|
SetConditional( "OSXALL" );
|
|
if ( m_bDedicatedBuild )
|
|
{
|
|
SetConditional( "DEDICATED" );
|
|
}
|
|
SetConditional( "POSIX" );
|
|
SetMacro( "_POSIX", "1", true );
|
|
|
|
SetMacro( "_DLL_EXT", ".dylib", true );
|
|
SetMacro( "_IMPLIB_EXT", ".dylib", false );
|
|
|
|
SetMacro( "_IMPLIB_PREFIX", "lib", false );
|
|
SetMacro( "_IMPLIB_DLL_PREFIX", "lib", false );
|
|
|
|
SetMacro( "_STATICLIB_EXT", ".a", false );
|
|
SetMacro( "_EXE_EXT", "", false );
|
|
SetMacro( "_SYM_EXT", ".dSYM", false );
|
|
}
|
|
else if ( V_stricmp( platformName.String(), "CYGWIN" ) == 0 )
|
|
{
|
|
SetConditional( "CYGWIN" );
|
|
SetConditional( "CYGWIN_WINDOWS_TARGET" );
|
|
SetConditional( "DEDICATED" );
|
|
SetConditional( "POSIX" );
|
|
|
|
SetMacro( "CYGWIN", "1", true );
|
|
SetMacro( "_CYGWIN", "1", true );
|
|
SetMacro( "CYGWIN_WINDOWS_TARGET", "1", true );
|
|
SetMacro( "_CYGWIN_WINDOWS_TARGET", "1", true );
|
|
SetMacro( "POSIX", "1", true );
|
|
SetMacro( "_POSIX", "1", true );
|
|
|
|
SetMacro( "_DLL_EXT", ".dll", true );
|
|
SetMacro( "_IMPLIB_EXT", ".dll.a", false );
|
|
|
|
SetMacro( "_IMPLIB_DLL_PREFIX", "", false );
|
|
SetMacro( "_IMPLIB_PREFIX", "lib", false );
|
|
|
|
SetMacro( "_STATICLIB_EXT", ".a", false );
|
|
SetMacro( "_EXE_EXT", ".exe", false );
|
|
}
|
|
|
|
// Set VPCGAME macro based on target game
|
|
if ( m_bEnableVpcGameMacro )
|
|
{
|
|
int nGameDefineIndex = -1;
|
|
for ( int iOtherGameDefine = 0; iOtherGameDefine < m_Conditionals.Count(); ++ iOtherGameDefine )
|
|
{
|
|
if ( m_Conditionals[iOtherGameDefine].type == CONDITIONAL_GAME &&
|
|
m_Conditionals[iOtherGameDefine].m_bDefined )
|
|
{
|
|
if ( nGameDefineIndex == -1 )
|
|
{
|
|
nGameDefineIndex = iOtherGameDefine;
|
|
}
|
|
else
|
|
{
|
|
// uh-oh, multiple games defined for target build
|
|
// can't set VPCGAME accurately
|
|
nGameDefineIndex = -2;
|
|
}
|
|
}
|
|
}
|
|
|
|
SetMacro( "VPCGAME", ( nGameDefineIndex >= 0 ) ? m_Conditionals[nGameDefineIndex].name.Get() : "valve", true );
|
|
SetMacro( "VPCGAMECAPS", ( nGameDefineIndex >= 0 ) ? m_Conditionals[nGameDefineIndex].upperCaseName.Get() : "VALVE", true );
|
|
|
|
// force this into additional CRC string
|
|
m_ExtraOptionsCRCString += CFmtStr( "/vpcgame:%s", GetMacroValue( "VPCGAME" ) );
|
|
}
|
|
|
|
// Set defines for PS3 and XDK presence
|
|
if ( m_bPS3SDKPresent )
|
|
{
|
|
SetConditional( "PS3SDKINSTALLED" );
|
|
}
|
|
|
|
if ( m_bXDKPresent )
|
|
{
|
|
SetConditional( "XDKINSTALLED" );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Checks for command line /params ( +/- used for projects, so ICommandLine() not suitable)
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::HasCommandLineParameter( const char *pParamName )
|
|
{
|
|
for ( int i=1; i < m_nArgc; i++ )
|
|
{
|
|
if ( V_stricmp( m_ppArgv[i], pParamName ) == 0 )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::HasP4SLNCommand()
|
|
{
|
|
return HasCommandLineParameter( "/p4sln" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CVPC::HandleP4SLN( IBaseSolutionGenerator *pSolutionGenerator )
|
|
{
|
|
#ifdef WIN32
|
|
// If they want to generate a solution based on a Perforce changelist, adjust m_targetProjects and set it up like /mksln had been passed in.
|
|
if ( m_iP4Changelists.Count() == 0 )
|
|
return false;
|
|
|
|
if ( !pSolutionGenerator )
|
|
{
|
|
VPCError( "No solution generator exists for this platform." );
|
|
}
|
|
|
|
// Figure out where to put the solution file.
|
|
char szFullSolutionPath[MAX_PATH];
|
|
if ( V_IsAbsolutePath( m_P4SolutionFilename.Get() ) )
|
|
{
|
|
V_strncpy( szFullSolutionPath, m_P4SolutionFilename.Get(), sizeof( szFullSolutionPath ) );
|
|
}
|
|
else
|
|
{
|
|
V_ComposeFileName( g_pVPC->GetStartDirectory(), m_P4SolutionFilename.Get(), szFullSolutionPath, sizeof( szFullSolutionPath ) );
|
|
}
|
|
|
|
CProjectDependencyGraph dependencyGraph;
|
|
GenerateSolutionForPerforceChangelist( dependencyGraph, m_iP4Changelists, pSolutionGenerator, szFullSolutionPath );
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::HandleMKSLN( IBaseSolutionGenerator *pSolutionGenerator, CProjectDependencyGraph &dependencyGraph )
|
|
{
|
|
if ( m_MKSolutionFilename.IsEmpty() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( !pSolutionGenerator )
|
|
{
|
|
VPCError( "No solution generator exists for this platform." );
|
|
}
|
|
|
|
// Find out what depends on what.
|
|
if ( !dependencyGraph.HasGeneratedDependencies() )
|
|
{
|
|
dependencyGraph.BuildProjectDependencies( 0 );
|
|
}
|
|
|
|
// GenerateBuildSet basically generates what we want, except it uses projectIndex_t's, meaning that
|
|
// we don't know what subset of games we should use until we've called VPC_IterateTargetProjects.
|
|
CUtlVector<CDependency_Project*> referencedProjects;
|
|
dependencyGraph.TranslateProjectIndicesToDependencyProjects( m_TargetProjects, referencedProjects );
|
|
|
|
// Generate a solution file.
|
|
char szFullSolutionPath[MAX_PATH];
|
|
if ( V_IsAbsolutePath( m_MKSolutionFilename.Get() ) )
|
|
{
|
|
V_strncpy( szFullSolutionPath, m_MKSolutionFilename.Get(), sizeof( szFullSolutionPath ) );
|
|
}
|
|
else
|
|
{
|
|
V_ComposeFileName( g_pVPC->GetStartDirectory(), m_MKSolutionFilename.Get(), szFullSolutionPath, sizeof( szFullSolutionPath ) );
|
|
}
|
|
|
|
pSolutionGenerator->GenerateSolutionFile( szFullSolutionPath, referencedProjects );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::SetupGenerators()
|
|
{
|
|
extern IBaseSolutionGenerator *GetSolutionGenerator_Win32();
|
|
extern IBaseProjectGenerator *GetWin32ProjectGenerator();
|
|
extern IBaseProjectGenerator *GetWin32ProjectGenerator_2010();
|
|
extern IBaseProjectGenerator *GetMakefileProjectGenerator();
|
|
extern IBaseProjectGenerator *GetPS3ProjectGenerator();
|
|
extern IBaseProjectGenerator *GetXbox360ProjectGenerator();
|
|
extern IBaseProjectGenerator *GetXbox360ProjectGenerator_2010();
|
|
|
|
#if defined( WIN32 )
|
|
// Under Windows we have the ability to generate makefiles so if they specified a linux config then use the makefile generator.
|
|
bool bUseMakefile = IsPlatformDefined( "LINUX" );
|
|
if ( bUseMakefile )
|
|
{
|
|
Log_Msg( LOG_VPC, "\n** Detected Linux platform. Using Makefile generator.\n" );
|
|
}
|
|
else
|
|
{
|
|
// Still use makefiles if they're building the (non-SRCDS) dedicated server.
|
|
conditional_t *pConditional = FindOrCreateConditional( "DEDICATED", false, CONDITIONAL_CUSTOM );
|
|
bUseMakefile = ( pConditional && pConditional->m_bDefined );
|
|
}
|
|
|
|
if ( bUseMakefile )
|
|
{
|
|
m_pProjectGenerator = GetMakefileProjectGenerator();
|
|
m_pSolutionGenerator = &g_PosixSolutionGenerator;
|
|
}
|
|
else
|
|
{
|
|
if ( IsPlatformDefined( "PS3" ) )
|
|
{
|
|
m_pProjectGenerator = GetPS3ProjectGenerator();
|
|
m_pSolutionGenerator = GetSolutionGenerator_Win32();
|
|
}
|
|
else if ( IsPlatformDefined( "X360" ) )
|
|
{
|
|
if ( m_bUse2010 )
|
|
{
|
|
Log_Msg( LOG_VPC, Color( 0, 255, 255, 255 ), "Generating for Visual Studio 2010.\n" );
|
|
m_pProjectGenerator = GetXbox360ProjectGenerator_2010();
|
|
}
|
|
else
|
|
{
|
|
m_pProjectGenerator = GetXbox360ProjectGenerator();
|
|
}
|
|
m_pSolutionGenerator = GetSolutionGenerator_Win32();
|
|
}
|
|
else
|
|
{
|
|
if ( m_bUse2013 )
|
|
{
|
|
Log_Msg( LOG_VPC, Color( 0, 255, 255, 255 ), "Generating for Visual Studio 2013.\n" );
|
|
m_pProjectGenerator = GetWin32ProjectGenerator_2010();
|
|
}
|
|
else if ( m_bUse2012 )
|
|
{
|
|
Log_Msg( LOG_VPC, Color( 0, 255, 255, 255 ), "Generating for Visual Studio 2012.\n" );
|
|
m_pProjectGenerator = GetWin32ProjectGenerator_2010();
|
|
}
|
|
else if ( m_bUse2010 )
|
|
{
|
|
Log_Msg( LOG_VPC, Color( 0, 255, 255, 255 ), "Generating for Visual Studio 2010.\n" );
|
|
m_pProjectGenerator = GetWin32ProjectGenerator_2010();
|
|
}
|
|
else
|
|
{
|
|
m_pProjectGenerator = GetWin32ProjectGenerator();
|
|
}
|
|
m_pSolutionGenerator = GetSolutionGenerator_Win32();
|
|
}
|
|
}
|
|
#else
|
|
// Linux always uses the makefile project generator.
|
|
m_pProjectGenerator = GetMakefileProjectGenerator();
|
|
m_pSolutionGenerator = &g_PosixSolutionGenerator;
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Since Steam's VPC builds tier0 and vstdlib directly in, Steam uses vpc.exe as the CRC checker.
|
|
// Source uses vpccrccheck.exe to do this.
|
|
//-----------------------------------------------------------------------------
|
|
void CVPC::InProcessCRCCheck()
|
|
{
|
|
for ( int i = 1; i<m_nArgc; i++ )
|
|
{
|
|
if ( !V_stricmp( m_ppArgv[i], "-crc" ) || !V_stricmp( m_ppArgv[i], "-crc2" ) )
|
|
{
|
|
// caller wants the crc check only
|
|
int ret = VPC_CommandLineCRCChecks( m_nArgc, m_ppArgv );
|
|
exit( ret );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
const char *CVPC::BuildTempGroupScript( const char *pVPCScriptName )
|
|
{
|
|
char projectName[MAX_PATH];
|
|
V_StripExtension( pVPCScriptName, projectName, sizeof( projectName ) );
|
|
|
|
char szCurrentDirectory[MAX_PATH];
|
|
V_GetCurrentDirectory( szCurrentDirectory, sizeof( szCurrentDirectory ) );
|
|
|
|
// caller is specifying an explicit VPC, i.e. not a project from the default group
|
|
// create a temporary group file that mimics a VGC, that points to the current dir's VPC
|
|
char *pTmpName = tmpnam( NULL );
|
|
if ( !pTmpName || !pTmpName[0] )
|
|
{
|
|
VPCError( "Could not generate temp name. Tell a Programmer.\n" );
|
|
}
|
|
if ( pTmpName[0] == '\\' )
|
|
{
|
|
pTmpName++;
|
|
}
|
|
|
|
char tempGroupScriptFilename[MAX_PATH];
|
|
V_ComposeFileName( szCurrentDirectory, CFmtStr( "%svgc.tmp", pTmpName ), tempGroupScriptFilename, sizeof( tempGroupScriptFilename ) );
|
|
m_TempGroupScriptFilename = tempGroupScriptFilename;
|
|
|
|
// build the temp group script
|
|
FILE *fp = fopen( m_TempGroupScriptFilename.Get(), "w+t" );
|
|
if ( !fp )
|
|
{
|
|
VPCError( "Could not open temp file '%s'. Tell a Programmer.\n", m_TempGroupScriptFilename.Get() );
|
|
}
|
|
|
|
char vpcScriptFilename[MAX_PATH];
|
|
V_ComposeFileName( szCurrentDirectory, pVPCScriptName, vpcScriptFilename, sizeof( vpcScriptFilename ) );
|
|
|
|
// the actual vpc must be relative to the source path
|
|
const char *pVPCFilename = StringAfterPrefix( vpcScriptFilename, m_SourcePath.Get() );
|
|
if ( !pVPCFilename )
|
|
{
|
|
VPCError( "Script %s is not in source path %s\n", vpcScriptFilename, m_SourcePath.Get() );
|
|
}
|
|
|
|
if ( pVPCFilename[0] == '\\' )
|
|
{
|
|
pVPCFilename++;
|
|
}
|
|
|
|
fprintf( fp, "$Project \"%s\"\n", projectName );
|
|
fprintf( fp, "{\n" );
|
|
fprintf( fp, "\"%s\"\n", pVPCFilename );
|
|
fprintf( fp, "}\n" );
|
|
fclose( fp );
|
|
|
|
// fake a build command
|
|
char buildCommand[MAX_PATH];
|
|
V_snprintf( buildCommand, sizeof( buildCommand ), "+%s", projectName );
|
|
int index = m_BuildCommands.AddToTail();
|
|
m_BuildCommands[index] = buildCommand;
|
|
|
|
return m_TempGroupScriptFilename.Get();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CVPC::ProcessCommandLine()
|
|
{
|
|
SetupDefaultConditionals();
|
|
|
|
DetermineSourcePath();
|
|
|
|
// possible extensions determine operation mode beyond expected normal user case
|
|
bool bScriptIsVGC = false;
|
|
bool bScriptIsVPC = false;
|
|
bool bScriptIsVCProj = false;
|
|
bool bHasBuildCommand = false;
|
|
const char *pScriptName = NULL;
|
|
const char *pScriptNameVCProj = NULL;
|
|
|
|
for ( int i = 1; i < m_nArgc; i++ )
|
|
{
|
|
const char *pArg = m_ppArgv[i];
|
|
if ( V_stristr( pArg, ".vgc" ) )
|
|
{
|
|
// caller explicitly providing group
|
|
pScriptName = pArg;
|
|
bScriptIsVGC = true;
|
|
bHasBuildCommand = true;
|
|
break;
|
|
}
|
|
else if ( V_stristr( pArg, ".vpc" ) )
|
|
{
|
|
// caller is using a local vpc, i.e. one that is not hooked into the groups
|
|
pScriptName = pArg;
|
|
bScriptIsVPC = true;
|
|
bHasBuildCommand = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( V_stristr( pArg, ".vcproj" ) || V_stristr( pArg, ".vcxproj" ) )
|
|
{
|
|
// caller wants to re-gen the vcproj, this is commonly used by MSDEV to re-gen
|
|
pScriptNameVCProj = pArg;
|
|
bScriptIsVCProj = true;
|
|
bHasBuildCommand = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int i = 1; i < m_nArgc; i++ )
|
|
{
|
|
if ( m_ppArgv[i][0] == '-' || m_ppArgv[i][0] == '+' || m_ppArgv[i][0] == '*' || m_ppArgv[i][0] == '@' )
|
|
{
|
|
bHasBuildCommand = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bScriptIsVPC )
|
|
{
|
|
pScriptName = BuildTempGroupScript( pScriptName );
|
|
bScriptIsVPC = false;
|
|
bScriptIsVGC = true;
|
|
}
|
|
|
|
if ( !bScriptIsVGC )
|
|
{
|
|
// no script, use default group
|
|
pScriptName = "vpc_scripts\\default.vgc";
|
|
bScriptIsVGC = true;
|
|
}
|
|
|
|
// set the current directory, it is to be expected src, i.e. .\vpc_scripts\..
|
|
SetDefaultSourcePath();
|
|
|
|
char szCurrentDirectory[MAX_PATH];
|
|
V_GetCurrentDirectory( szCurrentDirectory, sizeof( szCurrentDirectory ) );
|
|
m_StartDirectory = szCurrentDirectory;
|
|
|
|
// parse and build tables from group script that options will reference
|
|
if ( bScriptIsVGC )
|
|
{
|
|
VPC_ParseGroupScript( pScriptName );
|
|
}
|
|
|
|
if ( bScriptIsVCProj )
|
|
{
|
|
// this is commonly used as an extern tool in MSDEV to re-vpc in place
|
|
// caller is msdev providing the vcproj name, solve to determine which project and generate
|
|
FindProjectFromVCPROJ( pScriptNameVCProj );
|
|
}
|
|
else
|
|
{
|
|
ParseBuildOptions( m_nArgc, m_ppArgv );
|
|
}
|
|
|
|
// set macros and conditionals derived from command-line options
|
|
SetMacrosAndConditionals();
|
|
|
|
// generate a CRC string derived from command-line options
|
|
GenerateOptionsCRCString();
|
|
|
|
SetupGenerators();
|
|
|
|
// filter user's build commands
|
|
// generate list of build targets
|
|
CProjectDependencyGraph dependencyGraph;
|
|
GenerateBuildSet( dependencyGraph );
|
|
|
|
if ( !bHasBuildCommand && !HasP4SLNCommand() )
|
|
{
|
|
// spew usage
|
|
m_bUsageOnly = true;
|
|
}
|
|
|
|
if ( m_bUsageOnly )
|
|
{
|
|
// spew only
|
|
SpewUsage();
|
|
return 0;
|
|
}
|
|
|
|
#ifdef WIN32
|
|
if ( HandleP4SLN( m_pSolutionGenerator ) )
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
// iterate and build target projects
|
|
if ( !BuildTargetProjects() )
|
|
{
|
|
// build failure
|
|
return 0;
|
|
}
|
|
|
|
// now that we have valid project files, can generate solution
|
|
HandleMKSLN( m_pSolutionGenerator, dependencyGraph );
|
|
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// main
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// VPC is a DLL in Source.
|
|
#if defined(STEAM) || defined(OSX) || defined(LINUX)
|
|
int main( int argc, char **argv )
|
|
#else
|
|
int vpcmain( int argc, char **argv )
|
|
#endif
|
|
{
|
|
g_pVPC = new CVPC();
|
|
|
|
if ( !g_pVPC->Init( argc, argv ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int nRetVal = g_pVPC->ProcessCommandLine();
|
|
|
|
g_pVPC->Shutdown();
|
|
|
|
return nRetVal;
|
|
}
|
|
|
|
// VPC is a DLL in Source.
|
|
#if !(defined(STEAM) || defined(OSX) || defined(LINUX))
|
|
#include "ilaunchabledll.h"
|
|
|
|
// VPC is launched by vpc.exe, which is a copy of binlaunch.exe.
|
|
// All binlaunch does is setup the path to game\bin and load an ILaunchableDLL
|
|
// interface out of a DLL with the same name as the exe.
|
|
class CVPCLaunchableDLL : public ILaunchableDLL
|
|
{
|
|
public:
|
|
// All vpc.exe does is load the vpc DLL and run this.
|
|
virtual int main( int argc, char **argv )
|
|
{
|
|
return vpcmain( argc, argv );
|
|
}
|
|
};
|
|
|
|
EXPOSE_SINGLE_INTERFACE( CVPCLaunchableDLL, ILaunchableDLL, LAUNCHABLE_DLL_INTERFACE_VERSION );
|
|
#endif
|
|
|
|
|