@ECHO OFF
REM :: 
REM :: WDK build/package/distribution script
REM :: Written by Travis Robinson - 12/20/2010
REM ::

SET /A MAKE_RUN_COUNT=MAKE_RUN_COUNT+1
SETLOCAL ENABLEEXTENSIONS ENABLEDELAYEDEXPANSION

SET BUILD_ERRORLEVEL=0
SET WOUND_GUID=B49955DF-0623-4b65-A6E3-B5A91F3D2CFB
SET CreateTempFileList=

REM :: REQUIRED dependency - DOSCMD  
IF NOT DEFINED DCMD (
	SET MAKE_CMD_PATH=%~dp0
	PUSHD %CD%
	CD /D "!MAKE_CMD_PATH!"
	FOR /F "usebackq eol=; tokens=* delims=" %%D IN (`dir /A-D /B /S "doscmd.exe" "!MAKE_CMD_PATH!\doscmd.exe"`) DO IF NOT DEFINED DCMD SET DCMD=%%~D
	IF NOT DEFINED DCMD CALL :FindFileInPath DCMD doscmd.exe
	POPD
	IF DEFINED DCMD (
		REM - doscmd needs added to the path to work properly as a command in a for loop; this change is temporary
		CALL :PathSplit "!DCMD!"
		SET G_DOSCMD_DIR=!_DIR_!
		CALL :TrimExR "\" G_DOSCMD_DIR
		SET PATH=!G_DOSCMD_DIR!;!PATH!
		SET DCMD=doscmd.exe
		IF "!MAKE_RUN_COUNT!" EQU "1" !DCMD! --version
	) ELSE (
		ECHO DOSCMD not found.  DOSCMD is required for the WDK build process.
		GOTO :EOF
	)
)

REM :: START OF PRE/INIT SECTION ---------------------------------------
IF "%~1" NEQ "!WOUND_GUID!" (
	REM - first set the default 
	SET G_MAKE_CFG_FILE=!CD!\make.cfg
	IF NOT EXIST "!G_MAKE_CFG_FILE!" SET G_MAKE_CFG_FILE=%~dp0\make.cfg
	
	REM - Arguments are loaded twice so you can pass "MAKE_CFG_FILE=yourdir\yourmakefile.cfg"
	REM - load arguments
	CALL :ArgumentsToEnv 1 %*

	IF NOT EXIST "!G_MAKE_CFG_FILE!" (
		CALL :Print E "MAKCFG" "Configuration file not found.\n\tFile: @s\n\tA configuration file located at the root of your WDK 'sources' tree is required." "!G_MAKE_CFG_FILE!"
		GOTO DoneWithErrors
	)
	
	REM - Make sure the current dir is the directory of the cfg file.
	CALL :PathSplit "!G_MAKE_CFG_FILE!"
	SET MAKE_ORGINAL_WORKING_DIR=!CD!
	PUSHD "!CD!"
	IF /I "!CD!" NEQ "!_DIR_!" CD /D "!_DIR_!"
	SET _MAKE_DIR_=!_DIR_!
	
	REM - load config file
	CALL :LoadCfgFile "!G_MAKE_CFG_FILE!"
	IF !BUILD_ERRORLEVEL! NEQ 0 GOTO DoneWithErrors

	REM - load arguments [arguments always override]
	CALL :ArgumentsToEnv 1 %*
	IF !BUILD_ERRORLEVEL! NEQ 0 GOTO DoneWithErrors
	
	REM - If the dist arg was specified, build all platforms/archs listed in the DIST_BUILD_LIST env var.
	IF DEFINED G_DIST (

		IF NOT EXIST "!G_PACKAGE_DIR!" MKDIR "!G_PACKAGE_DIR!"
		CALL :ToAbsPath  G_PACKAGE_ABS_DIR "!G_PACKAGE_DIR!"
		
		IF NOT EXIST "!G_PACKAGE_TEMP_DIR!" MKDIR "!G_PACKAGE_TEMP_DIR!"
		CALL :ToAbsPath  G_PACKAGE_TEMP_ABS_DIR "!G_PACKAGE_TEMP_DIR!"

		REM - default to a FRE build if none was specified.
		IF "!G_FRE!!G_CHK!" EQU "" SET G_FRE=FRE
		CALL :ExecuteUserTask pre dist
		
		FOR /F "usebackq eol=; tokens=* delims=" %%K IN (`!DCMD! "-sp=;" "!G_DIST_BUILD_LIST!"`) DO (
			SET DIST_PLAT=%%~K
			CALL :Trim DIST_PLAT
			IF "!DIST_PLAT!" NEQ "" (
				ECHO DIST:!DIST_PLAT!
				CALL :SafeCMD %0 !WOUND_GUID! build !DIST_PLAT!
				IF DEFINED G_VERSION SET G_VERSION=
				IF !BUILD_ERRORLEVEL! NEQ 0 GOTO DoneWithErrors
			)
		)
		CALL :ExecuteUserTask post dist

	) ELSE (
		CALL :SafeCMD make.cmd !WOUND_GUID!
		IF !BUILD_ERRORLEVEL! NEQ 0 GOTO DoneWithErrors
	)
	
	:DoneWithErrors
	:DoneWithSuccess
	
	REM - This script makes heavy use of temp files.  If you CTRL-C it there will
	REM - be several temp files abandoned in the TEMP dir.
	CALL :DestroyAllTempFiles
	POPD
	
	GOTO :EOF
)

REM :: END OF PRE/INIT SECTION -----------------------------------------
REM :: START OF MAIN SECTION -------------------------------------------

	REM - load the arguments. this will include arguments that may have been passed
	REM - into make.cmd after it is wound. see the dist command above.
	CALL :ArgumentsToEnv 2 %*
	IF !BUILD_ERRORLEVEL! NEQ 0 GOTO Processing_Done

	REM - When a command is executed with SafeCMD it sets E_RET_FILE to a temp file
	REM - which is checked for an error code after the command completes.
	IF DEFINED G_E_RET_FILE SET E_SND_FILE=!G_E_RET_FILE!

	REM - add env option vars to WDK_ENV_OPTIONS [only ones explicitly passed by the user]

	CALL :AddIfDef WDK_ENV_OPTIONS G_FRE G_CHK G_64 G_X64 G_WIN7 G_WLH G_WXP G_WNET G_W2K

	REM - if none were defined, use the default build options.
	IF NOT DEFINED WDK_ENV_OPTIONS SET WDK_ENV_OPTIONS=!G_WDK_DEF_ENV_OPTIONS!
	
	CALL :AddIfDef WDK_ENV_OPTIONS G_NO_OACR

	REM - Check if any commands are defined
	SET __CHECK_CMD=
	CALL :AddIfDef __CHECK_CMD G_HELP G_FORMATCODE G_CLEAN G_BUILD G_VERSION G_ZIP

	REM - If no commands are defined, show the help.
	IF NOT DEFINED __CHECK_CMD SET G_HELP=help

	REM - call the commands that are defined; in this order.
	IF DEFINED G_HELP CALL :ShowUsage !G_HELP!
	IF DEFINED G_VERSION CALL :Version !G_VERSION!
	IF DEFINED G_FORMATCODE CALL :FormatCode !G_FORMATCODE!
	IF DEFINED G_CLEAN CALL :Clean !G_CLEAN!
	IF DEFINED G_BUILD CALL :Build !G_BUILD!
	IF DEFINED G_ZIP CALL :Zip !G_ZIP!
 
	:Processing_Done
	CALL :DestroyAllTempFiles

GOTO :EOF

REM :: END OF MAIN SECTION ---------------------------------------------
REM :: START OF COMMAND SECTION ----------------------------------------

:Version
	Call :PathSplit "!G_MAKE_CFG_FILE!"
	SET __Version_File=!_DIR_!!_FILE_!.versions
	IF NOT EXIST "!__Version_File!" GOTO Version_Done

	FOR /F "usebackq eol=; tokens=1,2,3,4 delims=;" %%A IN ('!G_VERSION!') DO (
		SET __VERSION_TARGET_NAME=%%~A
		SET __VERSION_TARGET_ACTION=%%~B
		SET __VERSION_TARGET_ACTION_OPTION=%%~C
		SET __VERSION_TARGET_ACTION_OPTION_VALUE=%%~D
		GOTO Version_Lookup
	)
	GOTO Version_NotFound

	:Version_Lookup
	CALL :VersionLookup "!__VERSION_TARGET_NAME!" "!__Version_File!"
	IF "!VersionLookup!" EQU "1" GOTO Version_Found

	:Version_NotFound:
	CALL :Print D "VERCTL" "Failed location version information for @s in @s." "%~1" "!__Version_File!"
	GOTO Version_Done

	:Version_Found:
	CALL :OutputToFile T __Version_Line @NULL FINDSTR /I /N /R /C:"^[ ]*!TARGET_VERSION_NAME![ ]*=" !__Version_File!
	IF NOT DEFINED __Version_Line_Error FOR /F "eol=; tokens=1 delims=:" %%A IN (!__Version_Line!) DO IF NOT DEFINED __VERSION_TARGET_LINE SET __VERSION_TARGET_LINE=%%~A
	CALL :Print D "VERCTL" "verson line = @s (@s), target = @s, version = @s\n\tin-file = @s\n\tout-file = @s" "!__VERSION_TARGET_LINE!" "!TARGET_VERSION_NAME!" "!TARGET_VERSION_LINK_NAME!" "!TARGET_VERSION!" "!TARGET_VERSION_IN_FILE!" "!TARGET_VERSION_OUT_FILE!"

	REM - a linked target can't change the version info; this is a safety feature
	IF /I "!TARGET_VERSION_NAME!" EQU "!TARGET_VERSION_LINK_NAME!" (
		IF NOT DEFINED __VERSION_TARGET_ACTION_OPTION SET __VERSION_TARGET_ACTION_OPTION=NANO
		IF /I "!__VERSION_TARGET_ACTION!" EQU "inc" SET __VER_ADD_AMT=+1
		IF /I "!__VERSION_TARGET_ACTION!" EQU "dec" SET __VER_ADD_AMT=-1
		IF /I "!__VERSION_TARGET_ACTION!" EQU "set" SET __VER_ADD_AMT=set
		IF NOT DEFINED TARGET_VERSION_!__VERSION_TARGET_ACTION_OPTION! (
			CALL :Print E "VERCTL" "Invalid version action option @s." "!__VERSION_TARGET_ACTION_OPTION!"
			GOTO Version_Done
		)
		IF "!__VER_ADD_AMT!" EQU "set" (
			SET /A TARGET_VERSION_!__VERSION_TARGET_ACTION_OPTION!=__VERSION_TARGET_ACTION_OPTION_VALUE
		) ELSE (
			SET /A TARGET_VERSION_!__VERSION_TARGET_ACTION_OPTION!=TARGET_VERSION_!__VERSION_TARGET_ACTION_OPTION!!__VER_ADD_AMT!
		)
		CALL :OutputToFile T __Version_NewLine @NULL ECHO !TARGET_VERSION_LINK_NAME! = !TARGET_VERSION_MAJOR!.!TARGET_VERSION_MINOR!.!TARGET_VERSION_MICRO!.!TARGET_VERSION_NANO!; !TARGET_VERSION_IN_FILE!; !TARGET_VERSION_OUT_FILE!;
		SET /A __VERSION_TARGET_LINE=__VERSION_TARGET_LINE-1
		CALL :CreateTempFile __Version_NewFile
		!DCMD! -fl=!__VERSION_TARGET_LINE!;update; "!__Version_File!" "!__Version_NewFile!" "!__Version_NewLine!"
		IF EXIST "!__Version_NewFile!" (
			CALL :PathSplit "!__Version_NewFile!"
			IF "!_FILESIZE_!" GTR "12" (
				COPY /Y "!__Version_NewFile!" "!__Version_File!" 2>NUL>NUL
				IF "!ERRORLEVEL!" NEQ "0" GOTO Version_Error
				SET TARGET_VERSION=!TARGET_VERSION_MAJOR!.!TARGET_VERSION_MINOR!.!TARGET_VERSION_MICRO!.!TARGET_VERSION_NANO!
				CALL :Print S "VERCTL" "@s version changed to @s" "!TARGET_VERSION_NAME!" "!TARGET_VERSION!"
				GOTO Version_Done
			)
		)
		GOTO Version_Error
	)
	GOTO Version_Done
	
	:Version_Error
	CALL :Print E "VERCTL" "Unable to locate target @s in version file @s." "!__VERSION_TARGET_NAME! " "!__Version_File!"
	GOTO Version_Done
	
	:Version_Done
	CALL :Undefine __VERSION* __CHECK_NAME TARGET_VERSION_NAME __VER_ADD_AMT
