d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
159 Commits
25 Branches
6 Tags
221 MiB
Branch: sanitize
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'sanitize'
${ noResults }
source-engine/vpc_scripts/generateVPC2005.pl

1843 lines
45 KiB
Raw Permalink Normal View History Unescape

1
5 years ago
use strict;
no strict 'refs';
######################################################
# Data Section
######################################################
my(@lines) = (); # holds the input file
my(@tabs) = (); # for indentation
my(@lineToPrint) = (); # current formatted output line
#my(@configOutput) = (); # output from configuration parsing
my(%configOutput) = (); # hash of configuration-specific config options
my($currentConfig) = ""; # configuration currently being parsed
my($nameFound) = 0; # flag set when project name has been parsed
my($lineCt) = 0; # current line number in the source file
my($exclusionsFound) = 0; # an file has been 'excluded from build' for some configuration
my($projectName) = ""; # base name of the project
my($parsingFiles) = 0; # a cheap state variable
my($splitConfigs) = 0; # debug variable set from the commmand line
my($outputPath) = undef;# optional path for the vpc destination
my($spaceBeforeFolder) = 0; # tracks when to add a line before folder blocks
my($spaceBeforeFile) = 0; # tracks when to add a line before file blocks
my($tabstop) = 4; # size of tabs - 4 for visual studio
my($srcdirBackslash) = undef;# holds the value of the macro SRCDIR, with \ separators
my($srcdirForwardslash) = undef;# holds the value of the macro SRCDIR, with / separators
my($usestring) = 1; # use string values for compiler options
my($stripEmptyOptions) = 1; # remove compiler options that have empty values (strings)
if ( $ARGV[1] =~ /useindex/ )
{
$usestring = 0;
}
elsif ( $ARGV[1] =~ /allownullstrings/ )
{
$stripEmptyOptions = 0;
}
elsif ( $ARGV[1] =~ /-o/ )
{
$outputPath = $ARGV[2];
}
##############################################################################
# Match vcproj option keywords with vpc keywords - only string value options
# String on the left matches the option name in the VCProj.
# String on the right matches the option name in vpc
my(%configOptionsSingleValue) = (
# Configuration
"General" =>
{
# General
"OutputDirectory" => "OutputDirectory",
"IntermediateDirectory" => "IntermediateDirectory",
"DeleteExtensionsOnClean" => "ExtensionsToDeleteOnClean",
"BuildLogFile" => "BuildLogFile",
"ATLMinimizesCRunTimeLibraryUsage" => "MinimizeCRTUseInATL",
"ManagedExtensions" => "UseManagedExtensions",
"WholeProgramOptimization" => "WholeProgramOptimization",
"ReferencesPath" => "ReferencesPath",
"ExcludedFromBuild" => "ExcludedFromBuild",
# Debugging
},
# C/C++
"VCCLCompilerTool" =>
{
# General
"AdditionalIncludeDirectories" => "AdditionalIncludeDirectories",
"AdditionalUsingDirectories" => "ResolveUsingReferences",
# Optimization
# Preprocessor
"PreprocessorDefinitions" => "PreprocessorDefinitions",
# Code Generation
# Language
# Precompiled Headers
"PrecompiledHeaderThrough" => "Create/UsePCHThroughFile",
"PrecompiledHeaderFile" => "PrecompiledHeaderFile",
# Output Files
"AssemblerListingLocation" => "ASMListLocation",
"ObjectFile" => "ObjectFileName",
"ProgramDataBaseFileName" => "ProgramDatabaseFileName",
"XMLDocumentationFileName" => "XMLDocumentationFileName",
# Browse Information
"BrowseInformationFile" => "BrowseFile",
# Advanced
"DisableSpecificWarnings" => "DisableSpecificWarnings",
"ForcedIncludeFiles" => "ForceIncludes",
"ForcedUsingFiles" => "ForceUsing",
"UndefinePreprocessorDefinitions" => "UndefinePreprocessorDefinitions",
# Command Line
"AdditionalOptions" => "AdditionalOptions",
},
# Librarian
"VCLibrarianTool" =>
{
# General
"OutputFile" => "OutputFileexplo",
"AdditionalDependencies" => "AdditionalDependencies",
"AdditionalLibraryDirectories" => "AdditionalLibraryDirectories",
"ModuleDefinitionFile" => "ModuleDefinitionFileName",
"IgnoreDefaultLibraryNames" => "IgnoreSpecificLibrary",
"ExportNamedFunctions" => "ExportNamedFunctions",
"ForceSymbolReferences" => "ForceSymbolReferences",
# Command LIne
"AdditionalOptions" => "AdditionalOptions",
},
# Linker
"VCLinkerTool" =>
{
# General
"OutputFile" => "OutputFile",
"Version" => "Version",
"AdditionalLibraryDirectories" => "AdditionalLibraryDirectories",
# Input
"AdditionalDependencies" => "AdditionalDependencies",
"IgnoreDefaultLibraryNames" => "IgnoreSpecificLibrary",
"ModuleDefinitionFile" => "ModuleDefinitionFile",
"AddModuleNamesToAssembly" => "AddModuleToAssembly",
"EmbedManagedResourceFile" => "EmbedManagedResourceFile",
"ForceSymbolReferences" => "ForceSymbolReferences",
"DelayLoadDLLs" => "DelayLoadedDLLs",
"AssemblyLinkResource" => "AssemblyLinkResource",
# Manifest File
"ManifestFile" => "ManifestFile",
"AdditionalManifestDependencies" => "AdditionalManifestDependencies",
# Debugging
"ProgramDatabaseFile" => "GenerateProgramDatabaseFile",
"StripPrivateSymbols" => "StripPrivateSymbols",
"MapFileName" => "MapFileName",
# System
"HeapReserveSize" => "HeapReserverSize",
"HeapCommitSize" => "HeapCommitSize",
"StackReserveSize" => "StackReserveSize",
"StackCommitSize" => "StackCommitSize",
# Optimization
"FunctionOrder" => "FunctionOrder",
"ProfileGuidedDatabase" => "ProfileGuidedDatabase",
# Embedded IDL
"MidlCommandFile" => "MIDLCommands",
"MergedIDLBaseFileName" => "MergedIDLBaseFileName",
"TypeLibraryFile" => "TypeLibrary",
"TypeLibraryResourceID" => "TypeLibResourceID",
# Advanced
"EntryPointSymbol" => "EntryPoint",
"BaseAddress" => "BaseAddress",
"ImportLibrary" => "ImportLibrary",
"MergeSections" => "MergeSections",
"KeyFile" => "KeyFile",
"KeyContainer" => "KeyContainer",
# Command LIne
"AdditionalOptions" => "AdditionalOptions",
},
# Resources
"VCResourceCompilerTool" =>
{
# General
"PreprocessorDefinitions" => "PreprocessorDefinitions",
"AdditionalIncludeDirectories" => "AdditionalIncludeDirectories",
"ResourceOutputFileName" => "ResourceFileName",
# Command LIne
"AdditionalOptions" => "AdditionalOptions",
},
# Build Events
"VCPreBuildEventTool" =>
{
# Pre-Build Event
"CommandLine" => "CommandLine",
"Description" => "Description",
"ExcludedFromBuild" => "ExcludedFromBuild",
},
"VCPreLinkEventTool" =>
{
# Pre-Link Event
"CommandLine" => "CommandLine",
"Description" => "Description",
"ExcludedFromBuild" => "ExcludedFromBuild",
},
"VCPostBuildEventTool" =>
{
# Post-Build Event
"CommandLine" => "CommandLine",
"Description" => "Description",
"ExcludedFromBuild" => "ExcludedFromBuild",
},
# Custom Build Step
"VCCustomBuildTool" =>
{
# Pre-Build Event
"CommandLine" => "CommandLine",
"Description" => "Description",
"Outputs" => "Outputs",
"AdditionalDependencies" => "AdditionalDependencies",
},
);
##############################################################################
# Match vcproj option keywords with vpc keywords - only multi-value options
# String on the left matches the option name in the VCProj.
# String on the right matches the option name in vpc
my(%configOptionsMultiValue) = (
# General
"ConfigurationType" => "ConfigurationType",
"UseOfMFC" => "UseOfMFC",
"UseOfAtl" => "UseOfATL",
"CharacterSet" => "CharacterSet",
# Debugging
# C/C++
# General
"DebugInformationFormat" => "DebugInformationFormat",
"SuppressStartupBanner" => "SuppressStartupBanner",
"WarningLevel" => "WarningLevel",
"Detect64BitPortabilityProblems" => "Detect64BitPortabilityIssues",
"WarnAsError" => "TreatWarningsAsErrors",
"UseUnicodeResponseFiles" => "UseUNICODEResponseFiles",
# Optimization
"Optimization" => "Optimization",
"InlineFunctionExpansion" => "InlineFunctionExpansion",
"EnableIntrinsicFunctions" => "EnableIntrinsicFunctions",
"FavorSizeOrSpeed" => "FavorSizeOrSpeed",
"OmitFramePointers" => "OmitFramePointers",
"EnableFiberSafeOptimizations" => "EnableFiberSafeOptimizations",
"WholeProgramOptimization" => "WholeProgramOptimization",
# Preprocessor
"IgnoreStandardIncludePath" => "IgnoreStandardIncludePath",
"GeneratePreprocessedFile" => "GeneratePreprocessedFile",
"KeepComments" => "KeepComments",
# Code Generation
"StringPooling" => "EnableStringPooling",
"MinimalRebuild" => "EnableMinimalRebuild",
"ExceptionHandling" => "EnableC++Exceptions",
"SmallerTypeCheck" => "SmallerTypeCheck",
"BasicRuntimeChecks" => "BasicRuntimeChecks",
"RuntimeLibrary" => "RuntimeLibrary",
"StructMemberAlignment" => "StructMemberAlignement",
"BufferSecurityCheck" => "BufferSecurityCheck",
"EnableFunctionLevelLinking" => "EnableFunctionLevelLinking",
"EnableEnhancedInstructionSet" => "EnableEnhancedInstructionSet",
"FloatingPointModel" => "FloatingPointModel",
"FloatingPointExceptions" => "EnableFloatingPointExceptions",
# Language
"DisableLanguageExtensions" => "DisableLanguageExtensions",
"DefaultCharIsUnsigned" => "DefaultCharUnsigned",
"TreatWChar_tAsBuiltInType" => "TreatWchar_tAsBuiltinType",
"ForceConformanceInForLoopScope" => "ForceConformanceInForLoopScope",
"RuntimeTypeInfo" => "EnableRunTimeTypeInfo",
"OpenMP" => "OpenMPSupport",
# Precompiled Headers
"UsePrecompiledHeader" => "Create/UsePrecompiledHeader",
# Output Files
"ExpandAttributedSource" => "ExpandAttributedSource",
"AssemblerOutput" => "AssemblerOutput",
"GenerateXMLDocumentationFiles" => "GenerateXMLDocumentationFiles",
# Browse Information
"BrowseInformation" => "EnableBrowseInformation",
# Advanced
"CallingConvention" => "CallingConvention",
"CompileAs" => "CompileAs",
"UndefineAllPreprocessorDefinitions" => "UndefineAllPreprocessorDefinitions",
"UseFullPaths" => "UseFullPaths",
"OmitDefaultLibName" => "OmitDefaultLibraryNames",
"ErrorReporting" => "ErrorReporting",
# Librarian
# General
"SuppressStartupBanner" => "SuppressStartupBanner",
"IgnoreAllDefaultLibraries" => "IgnoreAllDefaultLibraries",
"UseUnicodeResponseFiles" => "UseUNICODEResponseFiles",
"LinkLibraryDependencies" => "LinkLibraryDependencies",
# Linker
# General
"ShowProgress" => "ShowProgress",
"LinkIncremental" => "EnableIncrementalLinking",
"SuppressStartupBanner" => "SuppressStartupBanner",
"IgnoreImportLibrary" => "IgnoreImportLibrary",
"RegisterOutput" => "RegisterOutput",
"LinkLibraryDependencies" => "LinkLibraryDependencies",
"UseLibraryDependencyInputs" => "UseLibraryDependencyInputs",
"UseUnicodeResponseFiles" => "UseUNICODEResponseFiles",
# Input
"IgnoreAllDefaultLibraries" => "IgnoreAllDefaultLibraries",
# Manifest File
"GenerateManifest" => "GenerateManifest",
"AllowIsolation" => "AllowIsolation",
# Debugging
"GenerateDebugInformation" => "GenerateDebugInfo",
"GenerateMapFile" => "GenerateMapFile",
"MapExports" => "MapExports",
"AssemblyDebug" => "DebuggableAssembly",
# System
"SubSystem" => "SubSystem",
"LargeAddressAware" => "EnableLargeAddresses",
"TerminalServerAware" => "TerminalServer",
"SwapRunFromCD" => "SwapRunFromCD",
"SwapRunFromNet" => "SwapRunFromNetwork",
"Driver" => "Driver",
# Optimization
"OptimizeReferences" => "References",
"EnableCOMDATFolding" => "EnableCOMDATFolding",
"OptimizeForWindows98" => "OptimizeForWindows98",
"LinkTimeCodeGeneration" => "LinkTimeCodeGeneration",
# Embedded IDL
"IgnoreEmbeddedIDL" => "IgnoreEmbeddedIDL",
# Advanced
"ResourceOnlyDLL" => "NoEntryPoint",
"SetChecksum" => "SetChecksum",
"FixedBaseAddress" => "FixedBaseAddress",
"TurnOffAssemblyGeneration" => "TurnOffAssemblyGeneration",
"SupportUnloadOfDelayLoadedDLL" => "DelayLoadedDLL",
"TargetMachine" => "TargetMachine",
"Profile" => "Profile",
"CLRThreadAttribute" => "CLRThreadAttribute",
"CLRImageType" => "CLRImageType",
"DelaySign" => "DelaySign",
"ErrorReporting" => "ErrorReporting",
"CLRUnmanagedCodeCheck" => "CLRUnmanagedCodeCheck",
# Resources
# General
"Culture" => "Culture",
"IgnoreStandardIncludePath" => "IgnoreStandardIncludePath",
"ShowProgress" => "ShowProgress",
);
##############################################################################
# Match user option names to their lists of possible values
my(%configOptionValues) = (
# General
"ConfigurationType" =>
{
"0" => "Makefile",
"1" => "Application \(\.exe\)",
"2" => "Dynamic Library \(\.dll\)",
"3" => "Static Library \(\.lib\)",
"4" => "Utility",
},
"UseOfMFC" =>
{
"0" => "Use Standard Windows Libraries",
"1" => "Use MFC In A Static Library",
"2" => "Use MFC In A Shared DLL",
},
"UseOfATL" =>
{
"0" => "Not Using ATL",
"1" => "Static Link To ATL",
"2" => "Dynamic Link To ATL",
},
"CharacterSet" =>
{
"0" => "Not Set",
"1" => "Use Unicode Character Set",
"2" => "Use Multi-Byte Character Set",
},
# Debugging
# C/C++
# General
"DebugInformationFormat" =>
{
# These skip a number on purpose (per VS2005)
"0" => "Disabled",
"1" => "C7 Compatible \(\/Z7\)",
"3" => "Program Database \(\/Zi\)",
"4" => "Program Database for Edit & Continue \(\/ZI\)",
},
"SuppressStartupBanner" =>
{
"false" => "No",
"true" => "Yes \(\/nologo\)",
},
"WarningLevel" =>
{
"0" => "Off: Turn Off All Warnings \(\/W0\)",
"1" => "Level 1 \(\/W1\)",
"2" => "Level 2 \(\/W2\)",
"3" => "Level 3 \(\/W3\)",
"4" => "Level 4 \(\/W4\)",
},
"Detect64BitPortabilityProblems" =>
{
"false" => "No",
"true" => "Yes \(\/Wp64\)",
},
"WarnAsError" =>
{
"false" => "No",
"true" => "Yes \(\/WX\)",
},
"UseUnicodeResponseFiles" =>
{
"false" => "No",
"true" => "Yes",
},
# Optimization
"Optimization" =>
{
"0" => "Disabled \(\/Od\)",
"1" => "Minimize Size \(\/O1\)",
"2" => "Maximize Speed \(\/O2\)",
"3" => "Full Optimization \(\/Ox\)",
"4" => "Custom",
},
"InlineFunctionExpansion" =>
{
"0" => "Default",
"1" => "Only __inline \(\/Ob1\)",
"2" => "Any Suitable \(\/Ob2\)",
},
"EnableIntrinsicFunctions" =>
{
"false" => "No",
"true" => "Yes \(\/Oi\)",
},
"FavorSizeOrSpeed" =>
{
"0" => "Neither",
"1" => "Favor Fast Code \(\/Ot\)",
"2" => "Favor Small Code \(\/Os\)",
},
"OmitFramePointers" =>
{
"false" => "No",
"true" => "Yes \(\/Oy\)",
},
"EnableFiberSafeOptimizations" =>
{
"false" => "No",
"true" => "Yes \(\/GT\)",
},
"WholeProgramOptimization" =>
{
"false" => "No",
"true" => "Enable link-time code generation \(\/GL\)",
},
# Preprocessor
"IgnoreStandardIncludePath" =>
{
"false" => "No",
"true" => "Yes \(\/X\)",
},
"GeneratePreprocessedFile" =>
{
"0" => "No",
"1" => "With Line Numbers \(\/P\)",
"2" => "Without Line Numbers \(\/EP \/P\)",
},
"KeepComments" =>
{
"false" => "No",
"true" => "Yes \(\/C\)",
},
# Code Generation
"StringPooling" =>
{
"false" => "No",
"true" => "Yes \(\/GF\)",
},
"MinimalRebuild" =>
{
"false" => "No",
"true" => "Yes \(\/Gm\)",
},
"ExceptionHandling" =>
{
"0" => "No",
"1" => "Yes \(\/EHsc\)",
"2" => "Yes With SEH Exceptions \(\/EHa\)",
},
"SmallerTypeCheck" =>
{
"false" => "No",
"true" => "Yes \(\/RTCc\)",
},
"BasicRuntimeChecks" =>
{
"0" => "Default",
"1" => "Stack Frames \(\/RTCs\)",
"2" => "Uninitialized Variables \(\/RTCu\)",
"3" => "Both \(\/RTC1, equiv\. to \/RTCsu\)",
},
"RuntimeLibrary" =>
{
"0" => "Multi-threaded \(\/MT\)",
"1" => "Multi-threaded Debug \(\/MTd\)",
"2" => "Multi-threaded DLL \(\/MD\)",
"3" => "Multi-threaded Debug DLL \(\/MDd\)",
},
"StructMemberAlignment" =>
{
"0" => "Default",
"1" => "1 Byte \(\/Zp1\)",
"2" => "2 Bytes \(\/Zp2\)",
"3" => "4 Bytes \(\/Zp4\)",
"4" => "8 Bytes \(\/Zp8\)",
"5" => "16 Bytes \(\/Zp16\)",
},
"BufferSecurityCheck" =>
{
"false" => "No (/GS-)",
"true" => "Yes",
},
"EnableFunctionLevelLinking" =>
{
"false" => "No",
"true" => "Yes \(/Gy\)",
},
"EnableEnhancedInstructionSet" =>
{
"0" => "Not Set",
"1" => "Streaming SIMD Extensions \(\/arch:SSE\)",
"2" => "Streaming SIMD Extensions 2 \(\/arch:SSE2\)",
},
"FloatingPointModel" =>
{
"0" => "Precise \(\/fp:precise\)",
"1" => "Strict \(\/fp:strict\)",
"2" => "Fast \(\/fp:fast\)",
},
"FloatingPointExceptions" =>
{
"false" => "No",
"true" => "Yes \(\/fp:except\)",
},
# Language
"DisableLanguageExtensions" =>
{
"false" => "No",
"true" => "Yes \(/Za\)",
},
"DefaultCharIsUnsigned" =>
{
"false" => "No",
"true" => "Yes \(\/J\)",
},
"TreatWChar_tAsBuiltInType" =>
{
"false" => "No \(\/Zc:wchar_t-\)",
"true" => "Yes",
},
"ForceConformanceInForLoopScope" =>
{
"false" => "No \(\/Zc:forScope-\)",
"true" => "Yes",
},
"RuntimeTypeInfo" =>
{
"false" => "No \(\/GR-\)",
"true" => "Yes",
},
"OpenMP" =>
{
"false" => "No",
"true" => "Yes \(\/openmp\)",
},
# Precompiled Headers
"UsePrecompiledHeader" =>
{
"0" => "Not Using Precompiled Headers",
"1" => "Create Precompiled Header \(\/Yc\)",
"2" => "Use Precompiled Header \(\/Yu\)",
},
# Output Files
"ExpandAttributedSource" =>
{
"false" => "No",
"true" => "Yes \(\/Fx\)",
},
"AssemblerOutput" =>
{
"0" => "No Listing",
"1" => "Assembly-Only Listing \(\/FA\)",
"2" => "Assembly, Machine Code and Source \(\/FAcs\)",
"3" => "Assembly With Machine Code \(\/FAc\)",
"4" => "Assembly With Source Code \(\/FAs\)",
},
"GenerateXMLDocumentationFiles" =>
{
"false" => "No",
"true" => "Yes (/doc)",
},
# Browse Information
"BrowseInformation" =>
{
"0" => "None",
"1" => "Include All Browse Information \(\/FR\)",
"2" => "No Local Symbols \(\/Fr\)",
},
# Advanced
"CallingConvention" =>
{
"0" => "__cdecl \(\/Gd\)",
"1" => "__fastcall \(\/Gr\)",
"2" => "__stdcall \(\/Gz\)",
},
"CompileAs" =>
{
"0" => "Default",
"1" => "Compile as C Code \(\/TC\)",
"2" => "Compile as C\+\+ Code \(\/TP\)",
},
"ShowIncludes" =>
{
"false" => "No",
"true" => "Yes \(\/showIncludes\)",
},
"UndefineAllPreprocessorDefinitions" =>
{
"false" => "No",
"true" => "Yes \(\/u\)",
},
"UseFullPaths" =>
{
"false" => "No",
"true" => "Yes \(\/FC\)",
},
"OmitDefaultLibName" =>
{
"false" => "No",
"true" => "Yes \(\/Zl\)",
},
"ErrorReporting" =>
{
"0" => "Default",
"1" => "Prompt Immediately \(\/errorReport:prompt\)",
"2" => "Queue For Next Login \(\/errorReport:queue\)",
},
# Librarian
# General
"SuppressStartupBanner" =>
{
"false" => "No",
"true" => "Yes \(\/NOLOGO\)",
},
"IgnoreAllDefaultLibraries" =>
{
"false" => "No",
"true" => "Yes \(\/NODEFAULTLIB\)",
},
"UseUnicodeResponseFiles" =>
{
"false" => "No",
"true" => "Yes",
},
"LinkLibraryDependencies" =>
{
"false" => "No",
"true" => "Yes",
},
# Linker
#General
"ShowProgress" =>
{
"0" => "Not Set",
"1" => "Display All Progress Messages \(\/VERBOSE\)",
"2" => "Displays Some Progress Messages \(\/VERBOSE:LIB\)",
},
"LinkIncremental" =>
{
"0" => "Default",
"1" => "No \(\/INCREMENTAL:NO\)",
"2" => "Yes \(\/INCREMENTAL\)",
},
"SuppressStartupBanner" =>
{
"false" => "No",
"true" => "Yes \(\/NOLOGO\)",
},
"IgnoreImportLibrary" =>
{
"false" => "No",
"true" => "Yes",
},
"RegisterOutput" =>
{
"false" => "No",
"true" => "Yes",
},
"LinkLibraryDependencies" =>
{
"false" => "No",
"true" => "Yes",
},
"UseLibraryDependencyInputs" =>
{
"false" => "No",
"true" => "Yes",
},
"UseUnicodeResponseFiles" =>
{
"false" => "No",
"true" => "Yes",
},
# Input
"IgnoreAllDefaultLibraries" =>
{
"false" => "No",
"true" => "Yes \(\/NODEFAULTLIB\)",
},
# Manifest File
"GenerateManifest" =>
{
"false" => "No",
"true" => "Yes",
},
"AllowIsolation" =>
{
"false" => "Don't allow side-by-side isolation \(\/ALLOWISOLATION:NO\)",
"true" => "Yes",
},
# Debugging
"GenerateDebugInformation" =>
{
"false" => "No",
"true" => "Yes \(\/DEBUG\)",
},
"GenerateMapFile" =>
{
"false" => "No",
"true" => "Yes \(\/MAP\)",
},
"MapExports" =>
{
"false" => "No",
"true" => "Yes \(\/MAPINFO:EXPORTS\)",
},
"AssemblyDebug" =>
{
"0" => "No Debuggable attribute emitted",
"1" => "Runtime tracking and disable optimizations \(\/ASSEMBLYDEBUG\)",
"2" => "No runtime tracking and enable optimizations \(\/ASSEMBLYDEBUG:DISABLE\)",
},
# System
"SubSystem" =>
{
"0" => "Not Set",
"1" => "Console \(\/SUBSYSTEM:CONSOLE\)",
"2" => "Windows \(\/SUBSYSTEM:WINDOWS\)",
"3" => "Native \(\/SUBSYSTEM:NATIVE\)",
"4" => "EFI Application \(\/SUBSYSTEM:EFI_APPLICATION\)",
"5" => "EFI Boot Service Driver \(\/SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER\)",
"6" => "EFI ROM \(\/SUBSYSTEM:EFI_ROM\)",
"7" => "EFI Runtime \(\/SUBSYSTEM:EFI_RUNTIME_DRIVER\)",
"8" => "Posix \(\/SUBSYSTEM:POSIX\)",
"9" => "WindowsCE \(\/SUBSYSTEM:WINDOWSCE\)",
},
"LargeAddressesAware" =>
{
"0" => "Default",
"1" => "Do Not Support Addresses Larger Than 2 Gigabytes \(\/LARGEADDRESSAWARE:NO\)",
"2" => "Support Addresses Larger Than 2 Gigabytes \(\/LARGEADDRESSAWARE\)",
},
"TerminalServerAware" =>
{
"0" => "Default",
"1" => "Not Terminal Server Aware \(\/TSAWARE:NO\)",
"2" => "Application is Terminal Server Aware \(\/TSAWARE\)",
},
"SwapRunFromCD" =>
{
"false" => "No",
"true" => "Yes \(\/SWAPRUN:CD\)",
},
"SwapRunFromNet" =>
{
"false" => "No",
"true" => "Yes \(\/SWAPRUN:NET\)",
},
"Driver" =>
{
"0" => "Not Set",
"1" => "Driver \(\/DRIVER\)",
"2" => "Up Only \(\/DRIVER:UPONLY\)",
"3" => "WDM \(\/DRIVER:WDM\)",
},
#Optimization
"OptimizeReferences" =>
{
"0" => "Default",
"1" => "Keep Unreferenced Data \(\/OPT:NOREF\)",
"2" => "Eliminate Unreferenced Data \(\/OPT:REF\)",
},
"EnableCOMDATFolding" =>
{
"0" => "Default",
"1" => "Do Not Remove Redundant COMDATs \(\/OPT:NOICF\)",
"2" => "Remove Redundant COMDATs \(\/OPT:ICF\)",
},
"OptimizeForWindows98" =>
{
"0" => "Default",
"1" => "No \(\/OPT:NOWIN98\)",
"2" => "Yes \(\/OPT:WIN98\)",
},
"LinkTimeCodeGeneration" =>
{
"0" => "Default",
"1" => "Use Link Time Code Generation \(\/ltcg\)",
"2" => "Profile Guided Optimization - Instrument \(\/ltcg:pginstrument\)",
"3" => "Profile Guided Optimization - Optimize \(\/ltcg:pgoptimize\)",
"4" => "Profile Guided Optimization - Update \(\/ltcg:pgupdate\)",
},
# Embedded IDL
"IgnoreEmbeddedIDL" =>
{
"false" => "No",
"true" => "Yes \(\/IGNOREIDL\)",
},
#Advanced
"ResourceOnlyDLL" =>
{
"false" => "No",
"true" => "Yes \(\/NOENTRY\)",
},
"SetChecksum" =>
{
"false" => "No",
"true" => "Yes \(\/RELEASE\)",
},
"FixedBaseAddress" =>
{
"0" => "Default",
"1" => "Generate a relocation section \(\/FIXED:NO\)",
"2" => "Image must be loaded at a fixed address \(\/FIXED\)",
},
"TurnOffAssemblyGeneration" =>
{
"false" => "No",
"true" => "Yes \(\/NOASSEMBLY\)",
},
"SupportUnloadOfDelayLoadedDLL" =>
{
"0" => "Don't Support Unload",
"1" => "Support Unload \(\/DELAY:UNLOAD\)",
},
"TargetMachine" =>
{
"0" => "Not Set",
"1" => "MachineX86 \(\/MACHINE:X86\)",
"2" => "MachineAM33 \(\/MACHINE:AM33\)",
"3" => "MachineARM \(\/MACHINE:ARM\)",
"4" => "MachineEBC \(\/MACHINE:EBC\)",
"5" => "MachineIA64 \(\/MACHINE:IA64\)",
"6" => "MachineM32R \(\/MACHINE:M32R\)",
"7" => "MachineMIPS \(\/MACHINE:MIPS\)",
"8" => "MachineMIPS16 \(\/MACHINE:MIPS16\)",
"9" => "MachineMIPSFPU \(\/MACHINE:MIPSFPU\)",
"10" => "MachineMIPSFPU16 \(\/MACHINE:MIPSFPU16\)",
"11" => "MachineMIPSR41XX \(\/MACHINE:MIPSR41XX\)",
"12" => "MachineSH3 \(\/MACHINE:SH3\)",
"13" => "MachineSH4 \(\/MACHINE:SH4\)",
"14" => "MachineSH5 \(\/MACHINE:SH5\)",
"15" => "MachineTHUMB \(\/MACHINE:THUMB\)",
"16" => "MachineX64 \(\/MACHINE:X64\)",
},
"Profile" =>
{
"false" => "No",
"true" => "Enable Profiling information \(\/PROFILE\)",
},
"CLRThreadAttribute" =>
{
"0" => "No threading attribute set",
"1" => "MTA threading attribute \(\/CLRTHREADATTRIBUTE:MTA\)",
"2" => "STA threading attribute \(\/CLRTHREADATTRIBUTE:STA\)",
},
"CLRImageType" =>
{
"0" => "Default image type",
"1" => "Force IJW image \(\/CLRIMAGETYPE:IJW\)",
"2" => "Force pure IL image \(\/CLRIMAGETYPE:PURE\)",
"3" => "Force safe IL image \(\/CLRIMAGETYPE:SAFE\)",
},
"DelaySign" =>
{
"false" => "No",
"true" => "Yes \(\/DELAYSIGN\)",
},
"ErrorReporting" =>
{
"0" => "Default",
"1" => "Prompt Immediately \(\/ERRORREPORT:PROMPT\)",
"2" => "Queue For Next Login \(\/ERRORREPORT:QUEUE\)",
},
"CLRUnmanagedCodeCheck" =>
{
"false" => "No",
"true" => "Apply Unmanaged Code Check \(\/CLRUNMANAGEDCODECHECK\)",
},
# Resources
# General
"Culture" =>
{
"1000" => "Default",
"1001" => "Afrikaans \(0x436\)",
"1002" => "Albanian \(0x41c\)",
"1003" => "Arabic (Saudi Arabia) \(0x401\)",
"1004" => "Arabic (Iraq) \(0x801\)",
"1005" => "Arabic (Egypt) \(0xc01\)",
"1006" => "Arabic (Libya) \(0x1001\)",
"1007" => "Arabic (Algeria) \(0x1401\)",
"1008" => "Arabic (Morocco) \(0x1801\)",
"1009" => "Arabic (Tunisia) \(0x1c01\)",
"1010" => "Arabic (Oman) \(0x2001\)",
"1011" => "Arabic (Yemen) \(0x2401\)",
"1012" => "Arabic (Syria) \(0x2801\)",
"1013" => "Arabic (Jordan) \(0x2c01\)",
"1014" => "Arabic (Lebanon) \(0x3001\)",
"1015" => "Arabic (Kuwait) \(0x3401\)",
"1016" => "Arabic (U.A.E.) \(0x3801\)",
"1017" => "Arabic (Bahrain) \(0x3c01\)",
"1018" => "Arabic (Qatar) \(0x4001\)",
"1019" => "Basque \(0x42d\)",
"1020" => "Bulgarian \(0x402\)",
"1021" => "Belarusian \(0x423\)",
"1022" => "Catalan \(0x403\)",
"1023" => "Chinese (Taiwan) \(0x404\)",
"1024" => "Chinese (PRC) \(0x804\)",
"1025" => "Chinese (Hong Kong S.A.R.) \(0xc04\)",
"1026" => "Chinese (Singapore) \(0x1004\)",
"1027" => "Croatian \(0x41a\)",
"1028" => "Czech \(0x405\)",
"1029" => "Danish \(0x406\)",
"1030" => "Dutch (Netherlands) \(0x413\)",
"1031" => "Dutch (Belgium) \(0x813\)",
"1032" => "English (United States) \(0x409\)",
"1033" => "English (United Kingdom) \(0x809\)",
"1034" => "English (Australia) \(0xc09\)",
"1035" => "English (Canada) \(0x1009\)",
"1036" => "English (New Zealand) \(0x1409\)",
"1037" => "English (Ireland) \(0x1809\)",
"1038" => "English (South Africa) \(0x1c09\)",
"1039" => "English (Jamaica) \(0x2009\)",
"1040" => "English (Caribbean) \(0x2409\)",
"1041" => "Estonian \(0x425\)",
"1042" => "Farsi \(0x429\)",
"1043" => "Finnish \(0x40b)",
"1044" => "French (France) \(0x40c\)",
"1045" => "French (Belgium) \(0x80c\)",
"1046" => "French (Canada) \(0xc0c\)",
"1047" => "French (Switzerland) \(0x100c\)",
"1048" => "French (Luxembourg) \(0x140c\)",
"1049" => "German (Germany) \(0x407\)",
"1050" => "German (Switzerland) \(0x807\)",
"1051" => "German (Austria) \(0xc07\)",
"1052" => "German (Luxembourg) \(0x1007\)",
"1053" => "German (Liechtenstein) \(0x1407\)",
"1054" => "Greek \(0x408\)",
"1055" => "Hebrew \(0x40d\)",
"1056" => "Hungarian \(0x40e\)",
"1057" => "Icelandic \(0x40f\)",
"1058" => "Indonesian \(0x421\)",
"1059" => "Italian (Italy) \(0x410\)",
"1060" => "Italian (Switzerland) \(0x810\)",
"1061" => "Japanese \(0x411\)",
"1062" => "Korean \(0x412\)",
"1063" => "0x812",
"1064" => "Latvian \(0x426\)",
"1065" => "Lithuanian \(0x427\)",
"1066" => "Norwegian (Bokmal) \(0x414\)",
"1067" => "Norwegian (Nynorsk) \(0x814\)",
"1068" => "Polish \(0x415\)",
"1069" => "Portuguese (Brazil) \(0x416\)",
"1070" => "Portuguese (Portugal) \(0x816\)",
"1071" => "Romanian \(0x418\)",
"1072" => "Russian \(0x419\)",
"1073" => "Slovak \(0x41b\)",
"1074" => "Spanish (Traditional Sort) \(0x40a\)",
"1075" => "Spanish (Mexico) \(0x80a\)",
"1076" => "Spanish (International Sort) \(0xc0a\)",
"1077" => "Spanish (Guatemala) \(0x100a\)",
"1078" => "Spanish (Costa Rica) \(0x140a\)",
"1079" => "Spanish (Panama) \(0x180a\)",
"1080" => "Spanish (Dominican Republic) \(0x1c0a\)",
"1081" => "Spanish (Venezuela) \(0x200a\)",
"1082" => "Spanish (Colombia) \(0x240a\)",
"1083" => "Spanish (Peru) \(0x280a\)",
"1084" => "Spanish (Argentina) \(0x2c0a\)",
"1085" => "Spanish (Ecuador) \(0x300a\)",
"1086" => "Spanish (Chile) \(0x340a\)",
"1087" => "Spanish (Uruguay) \(0x380a\)",
"1088" => "Spanish (Paraguay) \(0x3c0a\)",
"1089" => "Spanish (Bolivia) \(0x400a\)",
"1090" => "Swedish \(0x41d\)",
"1091" => "Thai \(0x41e\)",
"1092" => "Turkish \(0x41f\)",
"1093" => "Ukrainian \(0x422\)",
"1094" => "Serbian (Latin) \(0x81a\)",
"1095" => "Urdu \(0x420\)",
},
"IgnoreStandardIncludePath" => "IgnoreStandardIncludePath",
{
"1" => "No",
"2" => "Yes \(\/X\)",
},
"ShowProgress" => "ShowProgress",
{
"1" => "No",
"2" => "Yes \(\/v\)",
},
);
# Hash matches vcproj configuration names with their output versions
my(%configurationNames) = ( "Base" => "base",
"DoD" => "dod",
"CounterStrike" => "cstrike",
"HL1" => "hl1",
"HL2" => "hl2",
"Episodic HL2" => "episodic",
"TF" => "tf",
"SDK" => "sdk",
"HL2MP" => "hl2mp",
"LostCoast" => "lostcoast",
"Portal" => "portal",
"Dedicated" => "dedicated",
);
my(@configurations) = keys %configurationNames;
my(%toolNames) = (
"VCCLCompilerTool" => "Compiler",
"VCCustomBuildTool" => "CustomBuildStep",
"VCLinkerTool" => "Linker",
"VCPostBuildEventTool" => "PostBuildEvent",
"VCPreBuildEventTool" => "PreBuildEvent",
"VCPreLinkEventTool" => "PreLinkEvent",
"VCResourceCompilerTool" => "Resources",
"VCLibrarianTool" => "Librarian",
);
my(@tools) = values %toolNames;
my($baseConfiguration) = "Application (.exe)";
my(%baseConfigurationTypes) = (
"Dynamic Library (.dll)" => "dll",
"Application (.exe)" => "exe",
"Static Library (.lib)" => "lib",
"Utility" => "lib",
);
my($configurationSubsystem) = "con";
my(%outputs);
my(%excludes);
my(%filesAdded);
for ( @configurations )
{
$outputs{$_} = ();
$excludes{$_} = 0;
$filesAdded{$_} = 0;
}
my(%keytabs) = ( 0 => "\t\t\t\t\t\t\t\t\t\t",
4 => "\t\t\t\t\t\t\t\t\t",
8 => "\t\t\t\t\t\t\t\t",
12 => "\t\t\t\t\t\t\t",
16 => "\t\t\t\t\t\t",
20 => "\t\t\t\t\t",
24 => "\t\t\t\t",
28 => "\t\t\t",
32 => "\t\t",
36 => "\t",
);
######################################################
# Subroutines
######################################################
sub break
{
return;
}
sub outputToAllConfigurations
{
for ( @configurations )
{
push( @{ $outputs{$_} }, @lineToPrint );
}
}
sub compare_arrays
{
my ($first, $second) = @_;
return 0 unless @$first == @$second;
for (my $i = 0; $i < @$first; $i++)
{
if ( $first->[$i] =~ /^(Debug|Release)$/ )
{
next;
}
return 0 if $first->[$i] ne $second->[$i];
}
return 1;
}
sub set_current_configuration
{
my($line) = shift;
$line =~ ( /Name="(\w+) ([\w\s]*)\|/ );
my($name1) = $1;
my($name2) = $2;
if ( $name2 =~ /Release|Debug/ )
{
$currentConfig = $name1;
}
else
{
$currentConfig = $name2;
}
if ( $line =~ ( /Name="(Release|Debug)\|/ ) )
{
# default configurations
$currentConfig = "Base";
}
}
####################################################
sub processFileConfig
{
$spaceBeforeFile = 1;
my($splitFiles) = 0;
my($line) = $_[++$lineCt];
# Set the current configuration
set_current_configuration( $line );
push( @tabs, "\t" );
$line =~ ( /Name="([\w\s]*)\|/ );
my($configName) = ( $1 =~ /(Debug|Release)/ );
push( @{ $configOutput{$currentConfig} }, @tabs, "\$Configuration\t\"", $configName, "\"\n" );
push( @{ $configOutput{$currentConfig} }, @tabs, "\{\n" );
# Process the configuration
my($configResult) = processConfiguration( @_ );
# end if this configuration
push( @{ $configOutput{$currentConfig} }, @tabs, "\}\n" );
if ( $configResult == 1 )
{
# Mark this file as excluded for the current configuration
$excludes{$currentConfig} = 1;
$splitFiles = 1;
}
elsif ( $configResult == -1 )
{
# Configuration is empty, so clear it
@{ $configOutput{$currentConfig} } = ();
}
pop( @tabs );
return $splitFiles;
}
####################################################
sub processFile
{
# get the file name and path
@lineToPrint = ();
if ( $spaceBeforeFile == 1 )
{
$spaceBeforeFile = 0;
# push( @lineToPrint, "\n" );
}
$_[++$lineCt] =~ ( /RelativePath="([^"]+)"/ );
my $line = $1;
# replace ..\ and .\ in filenames
$line =~ s/^\Q$srcdirBackslash\E\\/\$SRCDIR\\/;
$line =~ s/^\Q$srcdirForwardslash\E\//\$SRCDIR\\/;
$line =~ s/^\.\\//;
push( @lineToPrint, @tabs, "\t\$File\t\"", $line, "\"\n" );
push( @tabs, "\t" );
my($splitFiles) = 0;
my($configFound) = 0;
# loop until the </File> tag
%configOutput = ();
while ( $_[++$lineCt] !~ /^\s*\<\/File\>$/ )
{
# Check for file specific configurations
if ( $_[$lineCt] =~ /^\s*\<FileConfiguration/ )
{
$configFound = 1;
$splitFiles += processFileConfig( @_ );
}
}
# Compare the configurations to see if the files should be split
if ( $configFound && !$splitFiles )
{
for ( @configurations )
{
if ( $_ eq "Base" || $_ eq "Dedicated" )
{
next;
}
if ( !compare_arrays( \@{ $configOutput{"HL2"} }, \@{ $configOutput{$_} } ) )
{
$splitFiles = 1;
last;
}
}
if ( !$splitFiles )
{
push( @{ $configOutput{"Base"} }, @{ $configOutput{"HL2"} } );
}
}
# Add the file and configuration to the appropriate projects
if ( !$splitFiles )
{
if ( @{ $configOutput{"Base"} } > 0 )
{
push( @{ $outputs{"Base"} }, @lineToPrint, @tabs, "\{\n" );
push( @{ $outputs{"Base"} }, @{ $configOutput{"Base"} } );
push( @{ $outputs{"Base"} }, @tabs, "\}\n\n" );
}
else
{
push( @{ $outputs{"Base"} }, @lineToPrint );
}
$filesAdded{"Base"} = 1;
}
else
{
$excludes{"Base"} = 1;
$exclusionsFound = 1;
for ( @configurations )
{
if ( !$excludes{$_} )
{
if ( @{ $configOutput{$_} } > 0 )
{
push( @{ $outputs{$_} }, @lineToPrint, @tabs, "\{\n" );
push( @{ $outputs{$_} }, @{ $configOutput{$_} } );
push( @{ $outputs{$_} }, @tabs, "\}\n\n" );
}
else
{
push( @{ $outputs{$_} }, @lineToPrint );
}
$filesAdded{$_} = 1;
}
else
{
# reset the exclude flag
$excludes{$_} = 0;
}
}
}
pop( @tabs );
}
####################################################
sub processFolder
{
push( @tabs, "\t" );
# Grab the folder name and add it to all configuration's outputs
$_[++$lineCt] =~ ( /Name="([^"]+)"/ );
@lineToPrint = ( @tabs, "\$Folder\t\"", $1, "\"\n", @tabs, "\{\n" );
outputToAllConfigurations();
# Loop until the </Filter> tag
while ( $_[++$lineCt] !~ /^\s*\<\/Filter\>$/ )
{
if ( $_[$lineCt] =~ /^\s*\<Filter$/ )
{
# Start of a new folder
if ( $spaceBeforeFolder == 1 )
{
$spaceBeforeFolder = 0;
@lineToPrint = "\n";
outputToAllConfigurations();
}
processFolder( @_ );
}
elsif ( $_[$lineCt] =~ /^\s*\<File$/ )
{
# Start of a new file
processFile( @_ );
$spaceBeforeFolder = 1;
}
}
# End of the folder
@lineToPrint = ( @tabs, "\}\n" );
for ( @configurations )
{
push( @{ $outputs{$_} }, @lineToPrint );
}
pop( @tabs );
}
####################################################
sub processConfigOption
{
my($line) = shift;
my($tool) = shift;
# Get the keyname and value
if ( $line !~ /(\w+)="([^"\n]*)(.*)/ )
{
return;
}
my($keyname) = $1;
my($keyvalue) = $2;
my($lastChar) = $3;
my($outputvalue);
# Lookup the keyname
if ( $outputvalue = $configOptionsSingleValue{$tool}{$keyname} )
{
# A single value option - outputvalue is the VPC defined keyname
# Translate true/false to Yes/No
$keyvalue =~ s/true/Yes/;
$keyvalue =~ s/false/No/;
$keyname = $outputvalue;
}
elsif ( $outputvalue = $configOptionValues{$keyname}{$keyvalue} )
{
# A multi-value option - outputvalue is the desired option setting in string form
my($translatedName) = $configOptionsMultiValue{$keyname};
# Do some bookkeeping for later
if ( $translatedName =~ /^SubSystem$/ && $outputvalue =~ /Windows/ )
{
$configurationSubsystem = "win";
}
elsif ( $translatedName =~ /^ConfigurationType$/ )
{
$baseConfiguration = $outputvalue;
}
if ( $usestring )
{
return $translatedName, $outputvalue;
}
else
{
return $translatedName, $keyvalue;
}
}
else
{
# For debugging
print( "Line ", $lineCt, ": Error, no config found for Tool: ", $tool, ", ", $keyname, "=", $keyvalue, "\n" );
# push( @tempOutput, "\/\/" );
}
# special handling for multi-line options
if ( !$lastChar )
{
my($nextline) = ( @lines[++$lineCt] =~ /([^\n]*)/ );
while( $nextline !~ /\"/ )
{
$keyvalue = join( '', $keyvalue, "\" \\ \"\\n\"\n", @tabs, $keytabs{0}, "\"", $nextline );
($nextline) = ( @lines[++$lineCt] =~ /([^\n]*)/ );
}
}
# replace &quot; and ..\ and .\ in option values
$keyvalue =~ s/(?<=[^\\])\Q$srcdirBackslash\E\\/\$SRCDIR\\/g;
$keyvalue =~ s/(?<=[^\/])\Q$srcdirForwardslash\E\//\$SRCDIR\\/g;
$keyvalue =~ s/^\Q$srcdirBackslash\E\\/\$SRCDIR\\/g;
$keyvalue =~ s/^\Q$srcdirForwardslash\E\//\$SRCDIR\\/g;
$keyvalue =~ s/^\.\\//g;
$keyvalue =~ s/\&quot\;/\$QUOTE/g;
return $keyname, $keyvalue;
}
####################################################
sub processBuildTool
{
push( @tabs, "\t" );
# Grab the tool name
$_[++$lineCt] =~ ( /Name="([^"]+)"/ );
my($toolName) = $1;
if ( !$toolNames{$toolName} )
{
pop( @tabs );
while ( $_[$lineCt] !~ /\/\>$/ )
{
++$lineCt;
}
return;
}
my( @tempOutput );
if ( !$parsingFiles )
{
push( @tempOutput, "\n" );
}
push( @tempOutput, @tabs, "\$", $toolNames{$toolName}, "\n" );
push( @tempOutput, @tabs, "\{\n" );
# Loop until the /> tag
my($keyname);
my($keyvalue);
my($optionsFound) = 0;
while ( $_[$lineCt] !~ /\/\>$/ )
{
($keyname, $keyvalue) = processConfigOption( $_[++$lineCt], $toolName );
if ( $keyname )
{
if ( $keyvalue || !$stripEmptyOptions )
{
$optionsFound = 1;
}
my($len) = $tabstop * int( (length( $keyname ) + $tabstop + 1) / $tabstop );
push( @tempOutput, @tabs, "\t\$", $keyname, $keytabs{$len}, "\"", $keyvalue, "\"\n" );
}
}
pop( @tabs );
# End of the tool
if ( $optionsFound )
{
push( @{ $configOutput{$currentConfig} }, @tempOutput, @tabs, "\t}\n" );
return 1;
}
return 0;
}
####################################################
sub processConfiguration
{
my( $configOptionsFound ) = 0;
my( $startedGeneral ) = 0;
# Loop until the </Configuration> tag
while ( $_[++$lineCt] !~ /^\s*\<\/(File)*Configuration\>$/ )
{
if ( $_[$lineCt] =~ /^\s*\<Tool$/ )
{
if ( $startedGeneral )
{
# close out the faked "General" category
$startedGeneral = 0;
push( @{ $configOutput{$currentConfig} }, @tabs, "\}\n" );
pop( @tabs );
}
# Start of a new build tool
$configOptionsFound += processBuildTool( @_ );
}
elsif ( $_[$lineCt] =~ /=/ )
{
# Process the main configuration properties
if ( !$startedGeneral && !$parsingFiles )
{
# start the fake "General" category
$startedGeneral = 1;
push( @tabs, "\t" );
push( @{ $configOutput{$currentConfig} }, @tabs, "\$General\n" );
push( @{ $configOutput{$currentConfig} }, @tabs, "\{\n" );
}
my($keyname);
my($keyvalue);
($keyname, $keyvalue) = processConfigOption( $_[$lineCt], "General" );
if ( $keyname )
{
# Handle some special cases
if ( $keyname =~ /^ExcludedFromBuild$/ && $keyvalue =~ /^Yes$/ )
{
@{ $configOutput{$currentConfig} } = ();
return 1;
}
++$configOptionsFound;
my($len) = $tabstop * int( (length( $keyname ) + $tabstop + 1) / $tabstop );
push( @{ $configOutput{$currentConfig} }, @tabs, "\t\$", $keyname, $keytabs{$len}, "\"", $keyvalue, "\"\n" );
}
}
}
# See if any config options were recorded
if ( !$configOptionsFound )
{
return -1;
}
return 0;
}
######################################################
# Code section
######################################################
if ( !$ARGV[0] )
{
print( "Error: no project name specified\n" );
exit;
}
# Read in the source file
my $infile = $ARGV[0];
$infile =~ s/.vcproj//;
open(INFILE, "$infile.vcproj" );
@lines = <INFILE>;
close( INFILE );
my(@pathArray) = split(/\\/, $infile );
my($vcprojname) = $pathArray[$#pathArray];
unless ( $outputPath )
{
$outputPath = $infile;
$outputPath =~ s/$vcprojname//;
}
# build the fileheader
my(@fileheader);
push( @fileheader, "\/\/-----------------------------------------------------------------------------\n" );
push( @fileheader, "\/\/\t",uc($vcprojname),".VPC\n" );
push( @fileheader, "\/\/\n" );
push( @fileheader, "\/\/\tProject Script\n" );
push( @fileheader, "\/\/-----------------------------------------------------------------------------\n" );
push( @fileheader, "\/\/ ***** AUTO-GENERATED: PLEASE FIXUP MANUALLY BEFORE USING THIS SCRIPT! *****\n" );
push( @fileheader, "\n" );
push( @fileheader, "\$Macro SRCDIR\t\t\".." );
$srcdirBackslash = "..";
my($dirct) = $#pathArray - 2;
for ( my($i) = 0; $i < $dirct; ++$i )
{
push( @fileheader, "\\.." );
$srcdirBackslash = join( "\\", $srcdirBackslash, ".." );
}
$srcdirForwardslash = $srcdirBackslash;
$srcdirForwardslash =~ s/\\/\//g;
push( @fileheader, "\"\n" );
# Process the file one line at a time
my $folderOpenBrace = 0;
for( $lineCt = 0; $lineCt < @lines; ++$lineCt )
{
my($line) = @lines[$lineCt];
if ( !$nameFound && $line =~ ( /Name="([^"]+)"/ ) )
{
$projectName = $1;
# Print the project name
my $capName = $projectName;
$capName =~ s/\b(\w)/\U$1/g;
@lineToPrint = ( "\$Project \"", $capName, "\"\n\{\n" );
for ( @configurations )
{
push( @{ $outputs{$_} }, @lineToPrint );
}
$nameFound = 1;
$folderOpenBrace = 1;
# Clean up the directory
# for ( @configurations )
# {
# # delete the existing files
# my($filename) = join('_', $vcprojname, $configurationNames{$_} );
# if( $outputPath )
# {
# $filename = join('/', $outputPath, $filename );
# $filename =~ s/\//\\/g;
# }
# system( "del /Q $filename.vpc" );
# }
}
if ( $line =~ /^\s*\<Configuration$/ )
{
# Start of a new configuration
# Get the configuration name and then process the configuration
my($configLine) = @lines[++$lineCt];
set_current_configuration( $configLine );
$configLine =~ ( /Name="([\w\s]*)\|/ );
my($configName) = ( $1 =~ /(Debug|Release)/ );
$currentConfig = join( '_', $currentConfig, $configName );
push( @{ $configOutput{$currentConfig} }, "\$Configuration\t\"", $configName, "\"\n" );
push( @{ $configOutput{$currentConfig} }, "\{\n" );
processConfiguration( @lines );
# end if this configuration
push( @{ $configOutput{$currentConfig} }, "\}\n\n" );
}
elsif ( $line =~ /^\s*\<Files\>$/ )
{
# end of configurations section - write out the files
# first, finish filling in the header info
my($configtype) = $baseConfigurationTypes{$baseConfiguration};
if ( $configtype =~ /lib/ )
{
push( @fileheader, "\$Macro OUTLIBDIR\t\"\$SRCDIR\\lib\\XXXX\"\n" );
}
else
{
push( @fileheader, "\$Macro OUTBINDIR\t\"\$SRCDIR\\..\\game\\bin\"\n" );
}
push( @fileheader, "\n" );
push( @fileheader, "\$Include \"\$SRCDIR\\vpc_scripts\\source_" );
push( @fileheader, $configtype );
if ( $configtype =~ /exe/ )
{
push( @fileheader, "_", $configurationSubsystem );
}
push( @fileheader, "_win32_base.vpc\"\n" );
# push( @fileheader, "_win32_base.vpc\"\t\[\$WIN32\|\|\$LINUX\]\n" );
# push( @fileheader, "\$Include \"\$SRCDIR\\vpc_scripts\\source_" );
# push( @fileheader, $configtype );
# push( @fileheader, "_x360_base.vpc\"\t\t\[\$X360\]\n" );
push( @fileheader, "\n" );
for ( @configurations )
{
my $joinedname = join( '_', $_, "Debug" );
# print the configs
if ( @{ $configOutput{$joinedname} } > 0 )
{
my($filename) = join('_', $vcprojname, $configurationNames{$_} );
if( $outputPath )
{
$filename = join('/', $outputPath, $filename );
}
open ( OUTFILE, ">$filename.vpc" );
print OUTFILE @fileheader;
print OUTFILE @{ $configOutput{$joinedname} };
$joinedname = join( '_', $_, "Release" );
print OUTFILE @{ $configOutput{$joinedname} };
close ( OUTFILE );
}
}
$parsingFiles = 1;
}
elsif ( $line =~ /^\s*\<Filter$/ )
{
# Start of a new folder
if ( $spaceBeforeFolder == 1 )
{
$spaceBeforeFolder = 0;
for ( @configurations )
{
push( @{ $outputs{$_} }, "\n" );
}
}
processFolder( @lines );
}
elsif ( $line =~ /^\s*\<File$/ )
{
# Start of a new file
if ( $spaceBeforeFolder == 1 )
{
$spaceBeforeFolder = 0;
for ( @configurations )
{
push( @{ $outputs{$_} }, "\n" );
}
}
processFile( @lines );
}
}
my $projectCt = 0;
for ( @configurations )
{
push( @{ $outputs{$_} }, "\}\n" );
if ( $filesAdded{$_} )
{
++$projectCt;
# print the files
my($filename) = join('_', $vcprojname, $configurationNames{$_} );
if( $outputPath )
{
$filename = join('/', $outputPath, $filename );
}
open ( OUTFILE, ">>$filename.vpc" );
print OUTFILE @{ $outputs{$_} };
close ( OUTFILE );
}
}
if ( $projectCt == 1 )
{
my $oldname = join('_', $vcprojname, "base.vpc" );
my $newname = join('', $vcprojname, ".vpc" );
if( $outputPath )
{
$oldname = join('/', $outputPath, $oldname );
$newname = join('/', $outputPath, $newname );
}
rename $oldname, $newname;
}