GOTO :EOF

REM - %~1 = version string i.e '1.2.3.4'
REM - [SETS] TARGET_VERSION; TARGET_VERSION_MAJOR; TARGET_VERSION_MINOR; TARGET_VERSION_MICRO; TARGET_VERSION_NANO;
:VersionStringParse
	SET __VersionStringParse=%~1
	FOR /F "eol=; tokens=1,2,3,4 delims=.;" %%A IN ("!__VersionStringParse!") DO (
		SET TARGET_VERSION_MAJOR=%%A
		SET TARGET_VERSION_MINOR=%%B
		SET TARGET_VERSION_MICRO=%%C
		SET TARGET_VERSION_NANO=%%D
		CALL :Trim TARGET_VERSION_MAJOR TARGET_VERSION_MINOR TARGET_VERSION_MICRO TARGET_VERSION_NANO
	)
	SET __VersionStringParse=
GOTO :EOF

REM - %1 = version target name to look for
REM - %2 = version file to look in
REM - [SETS] TARGET_VERSION_LINK_NAME; TARGET_VERSION_NAME; TARGET_VERSION_IN_FILE; TARGET_VERSION_OUT_FILE; 
REM - [SETS] TARGET_VERSION; TARGET_VERSION_MAJOR; TARGET_VERSION_MINOR; TARGET_VERSION_MICRO; TARGET_VERSION_NANO;
REM - [SETS] __Version_Line to a filename with the [REAL] matched version record
REM - [RETURNS] VersionLookup = 1 if found, 0 if not
:VersionLookup
	CALL :Undefine TARGET_VERSION_LINK_NAME TARGET_VERSION TARGET_VERSION_MAJOR TARGET_VERSION_MINOR TARGET_VERSION_NANO
	SET TARGET_VERSION_NAME=%~1
	:VersionLookup_Link
	CALL :OutputToFile T __Version_Line @NULL FINDSTR /I /R /C:"^[ ]*!TARGET_VERSION_NAME![ ]*=" %~2
	FOR /F "eol=; tokens=1,2,3 delims=;" %%A IN (!__Version_Line!) DO (
		FOR /F "usebackq eol=; tokens=1,2 delims==" %%E IN ('%%~A') DO (
			IF NOT DEFINED TARGET_VERSION_LINK_NAME (
				SET TARGET_VERSION_LINK_NAME=%%~E
				
				REM - add new columns to the versions file here
				REM - modify the %%A FOR loop tokens [1,2,3,etc] as you add columns
				SET TARGET_VERSION_IN_FILE=%%~B
				SET TARGET_VERSION_OUT_FILE=%%~C
				CALL :Trim TARGET_VERSION_LINK_NAME TARGET_VERSION_IN_FILE TARGET_VERSION_OUT_FILE
			)				
			SET TARGET_VERSION_NAME=%%~E
			SET __CHECK_NAME=%%~F
			CALL :Trim TARGET_VERSION_NAME __CHECK_NAME
		)
		REM - If this is a linked version line, the 'version' field is the linked name.
		FINDSTR /I /R /C:"^[ ]*!__CHECK_NAME![ ]*=" %~2 2>NUL>NUL
		IF "!ERRORLEVEL!" NEQ "1" (
			CALL :Print D "VERCTL" "looking up linked version name for @s.." "!TARGET_VERSION_NAME!"
			SET TARGET_VERSION_NAME=!__CHECK_NAME!
			GOTO VersionLookup_Link
		)
		SET TARGET_VERSION=!__CHECK_NAME!
		CALL :VersionStringParse !TARGET_VERSION!
		IF DEFINED TARGET_VERSION_NANO GOTO VersionLookup_Found
		GOTO VersionLookup_NotFound
	)
	:VersionLookup_NotFound
	SET VersionLookup=0
	CALL :Undefine TARGET_VERSION*
	GOTO :EOF

	:VersionLookup_Found
	SET VersionLookup=1
GOTO :EOF

:FormatCode
	IF NOT EXIST "!G_FORMATCODE_EXE!" (
		SET AskYesNo_Default=1
		CALL :AskYesNo "\k0F@s not found. Look for it in path?" "!G_FORMATCODE_EXE!"
		IF NOT !AskYesNo! EQU 1 GOTO :EOF 
		SET __FORMATCODE_EXE=!G_FORMATCODE_EXE!
		CALL :FindFileInPath G_FORMATCODE_EXE "!G_FORMATCODE_EXE!"
		IF NOT EXIST "!G_FORMATCODE_EXE!" (
			CALL :Print E "FMTCOD" "Failed locating @s in path\r\n\t\k0ADownload Astyle at astyle.sourceforge.net" "!__FORMATCODE_EXE!"
			CALL :Print "FMTCOD" "make.cmd looks for optional programs in the path and the 'build_tools' sub-dir."
			GOTO :EOF
		) ELSE (
			CALL :Print S "FMTCOD" "Updating @s\n\twith FORMATCODE_EXE=@s" "!G_MAKE_CFG_FILE!" "!G_FORMATCODE_EXE!"
			!DCMD! --update-cfg=FORMATCODE_EXE "!G_MAKE_CFG_FILE!" "!G_FORMATCODE_EXE!"
		)
	)
	FOR /F "usebackq eol=; tokens=* delims=" %%K IN (`!DCMD! "-sp=;" "!G_FORMATCODE_ARGS!"`) DO (
		"!G_FORMATCODE_EXE!" %%K
		IF NOT "!ERRORLEVEL!" EQU "0" (
			CALL :SetError 1
			CALL :Print E "ERROR" "FormatCode failed: @s @s" "!G_FORMATCODE_EXE!" "%%~K"
			GOTO :EOF
		)
	)

GOTO :EOF

:Clean
	CALL :Print "CLEAN" "Cleaning targets and temporary files.."

	CALL :DefineDefaultDirEscapes __Clean_
	CALL :CreateTempFile __Clean_AllDirList
	CALL :CreateTempFile __Clean_AllFileList
	
	IF /I "!G_CLEAN!" EQU "" SET G_CLEAN=all;
	IF /I "!G_CLEAN!" EQU "clean" SET G_CLEAN=all;
	
	CALL :ExecuteUserTask pre clean
	
	FOR /F "usebackq eol=; tokens=1 delims=" %%A IN (`!DCMD! "-sp=;" "!G_CLEAN!"`) DO (
		SET __CLEAN_SET=%%~A
		CALL :Trim __CLEAN_SET
		CALL :Clean_!__CLEAN_SET!
	)
	
	REM - Even if there is nothing to clean both a dir and file list will exists with 0 bytes.
	IF NOT EXIST "!__Clean_AllDirList!" (
		CALL :Print E "CLEAN" "Invalid clean option@s." " !G_CLEAN!"
	) ELSE (
		CALL :RemoveList dir __Clean_AllDirList
		CALL :RemoveList file __Clean_AllFileList
	)
	
	CALL :Undefine __Clean_*
	CALL :ExecuteUserTask post clean
GOTO :EOF

	:Clean_Full
		attrib -H /S *.suo > NUL
		CALL :Clean_All
		REM - Remove the entire output directory on a full clean
		ECHO !__Clean_BuildOutputDirRel!>>!__Clean_AllDirList!
		IF EXIST "!G_PACKAGE_TEMP_DIR!\*" DEL /S /Q "!G_PACKAGE_TEMP_DIR!\*"
	GOTO :EOF
	
	:Clean_All
		CALL :Clean_Src
		CALL :Clean_Bin
	GOTO :EOF
	
	:Clean_Bin
	:Clean_Output
	CALL :SyncPathList D __Clean_AllDirList  "!G_BUILD_OUTPUT_BASE_DIR!" "/AD-H-R-S /S"  G_CLEAN_BIN_EXP "/I" @NULL ""
	CALL :SyncPathList F __Clean_AllFileList "!G_BUILD_OUTPUT_BASE_DIR!" "/A-D-H-R-S /S" G_CLEAN_BIN_EXP "/I" @NULL ""
	GOTO :EOF
	
	:Clean_Src
	:Clean_Source
	REM - Src uses a 'final' exclude expression so as not to tamper with the output dir.
	CALL :CreateTempFile __Clean_RegExpExcludeList
	!DCMD! -ff "!__Clean_RegExpExcludeList!" "@s\n@s\n" "!__Clean_BuildOutputDirEsc!" "!__Clean_PackageDirEsc!"
	CALL :SyncPathList D __Clean_AllDirList  "!CD!" "/AD-H-R-S /S"  G_CLEAN_SRC_EXP "/I" __Clean_RegExpExcludeList "/I /V"
	CALL :SyncPathList F __Clean_AllFileList "!CD!" "/A-D-H-R-S /S" G_CLEAN_SRC_EXP "/I" __Clean_RegExpExcludeList "/I /V"
	GOTO :EOF
GOTO :EOF


:Zip
	IF NOT EXIST "!G_PACKAGE_DIR!" MKDIR "!G_PACKAGE_DIR!"
	IF NOT EXIST "!G_PACKAGE_DIR!" (
		CALL :SetError 1
		CALL :Print E "ZIP" "Failed creating package directory @s.\n\tCheck the PACKAGE_DIR setting in make.cfg." "!G_PACKAGE_DIR!"
		GOTO :EOF
	)
	SET __Zip_TempDir=!TEMP!\Zip_Temp_%RANDOM%

	CALL :DefineDefaultDirEscapes __Zip_
	
	SET __Zip_FileCount=0

	IF /I "!G_ZIP!" EQU "" SET G_ZIP=all;
	IF /I "!G_ZIP!" EQU "zip" SET G_ZIP=all;
	
	SET __Zip_TempDir=!TEMP!\Zip_Temp_%RANDOM%
	
	Call :PathSplit "!G_MAKE_CFG_FILE!"
	SET __Version_File=!_DIR_!!_FILE_!.versions
	CALL :VersionLookup "PACKAGE" "!_DIR_!!_FILE_!.versions"
	IF "!VersionLookup!" EQU "1" (
		SET F_PACKAGE_VERSION=!TARGET_VERSION!
		CALL :LoadCfgFile "!G_MAKE_CFG_FILE!" PACKAGE
	)
	
	CALL :ExecuteUserTask pre zip
	
	FOR /F "usebackq eol=; tokens=1 delims=" %%A IN (`!DCMD! "-sp=;" "!G_ZIP!"`) DO (
		SET __Zip_UserOption=%%~A
		CALL :Trim __Zip_UserOption
		CALL :Zip_!__Zip_UserOption!
	)
	
	IF "!__Zip_FileCount!" EQU "0" GOTO Zip_Error
	IF NOT EXIST "!__Zip_TempDir!" GOTO Zip_Error
	
	CALL :LoadCfgFile "!G_MAKE_CFG_FILE!" PACKAGE_NAME_FORMAT
	
	SET __Zip_AbsFilename=!__Zip_PackageDir!\!G_PACKAGE_NAME_FORMAT!.!G_PACKAGE_ZIP_EXT!
	IF EXIST "!__Zip_AbsFilename!" DEL /Q "!__Zip_AbsFilename!"

	SET __Zip_Cmd=7z.exe
	!__Zip_Cmd! 2>NUL>NUL
	IF "!ERRORLEVEL!" NEQ "0" (
		SET __Zip_Cmd=7za.exe
		!__Zip_Cmd! 2>NUL>NUL
	)
	IF "!ERRORLEVEL!" NEQ "0" (
		CALL :Print E "ZIP" "7z.exe not found.\n\tDownload 7Zip at @s." "www.7-zip.org"
		CALL :Print "ZIP" "make.cmd looks for optional programs in the path and the 'build_tools' sub-dir."
		GOTO Zip_Done
	)
	
	PUSHD !CD!
	CD /D !__Zip_TempDir!
	CALL :SafeCall !__Zip_Cmd! a -mx9 -r "!__Zip_AbsFilename!" *
	POPD

	IF "!BUILD_ERRORLEVEL!" NEQ "0" GOTO Zip_Error
	CALL :Print S "ZIP" "Done\x21 @s (@d files)" "!__Zip_AbsFilename!" "!__Zip_FileCount!"
	GOTO Zip_Done
	
	:Zip_Error
	CALL :Print E "ZIP" "Invalid zip option@s or other failure.\n\tUse the 'build_quiet=0' argument for more information." " !G_ZIP!"
	CALL :Print "ZIP" "make.cmd looks for optional programs in the path and the 'build_tools' sub-dir."
	
	:Zip_Done
	IF EXIST "!__Zip_TempDir!" RMDIR /S /Q "!__Zip_TempDir!"	
	CALL :Undefine __Zip_*
	CALL :ExecuteUserTask post zip
GOTO :EOF

	:Zip_All
		SET F_PACKAGE_NAME=!G_PACKAGE_ALL_NAME!
		CALL :LoadCfgFile "!G_MAKE_CFG_FILE!" PACKAGE_ALL_SUBDIR_FORMAT
		SET __Zip_TempDir=!__Zip_TempDir!\!G_PACKAGE_ALL_SUBDIR_FORMAT!
		CALL :Zip_Src "!G_PACKAGE_SRC_NAME!"
		CALL :Zip_Package "@NONE@"
	GOTO :EOF
	
	:Zip_Bin
	:Zip_Output
	IF NOT EXIST "!G_BUILD_OUTPUT_BASE_DIR!" (
		CALL :Print W "ZIP" "Base output directory @s does not exist." "!G_BUILD_OUTPUT_BASE_DIR!"
		GOTO :EOF
	)
	CALL :CreateTempFile __Zip_FileList
	CALL :SyncPathList F __Zip_FileList "!G_BUILD_OUTPUT_BASE_DIR!" "/A-D-H-R-S /S" G_CLEAN_BIN_EXP "/I /V" @NULL ""
	
	SET F_PACKAGE_NAME=!G_PACKAGE_BIN_NAME!
	CALL :LoadCfgFile "!G_MAKE_CFG_FILE!" PACKAGE_NAME_FORMAT

	IF "%~1" NEQ "" (
		CALL :ZipAddFileSet "!__Zip_TempDir!\%~1\!G_BUILD_OUTPUT_BASE_DIR!" "!G_BUILD_OUTPUT_BASE_DIR!" __Zip_FileList __Zip_FileCount
	) ELSE (
		CALL :ZipAddFileSet "!__Zip_TempDir!\!G_PACKAGE_NAME_FORMAT!\!G_BUILD_OUTPUT_BASE_DIR!" "!G_BUILD_OUTPUT_BASE_DIR!" __Zip_FileList __Zip_FileCount
	)
	GOTO :EOF
	
	:Zip_Src
	:Zip_Source
	CALL :CreateTempFile __Zip_FileList
	CALL :CreateTempFile __Zip_RegExpExcludeList
	!DCMD! -ff "!__Zip_RegExpExcludeList!" "@s\n@s\n" "!__Zip_BuildOutputDirEsc!" "!__Zip_PackageDirEsc!"
	
	CALL :SyncPathList F __Zip_FileList "!CD!" "/A-D-H-R-S /S" G_CLEAN_SRC_EXP "/I /V" __Zip_RegExpExcludeList "/I /V"
	IF "%~1" NEQ "" (
		CALL :ZipAddFileSet "!__Zip_TempDir!\%~1" "!CD!" __Zip_FileList __Zip_FileCount
	) ELSE (
		SET F_PACKAGE_NAME=!G_PACKAGE_SRC_NAME!
		CALL :LoadCfgFile "!G_MAKE_CFG_FILE!" PACKAGE_NAME_FORMAT
		CALL :ZipAddFileSet "!__Zip_TempDir!\!G_PACKAGE_NAME_FORMAT!" "!CD!" __Zip_FileList __Zip_FileCount
	)
	GOTO :EOF

	:Zip_Package
	IF NOT EXIST "!G_PACKAGE_TEMP_DIR!" (
		CALL :Print W "ZIP" "Package temp directory @s does not exist." "!G_PACKAGE_TEMP_DIR!"
		GOTO :EOF
	)
	CALL :ToAbsPath  G_PACKAGE_ABS_DIR "!G_PACKAGE_DIR!"
	CALL :ToAbsPath  G_PACKAGE_TEMP_ABS_DIR "!G_PACKAGE_TEMP_DIR!"

	CALL :CreateTempFile __Zip_FileList
	CALL :SyncPathList F __Zip_FileList "!G_PACKAGE_TEMP_ABS_DIR!" "/A-D-H-R-S /S" G_CLEAN_PACKAGE_TEMP_EXP "/I /V" @NULL ""
	

	IF "%~1" EQU "@NONE@" (
		CALL :ZipAddFileSet "!__Zip_TempDir!" "!G_PACKAGE_TEMP_DIR!" __Zip_FileList __Zip_FileCount
	) ELSE IF "%~1" NEQ "" (
		CALL :ZipAddFileSet "!__Zip_TempDir!\%~1" "!G_PACKAGE_TEMP_DIR!" __Zip_FileList __Zip_FileCount
	) ELSE (
		SET F_PACKAGE_NAME=!G_PACKAGE_BIN_NAME!
		CALL :LoadCfgFile "!G_MAKE_CFG_FILE!" PACKAGE_NAME_FORMAT
		CALL :ZipAddFileSet "!__Zip_TempDir!\!G_PACKAGE_NAME_FORMAT!" "!G_PACKAGE_TEMP_DIR!" __Zip_FileList __Zip_FileCount
	)
	GOTO :EOF
	
GOTO :EOF

REM - %1 = package directory. all files and dirs under this are zipped
REM - %2 = root source dir for this set
REM -      i.e. !CD! or output; can be relative or absolute; all files for a set must be contained in this.
REM - %3 = env var name of file containing the list of files to copy
REM - %4 = env var name of file counter 
:ZipAddFileSet
	SET __ZipAddFileSet_Files=!%~3!
	SET __ZipAddFileSet_Count=0
	SET __ZipAddFileSet_BaseDir=%~1
	SET __ZipAddFileSet_RootDir=%~2
	CALL :TrimExR "\" __ZipAddFileSet_BaseDir
	
	
	FOR /F "eol=; tokens=* delims=" %%A IN (!__ZipAddFileSet_Files!) DO (
		SET /A __ZipAddFileSet_Count=__ZipAddFileSet_Count+1
		PUSHD !CD!
		CD /D "!__ZipAddFileSet_RootDir!"
		CALL :ToRelPath __ZipAddFileSet_AbsDir "%%~dpA"
		SET __ZipAddFileSet_AbsDir=!__ZipAddFileSet_BaseDir!\!__ZipAddFileSet_AbsDir!
		IF NOT EXIST "!__ZipAddFileSet_AbsDir!" MKDIR "!__ZipAddFileSet_AbsDir!"
		POPD
		COPY /Y "%%~A" "!__ZipAddFileSet_AbsDir!%%~nxA" >NUL
		IF "!ERRORLEVEL!" NEQ "0" CALL :Print W "ZIP" "Failed copying file:\n\t@s to @s." "%%~A" "!__ZipAddFileSet_AbsDir!%%~nxA"
	)
	
	SET /A %~4=%~4+!__ZipAddFileSet_Count!
	CALL :Undefine __ZipAddFileSet_*
GOTO :EOF

:Build_StartFailed
	CALL :SetError 1
	CALL :Print E "BUILD" "Failed setting up the WDK environment."
GOTO :EOF
	
:Build
	CALL :KitSetup
	IF "!BUILD_ERRORLEVEL!" NEQ "0" GOTO Build_StartFailed
	IF NOT DEFINED DDKBUILDENV GOTO Build_StartFailed

	REM - G_BUILD_OUTPUT_BASE_DIR is either absolute or relative to make.cfg. this is the base path of where output files will be placed.
	IF NOT EXIST "!G_BUILD_OUTPUT_BASE_DIR!" MKDIR "!G_BUILD_OUTPUT_BASE_DIR!"
	IF NOT EXIST "!G_BUILD_OUTPUT_BASE_DIR!" (
		CALL :SetError 1
		CALL :Print E "BUILD" "Failed creating base output dir@s." " !G_BUILD_OUTPUT_BASE_DIR!"
		GOTO :EOF
	)	
	IF EXIST "build!BUILD_ALT_DIR!.err" DEL /Q "build!BUILD_ALT_DIR!.err"
	IF EXIST "build!BUILD_ALT_DIR!.wrn" DEL /Q "build!BUILD_ALT_DIR!.wrn"
	
	REM - TODO: OUTPUT_FILE_LIST is not used yet but it's the start of a crucial part
	REM - for auto generating parts of the installer script.
	SET BUILD_OUTPUT_FILE_LIST=""
	SET BUILD_OUTPUT_COUNT=0
	
	REM - NOTE: Shorthand ovveride for G_WDK_SOURCES_LIST.
	IF DEFINED G_SRCS SET G_WDK_SOURCES_LIST=!G_SRCS!
	
	REM - This is the file.ext.sources file processing loop.  
	REM - It builds the sources listed in WDK_SOURCES_LIST from begining to end [in order]
	FOR /F "usebackq eol=; tokens=* delims=" %%I IN (`!DCMD! "-sp=;" "!G_WDK_SOURCES_LIST!"`) DO (
		SET __SOURCES_FILENAME=%%I
		CALL :TrimL __SOURCES_FILENAME
		IF "!__SOURCES_FILENAME!" NEQ "" (

			SET __SOURCES_FILENAME=!__SOURCES_FILENAME!.sources
			SET __SOURCES_COUNT=0
			
			REM - Locate the next sources file with dir; make sure it's really there.  and get the 
			FOR /F "usebackq eol=; tokens=* delims=" %%J IN (`dir /A-D /S /B "!__SOURCES_FILENAME!"`) DO (
				SET __SOURCES_NAME=%%~nJ
				SET __SOURCES_FILE=%%~fJ
				SET __SOURCES_DIR=%%~dpJ
				SET /A "__SOURCES_COUNT=__SOURCES_COUNT+1"
			)

			REM - Do some validation; there can be only one.
			IF !__SOURCES_COUNT! NEQ 1 (
				IF !__SOURCES_COUNT! GTR 1 CALL :Print E "BUILD" "Multiple sources found for @s.\r\n\tAll 'filename.ext.sources' files must all have a unique name\x21" "!__SOURCES_FILENAME!"
				IF !__SOURCES_COUNT! LSS 1 CALL :Print E "BUILD" "Missing sources file @s.\r\n\tA sources files listed in the WDK_SOURCES_LIST make.cfg setting was not found\x21" "!__SOURCES_FILENAME!"
				CALL :SetError 1
				GOTO :EOF
			)
			TITLE Building !__SOURCES_NAME! - !_BUILDARCH! - !DDK_TARGET_OS!..
			CALL :Print "BUILD" "@s \k03(\k0B@s\k03) - \k0B@s" "!__SOURCES_NAME!" "!_BUILDARCH!" "!DDK_TARGET_OS!"
			CALL :Build_LoadTargetEnv "!__SOURCES_FILE!" "!G_BUILD_OUTPUT_BASE_DIR!"
	
			REM - version tagging. this should go in pre tasks when/if there is one.
			CALL :PathSplit "!G_MAKE_CFG_FILE!"
			SET __BUILD_VERSION_FILE=!_DIR_!!_FILE_!.versions
			SET VERSION_FILENAME=
			IF EXIST "!__BUILD_VERSION_FILE!" (
				SET VERSION_FILENAME="!__SOURCES_NAME!"
				CALL :Print D "BUILD" "VERSION_FILE=@s TARGET_NAME=@s" "!__BUILD_VERSION_FILE!" !VERSION_FILENAME!
				!DCMD! -vc=tag "!__BUILD_VERSION_FILE!" !VERSION_FILENAME!
			)
	
			REM - build the sources file.
			REM - If an error occured in Build_SourcesFile, BUILD_ERRORLEVEL will be set
			CALL :Build_SourcesFile "!__SOURCES_FILE!"
			IF !BUILD_ERRORLEVEL! NEQ 0 GOTO Build_Stop
			
			REM - Check for errors, report warnings, sign target
			CALL :Build_PostTasks "!TARGET_FINAL_OUTPUT_DIR!\!__SOURCES_NAME!"
			IF !BUILD_ERRORLEVEL! NEQ 0 GOTO Build_Stop

			SET /A BUILD_OUTPUT_COUNT=BUILD_OUTPUT_COUNT+1
		)
	)
	
	REM - if nothing was built try and use a regular sources file that doesn't need renamed.
	IF "!BUILD_OUTPUT_COUNT!" EQU "0" CALL :SafeCall build !G_WDK_BUILD_OPTIONS!
	
	:Build_Stop
	SET >build_env_vars.lst
	SET __SOURCES_NAME=
	SET __SOURCES_FILE=
	SET __SOURCES_DIR=
	SET __TARGET_PATH=

	IF NOT EXIST "build!BUILD_ALT_DIR!.err" (
		IF !BUILD_ERRORLEVEL! EQU 0 (
			IF "!BUILD_OUTPUT_COUNT!" GTR "0" (
				CALL :Print S "BUILD" "\k02(\k0A!BUILD_ALT_DIR:_= !\k02)\k0A Build successful\x21 @d target(s) built.\n" "!BUILD_OUTPUT_COUNT!"
				GOTO :EOF
			)
		)
	)
	CALL :Print E "BUILD" "\k04(\k0C!BUILD_ALT_DIR:_= !\k04)\k0C Build failed\x21."
	IF EXIST "build!BUILD_ALT_DIR!.err" (
		ECHO.
		TYPE "build!BUILD_ALT_DIR!.err"
		ECHO.
	)
	IF EXIST "build!BUILD_ALT_DIR!.log" (
		SET AskYesNo_Default=0
		CALL :AskYesNo "\k0FDisplay entire log?"
		IF !AskYesNo! EQU 1 TYPE "build!BUILD_ALT_DIR!.log"
	)
	CALL :SetError 1
GOTO :EOF

REM :: Sets global, dynamic target env vars.  These are updated before each target is built.
REM - %1 = sources file name to be built.  Must be abs.
REM - %2 = Relative or absolute base output dir
:Build_LoadTargetEnv
	CALL :ToAbsPath  G_BUILD_OUTPUT_BASE_ABS_DIR "%~2"

	REM - The sources file must use $(G_TARGET_OUTPUT_NAME) for the target name.
	REM - To change the target name, change the name of the 'file.ext.sources' file.
	SET G_TARGET_OUTPUT_FILENAME=%~n1
	SET G_TARGET_OUTPUT_FRIENDLYNAME=!G_TARGET_OUTPUT_FILENAME:.=_!
	SET G_TARGET_OUTPUT_NAME=!G_TARGET_OUTPUT_FILENAME:~0,-4!
	SET G_TARGET_OUTPUT_FILENAME_EXT=!G_TARGET_OUTPUT_FILENAME:~-3!
	
	REM - This one will always point to the CORRECT ddk 'final' output subdir.
	REM - i386/x86 is a special feature exclusive to microsoft.
	SET G_TARGET_OUTPUT_ARCH=!_BUILDARCH!
	IF /I "!_BUILDARCH!" EQU "x86" SET G_TARGET_OUTPUT_ARCH=i386
	
	REM - TARGET_OUTPUT_ABS_DIR is what TARGETPATH should be set to in the sources file.
	CALL :LoadCfgFile "!G_MAKE_CFG_FILE!" TARGET_OUTPUT_ABS_DIR
	
	REM - TARGET_FINAL_OUTPUT_DIR is where the files will end up after WDK has added the arch.
	REM - This is sortof a hidden global.  It is special because it can't really be changed.
	SET TARGET_FINAL_OUTPUT_DIR=!G_TARGET_OUTPUT_ABS_DIR!\!G_TARGET_OUTPUT_ARCH!
		
GOTO :EOF

REM :: END COMMAND SECTION ---------------------------------------------
REM :: START BUILD SUB FUNCTIONS ---------------------------------------

REM :: Called by the Build_PostTasks function to sign target dll/sys/exe files when 'sign' is used on the command line.
REM - %1 = filepath to sign
:Build_Sign
	IF DEFINED G_SIGN (
		REM - sign only dll, sys and exe files.
		SET __SIGN_IS_SIGNABLE=
		IF /I "%~x1" EQU ".sys" SET __SIGN_IS_SIGNABLE=1
		IF /I "%~x1" EQU ".dll" SET __SIGN_IS_SIGNABLE=1
		IF /I "%~x1" EQU ".exe" SET __SIGN_IS_SIGNABLE=1
		IF NOT DEFINED __SIGN_IS_SIGNABLE (
			CALL :Print "SIGN" "Skipping @s file.." "%~x1"
			GOTO :EOF
		)
		PUSHD !CD!
		CD /D %~dp1
		CALL :SignFile "%~nx1"
		POPD
	)
GOTO :EOF

:Build_SetupWdfEnv
SET KMDFVERSION_MAJOR=1
SET KMDFVERSION_MINOR=10
:Build_SetupWdfEnv_NextVersion
SET /A "KMDFVERSION_MINOR=KMDFVERSION_MINOR-1"
IF "!KMDFVERSION_MINOR!" EQU "0" GOTO :EOF

SET KMDFCOINSTALLERVERSION=0!KMDFVERSION_MAJOR!00!KMDFVERSION_MINOR!
SET KMDFVERSION=!KMDFVERSION_MAJOR!.!KMDFVERSION_MINOR!
IF EXIST "!G_WDK_DIR!\redist\wdf\!_BUILDARCH!\WdfCoInstaller!KMDFCOINSTALLERVERSION!.dll" GOTO :EOF
GOTO Build_SetupWdfEnv_NextVersion

GOTO :EOF

REM :: Copies build err, log, and wrn files to the current directory
REM - %1 = Absolute filepath for a 'sources' file
REM - [USES] G_WDK_BUILD_OPTIONS, BUILD_ALT_DIR
:Build_SourcesFile
	IF NOT EXIST "%~1" (
		CALL :Print E "BUILD" "Sources file not found '@s'" "%~1"
		CALL :SetError 1
		GOTO :EOF
	)
	
	SET __SRCS_DIR=%~dp1
	CALL :TrimExR "\" __SRCS_DIR
	FOR /F "usebackq eol=; tokens=* delims=" %%A IN (`!DCMD! -rp d "!__SRCS_DIR!\\" d "!G_BUILD_OUTPUT_BASE_ABS_DIR!"`) DO IF "%%~A" NEQ "" SET G_TARGET_OUTPUT_REL_DIR=%%A

	REM - copy the name.ext.sources file to sources
	IF EXIST "%~dp1\sources" DEL /Q "%~dp1\sources"
	!DCMD! -ff "%~dp1\sources" "# ++ @s - @s\n" "AUTO-GENERATED" "%~nx1"
	!DCMD! -ff "%~dp1\sources" "@s@s\n@s@s\n" "TARGET_OUTPUT_FILENAME_EXT=" "!G_TARGET_OUTPUT_FILENAME_EXT!" "TARGET_OUTPUT_BASE_DIR=" "!G_TARGET_OUTPUT_REL_DIR!"
	CALL :Tokenizer "%~1" "%~dp1\sources" "G_TARGET_OUTPUT"

	REM - Clear the archive bit for everything in the output folder
	ATTRIB -A /S "!G_BUILD_OUTPUT_BASE_ABS_DIR!\*" 2>NUL>NUL

	Call :PathSplit "!G_MAKE_CFG_FILE!"
	SET __Version_File=!_DIR_!!_FILE_!.versions
	CALL :VersionLookup "PACKAGE" "!_DIR_!!_FILE_!.versions"
	
	REM - Call any user pre-build tasks here.
	CALL :ExecuteUserTask pre build !G_TARGET_OUTPUT_NAME!
	CALL :ExecuteUserTask pre build !G_TARGET_OUTPUT_FRIENDLYNAME!
	
	REM - Switch to the dir the sources file is in and build; this way we do not need dirs files.
	PUSHD !CD!
	CD /D %~dp1
	SET TOKVAR_LTAG=#
	SET TOKVAR_RTAG=#
	CALL :Build_SetupWdfEnv
	CALL :SafeCall build !G_WDK_BUILD_OPTIONS!
	SET TOKVAR_LTAG=
	SET TOKVAR_RTAG=
	POPD
	
	REM - Track the last file, for each type
	SET WDK_BUILD_LAST_!G_TARGET_OUTPUT_FILENAME_EXT!_TARGETFILE=!TARGET_FINAL_OUTPUT_DIR!\%~n1

	REM - Keep the current set of logs in the current directory.
	IF EXIST "%~dp1\build!BUILD_ALT_DIR!.err" COPY /Y "%~dp1\build!BUILD_ALT_DIR!.err" ".\" >NUL
	IF EXIST "%~dp1\build!BUILD_ALT_DIR!.wrn" COPY /Y "%~dp1\build!BUILD_ALT_DIR!.wrn" ".\" >NUL
	IF EXIST "%~dp1\build!BUILD_ALT_DIR!.log" TYPE "%~dp1\build!BUILD_ALT_DIR!.log" >>build!BUILD_ALT_DIR!.log
	
GOTO :EOF

REM :: Checks for build errors and executes user tasks; signs binaries;
REM - %1 = filepath of built target; this is also passed to Build_Sign
REM - [USES] BUILD_ALT_DIR
REM - [USES] G_TARGET_OUTPUT_FRIENDLYNAME
REM - [USES] G_TARGET_OUTPUT_NAME
:Build_PostTasks

	CALL :ExecuteUserTask post build !G_TARGET_OUTPUT_NAME!
	
	REM - If an error occurs we are all done
	IF EXIST "build!BUILD_ALT_DIR!.err" (
		CALL :SetError 1
		GOTO :EOF
	)

	REM - If an warning occurs; display it
	IF EXIST "build!BUILD_ALT_DIR!.wrn" (
		TYPE "build!BUILD_ALT_DIR!.wrn"
		ECHO.
	)
	IF NOT DEFINED G_WDK_NO_MAKEDIRS MAKEDIRS "!CD!">NUL
	
	REM - This is a good place to sign since we know where the files are at.
	CALL :Build_Sign "%~1"

	REM - Call any user pre-build tasks here.
	CALL :ExecuteUserTask post build !G_TARGET_OUTPUT_FRIENDLYNAME!

GOTO :EOF

:KitSetupFound_Callback
	SET /A __KitSetup_Count=%~5+1
	SET __KitSetup_Found=%~3
	CALL :TrimExR "\" __KitSetup_Found
	REM - setenv.bat must exist in a bin subdir of the root WDK install folder.
	IF EXIST "!__KitSetup_Found!\bin\setenv.bat" (
		ECHO !__KitSetup_Count!;!__KitSetup_Found!>>"!%~1!"
		CALL :Print "WDK #!__KitSetup_Count!" "@s" "!__KitSetup_Found!"
	)
GOTO :EOF

:KitKill
	REM - WDK has destroyed these values so we need a fresh copy
	CALL :RegEnum ":RegGetValue_CallBack" __KitKill_SystemPath "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "Path"
	CALL :RegEnum ":RegGetValue_CallBack" __KitKill_UserPath   "HKCU\Environment"                                                  "Path"
	CALL :RegEnum ":RegGetValue_CallBack" __KitKill_UserName   "HKCU\Volatile Environment"                                         "UserName"
	IF NOT DEFINED __KitKill_SystemPath GOTO KitKill_Error
	IF NOT DEFINED __KitKill_UserPath   GOTO KitKill_Error
	IF NOT DEFINED __KitKill_UserName   GOTO KitKill_Error
	
	PUSHD !CD!
	CD /D !PUBLIC_ROOT!\bin
	REM - Find everything that setenv.bat can possibly 'set'
	CALL :OutputToFile T __KitKill_SetEnvList @NULL FINDSTR /I /R /B /C:"[ ]*set[ ]" setenv.bat
	POPD
	IF NOT DEFINED __KitKill_SetEnvList_Error (
		REM - Keep spamming the user with this until they stop doing it.
		SET __KitKill_Text=
		SET __KitKill_Text=!__KitKill_Text! "WDK Environment is already configured."
		SET __KitKill_Text=!__KitKill_Text! "Run make.cmd from a normal command prompt to avoid this delay."
		SET __KitKill_Text=!__KitKill_Text! "De-configuring WDK environment.  Please Wait.."
		CALL :Print SW "KILENV" "\k0E@s\n\t\k0F@s\n\t@s\n" !__KitKill_Text!
		
		REM - Find all the 'set var-name' lines in setenv.bat that match varnames in the environment and undefine them.
		
		REM - Don't care what the values are, only the value names
		CALL :CreateTempFile __KitKill_AllList
		FOR /F "eol=; tokens=1,2 delims== " %%A IN (!__KitKill_SetEnvList!) DO ECHO %%B=>>"!__KitKill_AllList!"
		
		REM - Dump the current env
		CALL :CreateTempFile __KitKill__ActiveList
		SET >!__KitKill__ActiveList!
		
		REM - Find all the values names setenv has added/changed
		CALL :OutputToFile T __KitKill_MangledList @NULL FINDSTR /I /B /G:"!__KitKill_AllList!" !__KitKill__ActiveList!
		
		REM - Do the killin; but not PATH or USERNAME.
		FOR /F "eol=; tokens=1 delims==" %%A IN (!__KitKill_MangledList!) DO IF /I "%%~A" NEQ "PATH" IF /I "%%~A" NEQ "USERNAME" SET %%~A=
		
		REM - Repair PATH and USERNAME
		CALL :TrimEx ";" __KitKill_SystemPath __KitKill_UserPath
		SET UserName=!__KitKill_UserName!
		SET PATH=!G_DOSCMD_DIR!;!__KitKill_SystemPath!;!__KitKill_UserPath!;
		TITLE !COMSPEC!

		CALL :Undefine __KitKill_*
		GOTO :EOF
	)
		
	:KitKill_Error
	CALL :SetError 1
	
GOTO :EOF

:KitGetDefaultBuildOptions
	SET __KitSetup_OS=
	SET __KitSetup_Arch=

	IF /I "!_BUILDARCH!" EQU "amd64" SET __KitSetup_Arch=x64
	IF /I "!_BUILDARCH!" EQU "ia64" SET __KitSetup_Arch=64
	IF /I "!DDK_TARGET_OS!" EQU "Win2K" SET __KitSetup_OS=W2K
	IF /I "!DDK_TARGET_OS!" EQU "WinXP" SET __KitSetup_OS=WXP
	IF /I "!DDK_TARGET_OS!" EQU "Win7" SET __KitSetup_OS=WIN7
	IF NOT DEFINED __KitSetup_OS SET __KitSetup_OS=!DDK_TARGET_OS!
	IF NOT DEFINED __KitSetup_Arch IF /I "!__KitSetup_OS!" NEQ "W2K" IF /I "!__KitSetup_OS!" NEQ "WXP" SET __KitSetup_Arch=x86
	SET G_WDK_DEF_ENV_OPTIONS=
	CALL :AddIfDef G_WDK_DEF_ENV_OPTIONS DDKBUILDENV __KitSetup_Arch __KitSetup_OS
	SET WDK_ENV_OPTIONS=!G_WDK_DEF_ENV_OPTIONS!
GOTO :EOF

REM :: Called by the build function to configure the WDK environment; searches registry for WDK installations.
:KitSetup
	IF DEFINED DDKBUILDENV (
		IF EXIST "!PUBLIC_ROOT!\bin\setenv.bat" (
				CALL :KitGetDefaultBuildOptions
				SET G_WDK_DIR=!PUBLIC_ROOT!
				!DCMD! -uc=WDK_DIR "!G_MAKE_CFG_FILE!" "!G_WDK_DIR!"
				!DCMD! -uc=WDK_DEF_ENV_OPTIONS "!G_MAKE_CFG_FILE!" "!G_WDK_DEF_ENV_OPTIONS!"
			CALL :KitKill
			IF "!BUILD_ERRORLEVEL!" EQU "0" GOTO KitSetup_Start
		)
		CALL :SetError 1
		GOTO :EOF
	)
	
	:KitSetup_Start
	IF EXIST "!G_WDK_DIR!\bin\setenv.bat" GOTO KitSetup_Continue
	
	REM - The value  we are looking for is in the Wow6432Node software key so below will
	REM - scan for the value name we want starting in HKLM\SOFTWARE and do post validation
	REM - to ensure that it's really a WDK install dir.
	CALL :Print "SETENV" "Searching for WDK installations, please wait.."
	CALL :CreateTempFile __KitSetup_List
	CALL :RegEnum ":KitSetupFound_Callback" __KitSetup_List "HKLM\SOFTWARE" "setup-install-location" REG_SZ
	IF EXIST "!__KitSetup_List!" (
		!DCMD! -ff CON "\k0BSelect the DDK to use as the default"
		CALL :GetC __KitSetup_Selected "1" "-" "!__KitSetup_Count!" "1"
	) ELSE IF "!__KitSetup_Count!" EQU "1" (
		SET __KitSetup_Selected=1
	) ELSE (
		SET __KitSetup_Selected=
	)
	IF DEFINED __KitSetup_Selected (
		CALL :OutputToFile T __KitSetup_SelectedList @NULL FINDSTR /R /B /C:"!__KitSetup_Selected!;" !__KitSetup_List!
		IF NOT DEFINED __KitSetup_SelectedList_Error (
			SET G_WDK_DIR=
			FOR /F "eol=; tokens=1,* delims=;" %%A IN (!__KitSetup_SelectedList!) DO IF NOT DEFINED G_WDK_DIR SET G_WDK_DIR=%%~B
			IF EXIST "!G_WDK_DIR!" (
				!DCMD! -uc=WDK_DIR "!G_MAKE_CFG_FILE!" "!G_WDK_DIR!"
				IF "%ERRORLEVEL%" EQU "0" (
					CALL :Print S "SETENV" "Updated default WDK dir in @s." "!G_MAKE_CFG_FILE!"
					CALL :Undefine __KitSetup_*
					GOTO KitSetup_Continue
				) ELSE (
					CALL :Print E "SETENV" "Failed updating @s" "!G_MAKE_CFG_FILE!"
				)
			)
		)
	)
	:KitSetup_Error
	CALL :Undefine __KitSetup_*
	CALL :SetError 1
	GOTO :EOF

	:KitSetup_Continue
	PUSHD !CD!
	CALL :Print "SETENV" "Configuring WDK build environment. \k03(\k0B@s\k03)" "!WDK_ENV_OPTIONS!"
	CD /D "!G_WDK_DIR!\bin"
	CALL :SafeCall setenv.bat !G_WDK_DIR! !WDK_ENV_OPTIONS!
	POPD
GOTO :EOF

REM :: END OF BUILD SUB FUNCTIONS --------------------------------------
REM :: START OF UTILITY FUNCTIONS --------------------------------------

REM :: Called when a build error or other unrecoverable error occurs; notifies the parent make.cmd there was problems.
:SetError
	SET BUILD_ERRORLEVEL=%1
	IF DEFINED E_SND_FILE (
		IF EXIST "!E_SND_FILE!" (
			ECHO %~1 >!E_SND_FILE!
		)
	)
)
GOTO :EOF

:DefineDefaultDirEscapes
	SET %1BuildOutputDir=/@NULL/
	SET %1PackageDir=/@NULL/
	IF EXIST "!G_BUILD_OUTPUT_BASE_DIR!" CALL :ToAbsPath %1BuildOutputDir "!G_BUILD_OUTPUT_BASE_DIR!"
	IF EXIST "!G_PACKAGE_DIR!" CALL :ToAbsPath %1PackageDir "!G_PACKAGE_DIR!"
	CALL :ToRelPath %1BuildOutputDirRel "!%1BuildOutputDir!"
	CALL :ToRelPath %1PackageDirRel "!%1PackageDir!"
	CALL :RegexEscape %1BuildOutputDirEsc "!%1BuildOutputDirRel!"
	CALL :RegexEscape %1PackageDirEsc "!%1PackageDirRel!"
GOTO :EOF

REM :: Looks for and executes user 'bat' files which are excuted vefore and after every major tasks.
REM - %1 = pre/post
REM - %2 = category. IE. build / dist /etc.
REM - %3 = friendly name
:ExecuteUserTask
	SET __BAT_FILE=.\make_tasks\%~1_%~2_%~3.bat
	SET __CFG_FILE=.\make_tasks\%~1_%~2_%~3.cfg
	IF "%~3" EQU "" (
		SET __BAT_FILE=.\make_tasks\%~1_%~2.bat
		SET __CFG_FILE=.\make_tasks\%~1_%~2.cfg
	)
	CALL :Print D "USRCFG" "Looking for user config @s.." "!__CFG_FILE!"
	CALL :Print D "USRBAT" "Looking for user task @s.." "!__BAT_FILE!"
	IF EXIST "!__CFG_FILE!" CALL :LoadCfgFileEx "set-prefix=K_" "!__CFG_FILE!"
	IF EXIST "!__BAT_FILE!" CALL "!__BAT_FILE!" %*
	SET __BAT_FILE=
	SET __CFG_FILE=
GOTO :EOF

REM :: Signs a binary using the cert options defined in make.cfg or passed as arguments.
REM - %1 = Full path of file to sign.
REM [USES] G_WDK_DIR, G_SIGN_CERT_FILE, G_SIGN_CERT_NAME, G_SIGN_CERT_OPTIONS
:SignFile
	IF NOT EXIST "!G_SIGN_CERT_FILE!" (
	
		CALL :Print D "SIGN" "Skipping sign. No cert file."
		GOTO :EOF
	)
	CALL :FindFileInPath SIGN_EXE SignTool.exe
	IF NOT EXIST "!SIGN_EXE!" SET SIGN_EXE=!G_WDK_DIR!\bin\x86\SignTool.exe
	IF NOT EXIST "!SIGN_EXE!" FOR /F "usebackq eol=; tokens=* delims=" %%A IN (`dir /S /A-D /B "!G_WDK_DIR!\SignTool.exe"`) DO IF NOT EXIST "!SIGN_EXE!" SET SIGN_EXE=%%~A
	IF NOT EXIST "!SIGN_EXE!" (
		CALL :Print E "SIGN" "@s not found\x21 WDK installation at @s is either mangled or missing." "SignTool.exe" "!G_WDK_DIR!"
	) ELSE (
		PUSHD !CD!
		CD /D %~dp1
		!SIGN_EXE! !G_SIGN_CERT_ARGS! %~nx1
		IF DEFINED G_SIGN_CERT_VERIFY_ARGS !SIGN_EXE! !G_SIGN_CERT_VERIFY_ARGS! %~nx1
		POPD
	)
	SET SIGN_EXE=
GOTO :EOF

REM :: Executes a command line using CMD /C and returns an error code.
REM    After make.cmd has been wound, it can call SetError to report status
REM    back to the parent make.cmd if a critical action fails.
:SafeCMD
	SET E_RET_FILE=!TEMP!\E_RET_FILE_!RANDOM!.mrk
	IF EXIST "!E_RET_FILE!" DEL /Q "!E_RET_FILE!"
	ECHO 0 >!E_RET_FILE!
	CALL CMD /C %* E_RET_FILE="!E_RET_FILE!"
	FOR /F "eol=; tokens=1 delims= " %%I IN (!E_RET_FILE!) DO (
		SET BUILD_ERRORLEVEL=%%I
		GOTO SafeCMD_Done
	)
	
	:SafeCMD_Done
	IF EXIST "!E_RET_FILE!" DEL /Q "!E_RET_FILE!"

GOTO :EOF

REM :: Calls a function safely when running quiet; output is sent to a temp file; of any problems occur the output can be shown to the user.
REM    Checks ERRORLEVEL; calls 'SetError' and displays error with commandline if a problem occurs;
REM [SETS] SafeCall_Command to the last command executed
REM [SETS] SafeCall_OutputLog to the name of the tmp file stdout was stored to
REM [SETS] SafeCall_OutputErr to the name of the tmp file stderr was stored to
:SafeCall
	SET SafeCall_Command=%*
	SET SafeCall_Command=!SafeCall_Command:"=`!
	IF "!G_BUILD_QUIET!" EQU "1" (
		CALL :CreateTempFile __SafeCallOutputLog log
		CALL :CreateTempFile __SafeCallOutputErr err
		CALL %* 2>"!__SafeCallOutputErr!">"!__SafeCallOutputLog!"
	) ELSE (
		CALL %*
	)
	IF NOT "!ERRORLEVEL!" EQU "0" (
		CALL :SetError 1
		CALL :Print E "ERROR" "Failed executing command:@s" " %~1 "
	)
GOTO :EOF

REM :: Removes a list of sub directories or files recursively
REM - %1 = Remove type. can be 'dir' or 'file'
REM - %2 = env var name of the file list to remove; %1 indicates whether its a list of files or dirs
:RemoveList
	SET __RemoveList_FailCount=0
	SET __RemoveList_Count=0
	SET __RemoveList_Type=%~1
	SET __RemoveListFile=!%~2!

	IF /I "!__RemoveList_Type!" EQU "file" SET __RemoveList_DirCmd=/S /A-D
	IF /I "!__RemoveList_Type!" EQU "dir" SET __RemoveList_DirCmd=/S /AD
	FOR /F "eol=; tokens=* delims=" %%I IN (!__RemoveListFile!) DO (
		IF EXIST "%%~I" (
			IF /I "!__RemoveList_Type!" EQU "file" (
				ATTRIB -R -S -H "%%~I" 2>NUL>NUL
				DEL /S /Q %%I 2>NUL>NUL
			)
			IF /I "!__RemoveList_Type!" EQU "dir" RMDIR /S /Q %%I 2>NUL>NUL
			SET __REL_PATH=%%~I
			CALL :TrimExR "\" __REL_PATH
			IF EXIST "!__REL_PATH!"	(
				SET /A "__RemoveList_FailCount=__RemoveList_FailCount+1"
				CALL :Print E "CLEAN" "\k0EUnable to remove !__RemoveList_Type! @s." "!__REL_PATH!" 
			) ELSE (
				SET /A "__RemoveList_Count=__RemoveList_Count+1"
				CALL :Print S "CLEAN" "Removed !__RemoveList_Type! @s" "!__REL_PATH!" 
				SET __REL_PATH=
			)
		) ELSE (
			CALL :Print D "CLEAN" "@s @s no longer exists." "!__RemoveList_Type!" "%%~I" 
		)
	)
	:RemoveList_Done
	IF "!__RemoveList_FailCount!" EQU "0" CALL :Print S "CLEAN" "\k0AAll !__RemoveList_Type!s clean."
	CALL :Undefine __RemoveList*
GOTO :EOF

REM :: Creates a bare '/B' directory list and runs include/exlude regexps against it to produce final output.
REM - %1 = F or D [files or directories];
REM - %2 = env var name of file which will contain the final output;
REM        Must already be defined; ie CreateTempFile, OutputToFile
REM - %3 = root directory.  This will be passed to the initial 'DIR' command. i.e. DIR %1\*
REM        It will be stripped from the filelist and replaced with a '.' char
REM - %4 = additional arguments for DIR. '/S' for recursive, '/AD' dirs only '/A-D' files only
REM - %5 = clean exp var name
REM - %6 = findstr options for main clean expr [in %3] '/I' to ignore case.
REM - %7 = final [can be include or exclude] exp file list var name [@NULL to skip]
REM	- %8 = final exp findstr options [/v for exclude]
:SyncPathList
	REM - write the clean expressions to a temp file; one line per.
	SET __Sync_Path_OutFile=!%2!
	SET __Sync_Path_Type=%~1
	CALL :CreateTempFile __Sync_Path_RelList
	CALL :OutputToFile T __Sync_Path_AbsList @NULL DIR %~4 /B "%~3\*"
	FOR /F "eol=; tokens=* delims=" %%A IN (!__Sync_Path_AbsList!) DO (
		CALL :ToRelPath __Sync_Path_RelPath "%%~A"
		IF /I "!__Sync_Path_Type!" EQU "D" ECHO !__Sync_Path_RelPath!\>>"!__Sync_Path_RelList!"
		IF /I "!__Sync_Path_Type!" EQU "F" ECHO !__Sync_Path_RelPath!>>"!__Sync_Path_RelList!"
	)

	CALL :OutputToFile T __Sync_Path_RegExpList @NULL !DCMD! --get-commandline=start=0;split=0x0A;strip_quotes; !%5!
	ECHO.>>!__Sync_Path_RegExpList!
	CALL :SyncList %2 __Sync_Path_RegExpList "/I %~6" "%~7" "/I %~8" __Sync_Path_RelList
	CALL :Undefine __Sync_Path_*
GOTO :EOF


REM :: Runs include/exlude regexps against command output output to produce final output.
REM - %1 = Env var name of a file that will be appended with the final output
REM - %2 = Env var name of a file containing the list of initial [main] findstr regexps [one per line]
REM - %3 = findstr options for main regexps [in %1] '/I' to ignore case.
REM - %4 = Env var name of a file containing the list of secondary findstr regexps [one per line] [@NULL to skip]
REM - %5 = findstr options for secondary regexps [in %3] '/I' to ignore case.
REM - %6 = Env var name of file text that will be synced
:SyncList
	IF "%~4" EQU "@NULL" (
		CALL :OutputToFile A %~1 @NULL FINDSTR %~3 /R /G:"!%~2!" !%~6!
	) ELSE (
		CALL :OutputToFile T __Sync_List_1 @NULL FINDSTR %~3 /R /G:"!%~2!" !%~6!
		REM - this is the 'finalizer' exp which includes/excludes lines from the already filtered list
		CALL :OutputToFile A %~1 @NULL FINDSTR %~5 /R /G:"!%~4!" !__Sync_List_1!
	)
	CALL :Undefine __Sync_List_1
GOTO :EOF

REM :: Finds a file in the PATH env var
REM - %1 = Env pointer set to the full pathname of the file that was found.
REM - %2 = Filename to look for
REM [SETS] DIR_%1 to the full directory the file was found in.
:FindFileInPath
	IF "%~1" EQU "" GOTO :EOF
	SET %1=%~f$PATH:2
	SET DIR_%1=%~dp$PATH:2
	SHIFT /1
	SHIFT /1
	GOTO FindFileInPath
GOTO :EOF

REM :: Enumerates a registry key/sub keys for a specific value name
REM - %1 = Callback function name [Called for each match]
REM - %2 = Env var name of User context [lol]
REM - %3 = Registry key to enumerate
REM - %4 = value name to look for
REM - %5 = [OP] value type to look for
:RegEnum
	SET __RegEnum_ValueName=%~4
	SET __RegEnum_Callback=%~1
	SET __RegEnum_Context=%~2
	
	IF "%~5" NEQ "" SET __RegEnum_Type=/t %~5

	CALL :OutputToFile T __RegEnum_Out @NULL reg query "%~3" /s /v "%~4" !__RegEnum_Type!
	IF NOT DEFINED __RegEnum_Out_Error (
		SET __RegEnum_Count=0
		FOR /F "eol=H tokens=1,2* delims= " %%A IN (!__RegEnum_Out!) DO (
			SET __RegEnum_CheckValueName=%%~A
			CALL :Trim __RegEnum_CheckValueName
			IF /I "!__RegEnum_CheckValueName!" EQU "!__RegEnum_ValueName!" (
				SET __RegEnum_Type=%%~B
				SET __RegEnum_Value=%%~C
				CALL :Trim __RegEnum_Value __RegEnum_Type
				CALL !__RegEnum_Callback! !__RegEnum_Context! "!__RegEnum_ValueName!" "!__RegEnum_Value!" !__RegEnum_Type! !__RegEnum_Count!
				SET /A __RegEnum_Count=__RegEnum_Count+1
				IF DEFINED !__RegEnum_Callback!_Stop (
					SET !__RegEnum_Callback!_Stop=
					GOTO RegEnum_Done
				)
			)
		)
	) ELSE (
		CALL :Print E "REGENUM" "Unable to find registry value @s in key:\n\t@s." "%~4" "%~3"
	)
	IF "!__RegEnum_Count!" EQU "0" CALL :!__RegEnum_Callback! !__RegEnum_Context! "!__RegEnum_ValueName!"
	
	:RegEnum_Done
	CALL :Undefine __RegEnum_*
GOTO :EOF

:RegGetValue_CallBack
	SET %~1=%~3
GOTO :EOF

REM :: Gets file info.
REM - %1 = full pathname of a file
REM - [SETS] _DRIVE_ to drive
REM - [SETS] _DIR_ drive and diectory
REM - [SETS] _FILE_ filename only [no ext]
REM - [SETS] _FILENAME_ filename only [with ext]
REM - [SETS] _FILEEXT_ file ext only
REM - [SETS] _FILESIZE_ size of the file
:PathSplit
	SET _DRIVE_=%~d1
	SET _DIR_=%~dp1
	SET _FILE_=%~n1
	SET _FILENAME_=%~nx1
	SET _FILEEXT_=%~x1
	SET _FILESIZE_=%~z1
GOTO :EOF

REM :: Generates a new temporary filename that will reside in the 'TEMP' directory;
REM - %1 = Env var name to store filename in; also used to generate the temp filename/
REM - %2 = [OP] The extension added to the filename. i.e 'bat' or 'txt'.  'tmp' is default. 
:CreateTempFile
	IF NOT DEFINED CreateTempFileList SET CreateTempFileList=!TEMP!\__TempFiles_!RANDOM!.lst
	SET __TempFileExt=tmp
	IF "%~2" NEQ "" SET __TempFileExt=%~2
	SET %1=!TEMP!\%1_!RANDOM!.!__TempFileExt!
	IF EXIST "!%1!" DEL /Q "!%1!" 2>NUL>NUL
	SET __TempFileExt=
	ECHO !%1!>>!CreateTempFileList!
GOTO :EOF

REM :: Destroys all temp files that where created with 'CreateTempFile' for the current instance of make.cmd.
:DestroyAllTempFiles
	IF NOT DEFINED CreateTempFileList GOTO DestroyAllTempFilesDone
	IF NOT EXIST !CreateTempFileList! GOTO DestroyAllTempFilesDone
	FOR /F "eol=; tokens=* delims=" %%T IN (!CreateTempFileList!) DO (
		CALL :Print D "TMPFILE" "[@d] Destroying TMP file @s.." "!MAKE_RUN_COUNT!" "%%~nxT"
		IF EXIST "%%~T" DEL /Q "%%~T"
	)
	IF EXIST !CreateTempFileList! DEL /Q !CreateTempFileList!
:DestroyAllTempFilesDone
	SET CreateTempFileList=
GOTO :EOF

REM :: Tags a file with env vars
REM %1 in file.
REM %2 out file.
REM %3 [OP] 'use only' prefix; only tokenize env vars beginning with this string
:Tokenizer
	IF "%~3" EQU "" !DCMD! "--env-tag" "%~1" "%~2"
	IF "%~3" NEQ "" !DCMD! "--env-tag=%~3" "%~1" "%~2"
	IF "%ERRORLEVEL%" NEQ "0" (
		CALL :Print E "TOKEN" "Failed tokenizing file @s to @s."  "%~1" "%~2"
		CALL :SetError 1
	)
GOTO :EOF

REM :: Redirects stderr and stdout to temp files for the given commandline
REM - %1 = 'T' new tempfile
REM        'W' overwrite and re-use existing
REM        'A' append
REM - %2 = env var name to store the temp file name for stdout output
REM - %3 = env var name to store the temp file name for stderr output [@NULL if none]
REM - %4 and up = The commandline to execute and retrieve output from
REM [SETS] %1_Error=1 if the commad failed, undefines %1_Error if successful
:OutputToFile
	SET %2_Error=
	SET __STDOUT_FILE=NUL
	SET __STDERR_FILE=NUL
	
	CALL :CreateTempFile __OutputToFile bat
	CALL !DCMD! --get-commandline=start=3 %*>!__OutputToFile!
	IF "%~2" NEQ "@NULL" (
		IF /I "%~1" EQU "T" (
			CALL :CreateTempFile %2
			SET __STDOUT_FILE=!%~2!
		) ELSE (
			SET __STDOUT_FILE=!%~2!
		)
	)
	
	IF "%~3" NEQ "@NULL" (
		IF /I "%~1" EQU "T" (
			CALL :CreateTempFile %3
			SET __STDERR_FILE=!%~3!
		) ELSE (
			SET __STDERR_FILE=!%~3!
		)
	)
	IF /I "%~1" EQU "A" (
		CALL !__OutputToFile! 2>>!__STDERR_FILE!>>!__STDOUT_FILE!
	) ELSE (
		CALL !__OutputToFile! 2>!__STDERR_FILE!>!__STDOUT_FILE!
	)
	IF "%ERRORLEVEL%" NEQ "0" SET %2_Error=1
GOTO :EOF

REM :: Loads a cfg file [settting=value entities in a file] into env vars.
REM %1      - filepath to load
REM %2 [OP] - prefix string of the variable names to get from the file. [get-prefix[
REM %3 [OP] - prefix string added to the variables that are set. [set-prefix]
:LoadCfgFile
	CALL :CreateTempFile __LoadCfgFile bat
	IF "%~2" EQU "" (
		!DCMD! "--make-tokens=set-prefix=G_" "%~1" "!__LoadCfgFile!"
	) ELSE IF "%~3" EQU "" (
		!DCMD! "--make-tokens=set-prefix=G_;get-prefix=%~2" "%~1" "!__LoadCfgFile!"
	) ELSE (
		!DCMD! "--make-tokens=set-prefix=%~3;get-prefix=%~2" "%~1" "!__LoadCfgFile!"
	)
	
	"!__LoadCfgFile!"
	IF "%ERRORLEVEL%" NEQ "0" (
		CALL :Print E "CFGFILE" "Failed loading cfg file @s." "%~1"
		CALL :SetError 1
		GOTO :EOF
	)
GOTO :EOF

REM %1 - make-tokens arguments
REM %2 - cfg file to load
:LoadCfgFileEx
	CALL :CreateTempFile __LoadCfgFile bat
	!DCMD! "--make-tokens=%~1" "%~2" "!__LoadCfgFile!"
	"!__LoadCfgFile!"
	IF "%ERRORLEVEL%" NEQ "0" (
		CALL :Print E "CFGFILE" "Failed loading cfg file @s." "%~1"
		CALL :SetError 1
		GOTO :EOF
	)
GOTO :EOF

REM :: Gets arguments from the commandline and adds them as env vars.
:ArgumentsToEnv
	CALL :CreateTempFile __ArgumentsToEnv bat
	!DCMD! --make-args=%~1 "!__ArgumentsToEnv!" %*
	"!__ArgumentsToEnv!"
	IF "%ERRORLEVEL%" NEQ "0" (
		CALL :Print E "ARGENV" "Failed loading arguments file @s." "!__ArgumentsToEnv!"
		CALL :SetError 1
	)
GOTO :EOF

REM :: Prints formatted/colored status messages.
REM - %1 = [OP] type [D for debug, E for error, S for success, W for warning, excluded for status]
REM - %1 = 6 char category string (automatically padded/truncated)
REM - %2 = printf format string.
REM %3 and up printf arguments.
:Print
	SET __Print_Args=
	REM - StatuColor = 0, StatusColorDark = 3, TextColor = 6 [_S_CLR index]
	SET _S_CLR=0E 08 0B
	
	IF /I "%~1" EQU "S" ( 
		SET _S_CLR=0A 08 0B
		SHIFT /1
	) ELSE IF /I "%~1" EQU "E" ( 
		SET _S_CLR=CF 08 0C
		SHIFT /1
	) ELSE IF /I "%~1" EQU "W" ( 
		SET _S_CLR=E4 08 0F
		SHIFT /1
	) ELSE IF /I "%~1" EQU "SW" ( 
		SET _S_CLR=F4 08 0B
		SHIFT /1
	) ELSE IF /I "%~1" EQU "D" (
		IF "!G_SCRIPT_DEBUGGING!" NEQ "1" GOTO :EOF
		SET _S_CLR=0D 08 07
		SHIFT /1
	)
	
	:Print_NextArg
	IF "%~3" NEQ "" (
		SET __Print_Args=!__Print_Args! %3
		SHIFT /3
		GOTO Print_NextArg
	)
	!DCMD! -ff stdout "\k!_S_CLR:~0,2!@-6.6s\k!_S_CLR:~3,2!: \k!_S_CLR:~6,2!%~2\k07\r\n" "%~1" !__Print_Args!
	SET __Print_Args=
GOTO :EOF

REM :: Gets one char from the user and returns immediately; 
REM - %1 = Env Pointer to store char in.
REM - %2 = lower limit char to display.
REM - %3 = limit separator char to display.
REM - %4 = upper limit char to display.
REM - %5 = String for [enter = string]  display and value returned if enter is pressed.
REM - [NOTE] This is the only form if input we request from the user
:GetC
	IF DEFINED G_NOGETC (
		SET %1=%~5
		SET GetC_Response=%~5
		GOTO :EOF
	)
	CALL :CreateTempFile __GetC
	!DCMD! -ff CON " \k03(\k0B@s\k03@s\k0B@s\k03) \k03[\k0BEnter\k03=\k0B@s\k03] \k0E:\k0A" "%~2" "%~3" "%~4" "%~5"
	!DCMD! --getkey " " 2>!__GetC!>NUL
	FOR /F "eol=; tokens=* delims=" %%G IN (!__GetC!) DO (
		SET GetC_Response=%%G
		GOTO GetC_FoundKey
	)
	:GetC_FoundKey
	
	REM - Char is converted to ucase; if not a word char returned as 4 char hex string [0x00].
	IF /I "!GetC_Response:~1,1!" NEQ "" (
		SET %1=%~5
		!DCMD! -ff CON "\k07\n"
	) ELSE (
		SET %1=!GetC_Response!
		!DCMD! -ff CON "@s\k07\n" "!GetC_Response!"
	)
	SET GetC_Response=
GOTO :EOF

REM :: Ask a yes/no question.
REM - %1 and up = The question to ask
REM [USES] AskYesNo_Default [0 or 1]
REM [SETS] AskYesNo=1 if yes, 0 if no, AskYesNo_Default if niether y or n was pressed.
:AskYesNo
	!DCMD! -ff CON %*
	IF "!AskYesNo_Default!" EQU "0" (
		SET AskYesNo=0
		SET __AskYesNo_DefString=n
	) ELSE (
		SET AskYesNo=1
		SET AskYesNo_Default=1
		SET __AskYesNo_DefString=y
	)
	CALL :GetC AskYesNo_Response "y" "/" "n" "!__AskYesNo_DefString!"
	SET __AskYesNo_DefString=
	IF /I "!AskYesNo_Response!" EQU "N" SET AskYesNo=0
	IF /I "!AskYesNo_Response!" EQU "Y" SET AskYesNo=1
	SET AskYesNo_Response=
GOTO :EOF

REM :: Converts relative paths to absolute.
:ToAbsPath
	IF "%~1" EQU "" GOTO :EOF
	SET %~1=%~f2
	SHIFT /1
	SHIFT /1
	GOTO ToAbsPath
GOTO :EOF

:ToRelPath
	IF "%~1" EQU "" GOTO :EOF
	SET __ToRelPath=%~2
	CALL :PtrToString __ToRelPath "__ToRelPath:!CD!=."
	SET %~1=!__ToRelPath!
	SHIFT /1
	SHIFT /1
	GOTO ToRelPath
GOTO :EOF

REM :: Escapes a string for FINDSTR/
REM - %1 = Env var name to set with the escaped string text.
REM - %2 and up = Text to escape 
:RegexEscape
	CALL :CreateTempFile __RegexEscape_File bat
	CALL !DCMD! --get-commandline=start=1;strip_quotes;escaped="5C; 2E, 2A, 24, 5E, 5B, 5D";header="SET %~1=" %*>!__RegexEscape_File!
	CALL "!__RegexEscape_File!"
	IF NOT "!ERRORLEVEL!" EQU "0" (
		CALL :SetError 1
		CALL :Print E "ERROR" "Failed executing command: @s" "RegexEscape"
		TYPE "!__RegexEscape_File!"
	)	
GOTO :EOF

REM :: oooooooooooooooooooooooooooooooooooooooooooooooooooooo
REM ::  Basic string functions for trimming ends of a string
REM :: oooooooooooooooooooooooooooooooooooooooooooooooooooooo
:Trim
	CALL :TrimEx " " %*
GOTO :EOF

:TrimL
	CALL :TrimExL " " %*
GOTO :EOF

:TrimR
	CALL :TrimExR " " %*
GOTO :EOF

:TrimEx
	CALL :TrimExL %*
	CALL :TrimExR %*
GOTO :EOF

REM :: In the 'Ex' functions, the first arg is the trim char.
:TrimExL
	SET _W0=!%2!
	IF DEFINED _W0 (
		SET _W1="!_W0:~0,1!"
		IF !_W1! EQU "%~1" (
			SET %2=!_W0:~1!
			GOTO TrimExL
		)
		GOTO TrimExL_Done
	)
	:TrimExL_Done
	SHIFT /2
	IF "%2" NEQ "" GOTO TrimExL
GOTO :EOF

:TrimExR
	SET _W0=!%2!
	IF DEFINED _W0 (
		SET _W1="!_W0:~-1!"
		IF !_W1! EQU "%~1" (
			SET %2=!_W0:~0,-1!
			GOTO TrimExR
		)
		GOTO TrimExR_Done
	)
	:TrimExR_Done
	SHIFT /2
	IF "%2" NEQ "" GOTO TrimExR
GOTO :EOF

REM :: Adds env vars separated by spaces but only if they are defined.
REM - %1 = env var name to store 'defined' values.
REM - %2 and up = Env var names to check/add
:AddIfDef
	IF "%2" EQU "" (
		CALL :Trim %1
		GOTO :EOF
	)
	IF DEFINED %2 SET %1=!%1! !%~2!
	SHIFT /2
	GOTO AddIfDef
GOTO :EOF

REM :: Takes two env var names and set the first equal to the value of the second
REM - %1 = name of env var to set
REM - %2 = name of env var to use as the value for %1
:PtrToString
	SET %~1=!%~2!
GOTO :EOF

REM :: Undefines env vars.  
REM - %1 and up = Env var names to destroy. Appending a '*' will undefine all vars starting with this name
:Undefine
	IF "%~1" EQU "" (
		SET __UNDEFINE=
		GOTO :EOF
	)
	SET __UNDEFINE=%~1
	IF "!__UNDEFINE:~-1!" EQU "*" (
		SET __UNDEFINE=!__UNDEFINE:~0,-1!
		FOR /F "eol=; tokens=1 delims==" %%U IN ('SET !__UNDEFINE!') DO IF DEFINED %%U SET %%U=
	) ELSE (
		IF DEFINED %~1 SET %~1=
	)
	SHIFT /1
	GOTO Undefine
GOTO :EOF

:ShowUsage
SET F=!DCMD! -ff CON
SET A=!F! "@.72s\n"
IF /I "!G_HELP!" EQU "help" SET G_HELP=
IF /I "!G_HELP!" NEQ "" GOTO :ShowUsage_!G_HELP!

%A% "USAGE: make.cmd command[=value] <command-specific-arguments>            "
%A% "                                                                        "
%A% "COMMANDS: build/dist/clean/version/zip/formatcode                       "
%A% "                                                                        "
%A% "For help on a specific command, use the syntax:                         "
%A% "    make.cmd help=command                                               "
%A% "                                                                        "
GOTO :EOF

:ShowUsage_All
:ShowUsage_Build
%A% "USAGE: make.cmd build [fre/chk] [64/x64]                                "
%A% "                      [W2K/WIN7/WLH/WXP/WNET] [no_oacr]                 "
%A% "                                                                        "
IF "!G_HELP!" NEQ "all" GOTO :EOF

:ShowUsage_Dist
%A% "USAGE: make.cmd dist [fre/chk]                                          "
%A% "                                                                        "
IF "!G_HELP!" NEQ "all" GOTO :EOF

GOTO :EOF