able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/tools/postbuildscripts/ddkcabs.bat

1412 lines
45 KiB
Batchfile
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
@perl -x -w %0 %*
@goto :eof
#!perl
# line 5
################################################################################
# 05-Jun-00 : skupec: Add fail safes to avoid hangs in post build
# 1) delete all old lock files before we start
# 2) set max. wait limit for new process to 30*2 seconds
#
# 01-Jul-00 : skupec: Convert to use Win32::Process to avoid sporadic hangs
# that are showing up in postbuild.
#
# 10-Nov-00 : skupec: Add Verbose mode
# No longer use \lib[fre|chk]\%arch%. Now just \lib\%arch%
#
# 11-Jan-01 : skupec: Don't ship checked versions of the tools.
#
# 10-Feb-01 : skupec: Create per-architecture cabs for tools. Instead of just
# TOOL_*.cab, we now also have TOOL_*x.cab and TOOL_*i.cab
# (x86/ia64 respectively) IFF per-arch directories exist
# when cabbing is done. TOOL_*.cab should still be the
# primary cab in cabs.ini so a single checkbox will install
# on either platform.
#
# 27-Feb-01 : skupec: Modify the cabbing of \incs to properly handle the new
# platform specific subdir layout.
#
# 04-Apr-01 : skupec: Add cabbing of legacy libs for Win2K DDK env
#
# 17-May-01 : skupec: Add DDK_DBG[i|x] cabs only on CHK builds
#
use lib $ENV{RAZZLETOOLPATH} . '\\postbuildscripts';
use BuildName;
# Only accept one parameter which must be numeric
my ($numproc, $lpCount, $force, $spoof,$verbose) = (2,0,0,0,0);
for ($lpCount=0; $lpCount <= ($#ARGV); $lpCount++) {
SWITCH: {
if ((substr($ARGV[$lpCount],0,1) eq "-") or (substr($ARGV[$lpCount],0,1) eq "/")) {
for ($i=1;$i<length($ARGV[$lpCount]);$i++) {
exit(Usage()) if uc(substr($ARGV[$lpCount],$i,1)) eq "?";
exit(Usage()) if uc(substr($ARGV[$lpCount],$i,1)) eq "H";
if (uc substr($ARGV[$lpCount],$i,1) eq "L") {
if ($ARGV[$lpCount] =~ /:+(.*)/) {
if ((defined $1) and ($1 ne "")) { # handle -l:<language>
$lang = $1;
} else { # handle -l: where language was forgotten
$lang = "usa";
}
$ARGV[$lpCount] =~ s/:+(.*)//;
} elsif (defined $ARGV[$lpCount+1]) { # handle -l <language>
$lang = $ARGV[$lpCount+1];
splice(@ARGV,$lpCount+1,1);
} else { # handle -l where language was forgotten
$lang = "usa"; # default
}
unless (uc $lang eq "USA") { # only execute on USA
exit 0;
}
next;
} elsif (uc substr($ARGV[$lpCount],$i,1) eq "N") {
if (defined($ARGV[$lpCount+1]) and ($ARGV[$lpCount+1] =~ /^\d*$/)) {
$numproc=$ARGV[$lpCount+1];
splice(@ARGV,$lpCount+1,1);
} else {
exit(Usage());
}
} elsif (uc substr($ARGV[$lpCount],$i,1) eq "F") {
$force = 1;
} elsif (uc substr($ARGV[$lpCount],$i,1) eq "S") {
$spoof = 1;
} elsif (uc substr($ARGV[$lpCount],$i,1) eq "V") {
$verbose = 1;
} else {
print("-",substr($ARGV[$lpCount],$i,1)," switch ignored. Use '-?' or '-h' to get usage.\n");
}
}
} else {
print("$ARGV[$lpCount] argument ignored.\n");
}
1; #Last line should do nothing
}
}
if ($spoof) {
# Create %_NTTREE%/build_logs to hold the generated BuildName.txt file.
mkdir ("$ENV{_NTTREE}/build_logs", 0);
# Create & write the BuildName.txt file.
open (BLDNAME, ">$ENV{_NTTREE}/build_logs/BuildName.txt")
|| die "Couldn't open $ENV{_NTTREE}/build_logs/BuildName.txt for writing.\n";
# Write out the build number.
chop ($_ = `getbldno.cmd`);
print BLDNAME "$_.";
# Write out the build type.
print BLDNAME "$ENV{_BuildArch}$ENV{_BuildType}.";
# Write out the build branch.
print BLDNAME "$ENV{_BuildBranch}.";
# Write out the build time. Note that the year value [5] is years since
# 1900, and the month [4] is 0..11.
@_ = localtime(time);
printf BLDNAME "%02u%02u%02u-%02u%02u\n",
$_[5] - 100, $_[4] + 1, $_[3], $_[2], $_[1];
close BLDNAME;
}
# Only build if (1) -f is passed, (2) %OFFICIAL_BUILD_MACHINE% is set, or (3) %__BUILDMACHINE__% == LB6RI
if (! defined $ENV{OFFICIAL_BUILD_MACHINE} && (! $force) && (uc($ENV{__BUILDMACHINE__}) ne "LB6RI") ) {
print STDERR "Not building because this isn't an official build machine. Use -f to force.\n";
exit 0;
};
system("title PB_ddkcabs.bat"); # Required by postbuild. Do not remove.
print(STDERR "$0: Started. ");
use strict;
# use Win32;
use Win32::Process;
# Set %temp% as working directory
Win32::SetCwd $ENV{Temp};
my $time = time();
my $hLogFile;
my $handle;
################################################################################
#
# Create .tmp file so postbuild.cmd knows we're running.
#
################################################################################
open (hLogFile, ">$ENV{TEMP}\\ddkcabs.tmp") || die("Can't open $ENV{TEMP}\\ddkcabs.tmp for writing: $!\n");
print (hLogFile "1");
close (hLogFile);
################################################################################
#
# Find the correct logfile to use
#
################################################################################
# Either use the defined log file
if (defined $ENV{LOGFILE}) {
$handle="$ENV{LOGFILE}";
# or use our default log file.
} else {
$handle="$ENV{TEMP}\\ddkcabs.log";
}
print(STDERR "Writing log to $handle.\n");
################################################################################
#
# Test for all conditions that require us to terminate early.
#
################################################################################
# If %_DDK_NOCAB% is defined, don't make CABS
if (defined $ENV{_DDK_NOCAB} ) {
logmsg("_DDK_NOCAB is set. Not making CABS.");
unlink("$ENV{TEMP}\\ddkcabs.tmp");
exit(0);
}
# If any of the needed environment variables aren't defined, output an
# error and abort the cabbing process
foreach ("_NTDRIVE","_NTROOT","_BUILDARCH","_BUILDTYPE","_NTTREE","RazzleToolPath","PROCESSOR_ARCHITECTURE","NUMBER_OF_PROCESSORS") {
unless (defined $ENV{$_}) {
logerror("Aborting: \%$_\% is not defined.");
unlink("$ENV{TEMP}\\ddkcabs.tmp");
exit(0);
}
}
# Don't build on AXP64 or Alpha
if ($ENV{_BuildArch} =~ /^(axp64|alpha)/i) {
unlink("$ENV{TEMP}\\ddkcabs.tmp");
logmsg("DDK unsupported on $ENV{_BuildArch}. Exiting.");
exit(0);
}
################################################################################
#
# Global Variables
#
################################################################################
my $bldno = build_number;
logdebug("$numproc processes per processor");
my $MAX_PROCESSES = $ENV{NUMBER_OF_PROCESSORS}*$numproc;
my @Processes;
my $exe = "$ENV{RazzleToolPath}\\$ENV{PROCESSOR_ARCHITECTURE}\\cabarc.exe";
my $global_param = " -s 6144 -m MSZIP -i 1 N ";
my $INCREMENTAL = 0; # Full build by default
my %MAKECAB;
my @dir_list1;
my @dir_list2;
my $dir;
my $dir2;
my $file;
my $cabname;
my $samplename;
my $friendlyname;
my $kit;
my $i;
sub TRUE {return(1);} # BOOLEAN TRUE
sub FALSE {return(0);} # BOOLEAN FALSE
my $CABDEBUG = FALSE;
$CABDEBUG = TRUE if (defined($ENV{_CABDEBUG}));
my $bindir;
my $sdkincs = "$ENV{_NTTREE}\\ddk_flat\\inc";
# Directory to look for .lib's in
my $libdir = "lib\\wxp";
if (uc($ENV{_BuildArch}) eq "IA64") {
$libdir .= "\\ia64";
} else {
$libdir .= "\\i386";
}
################################################################################
#
# Determine if we should build incrementally
#
################################################################################
if ( -e "$ENV{_NTTREE}\\build_logs\\bindiff.txt" ) {
$INCREMENTAL = TRUE;
open(hFile, "$ENV{_NTTREE}\\build_logs\\bindiff.txt");
@dir_list1 = <hFile>;
close(hFile);
# Pass over the array of changed files once and determine which CABs
# need re-built.
foreach $file (@dir_list1) {
# Ignore files we don't care about.
next unless ($file =~ /\\ddk_flat\\/);
chomp $file;
# The easy checks
$MAKECAB{DDKINCS} =TRUE if ($file =~ /\\ddk_flat\\inc\\ddk\\/);
$MAKECAB{DDKLIBS} =TRUE if ($file =~ /\\ddk_flat\\$libdir\\/);
$MAKECAB{DDKBINS} =TRUE if ($file =~ /\\ddk_flat\\bin\\/);
$MAKECAB{DDKDOCS} =TRUE if ($file =~ /\\ddk_flat\\help\\/);
$MAKECAB{DDKTOOLS}=TRUE if ($file =~ /\\ddk_flat\\tools\\/);
$MAKECAB{DDKDBG} =TRUE if ($file =~ /\\ddk_flat\\debug\\/);
$MAKECAB{IFSTOOLS}=TRUE if ($file =~ /\\ifs_flat\\tools\\/);
$MAKECAB{IFSLIBS} =TRUE if ($file =~ /\\ifs_flat\\$libdir\\/);
$MAKECAB{IFSINCS} =TRUE if ($file =~ /\\ifs_flat\\incs\\/);
$MAKECAB{IFSDOCS} =TRUE if ($file =~ /\\ifs_flat\\help\\/);
#$MAKECAB{HALTOOLS}=TRUE if ($file =~ /\\hal_flat\\tools\\/);
$MAKECAB{HALLIBS} =TRUE if ($file =~ /\\hal_flat\\$libdir\\/);
$MAKECAB{HALINCS} =TRUE if ($file =~ /\\hal_flat\\incs\\/);
$MAKECAB{HALBINS} =TRUE if ($file =~ /\\hal_flat\\bins\\/);
#$MAKECAB{HALDOCS} =TRUE if ($file =~ /\\hal_flat\\help\\/);
#$MAKECAB{PDKTOOLS}=TRUE if ($file =~ /\\processor_flat\\tools\\/);
$MAKECAB{PDKLIBS} =TRUE if ($file =~ /\\processor_flat\\$libdir\\/);
$MAKECAB{PDKINCS} =TRUE if ($file =~ /\\processor_flat\\incs\\/);
#$MAKECAB{PDKDOCS} =TRUE if ($file =~ /\\processor_flat\\help\\/);
# The moderate checks
if ($file =~ /\\ddk_flat\\inc\\(.*)/) {
$i = $1;
$MAKECAB{SDKINCS}=TRUE unless ($i =~ /^ddk\\/);
}
if ($file =~ /\\ddk_flat\\(.*)/) {
$i = $1;
$MAKECAB{COREDDK}=TRUE unless ($i =~ /\\/);
}
if ($file =~ /\\hal_flat\\src\\hals\\(.*)/) {
$i = $1;
$MAKECAB{COREHAL}=TRUE unless ($i =~ /\\/);
}
if ($file =~ /\\processor_flat\\src\\processor\\(.*)/) {
$i = $1;
$MAKECAB{COREPDK}=TRUE unless ($i =~ /\\/);
}
$file =~ s/^[A-Z]:\\binaries\.(ia64|x86)(chk|fre)\\(ddk|ifs|hal|processor)_flat\\//i;
if ($file =~ /^tools\\(.*?)\\/) {
$dir = $1;
$cabname=sprintf("%s_%s\n","TOOL",lc(substr($dir,0,6)));
chomp $cabname;
$MAKECAB{$cabname} = TRUE;
}
next unless ($file =~ /^src\\(.*?)\\(.*?)\\/);
$dir = $1;
$dir2 = $2;
$cabname=sprintf("%s_%s\n",uc(substr($dir,0,4)),lc(substr($dir2,0,6)));
chomp $cabname;
$MAKECAB{$cabname} = TRUE;
}
}
# --------------------------------------------------------------------------
# Make the samples CABs. One cab per 2nd level directory under src. Name of each cab is
# the first 4 character of the first level directory + the first 6 of the second level
# directory.
# --------------------------------------------------------------------------
SAMPLES:{
foreach $kit ("ddk","ifs", "hal", "processor") {
mkdir("$ENV{_NTTREE}\\${kit}_cd\\common", 777) unless (-e "$ENV{_NTTREE}\\${kit}_cd\\common");
opendir(hDIR, "$ENV{_NTTREE}\\${kit}_flat\\src"); # Get the first level directories
@dir_list1=readdir(hDIR);
closedir(hDIR);
foreach $dir (@dir_list1) {
# Skip . & .. as well as non-directory files (which shouldn't be there anyhow).
next unless ((-d "$ENV{_NTTREE}\\${kit}_flat\\src\\$dir") and ($dir ne ".") and ($dir ne ".."));
chomp $dir;
opendir(hDIR, "$ENV{_NTTREE}\\${kit}_flat\\src\\$dir"); # Get the second level directories
@dir_list2=readdir(hDIR);
closedir(hDIR);
foreach $dir2 (@dir_list2) {
# Skip . & .. as well as non-directory files (which shouldn't be there anyhow).
next unless ((-d "$ENV{_NTTREE}\\${kit}_flat\\src\\$dir\\$dir2") and ($dir2 ne ".") and ($dir2 ne ".."));
chomp $dir2;
$cabname=sprintf("%s_%s\n",uc(substr($dir,0,4)),lc(substr($dir2,0,6)));
chomp $cabname;
next if (($INCREMENTAL) and (! defined $MAKECAB{$cabname}));
# Create a complete listing of files under the second level directory
system("dir $ENV{_NTTREE}\\${kit}_flat\\src\\$dir\\$dir2 /s/b/a-d > ${dir}${dir2}.ddk.ini 2>nul");
# Create the .ini
CreateCAB ("${dir}${dir2}.ddk.ini","$cabname","Samples","$dir", "$kit", "$bldno");
}
}
}
}
# --------------------------------------------------------------------------
DDKINCS: {
if ($INCREMENTAL) {
last DDKINCS unless ( defined $MAKECAB{DDKINCS} );
}
# List all files under \inc\ddk\...
system("dir $ENV{_NTTREE}\\ddk_flat\\inc\\ddk /s/b/a-d > ddkincs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "ddkincs.ddk.ini","DDKINCS","Build_Environment",
"DDK_Include_Files", "DDK", $bldno);
}
# --------------------------------------------------------------------------
IFSINCS: {
if ($INCREMENTAL) {
last IFSINCS unless ( defined $MAKECAB{IFSINCS} );
}
system("dir $ENV{_NTTREE}\\ifs_flat\\inc /s/b/a-d > ifsincs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "ifsincs.ddk.ini","IFSINCS","Build_Environment",
"IFS_Include_Files","IFS",$bldno);
}
# --------------------------------------------------------------------------
PDKINCS: {
if ($INCREMENTAL) {
last PDKINCS unless ( defined $MAKECAB{PDKINCS} );
}
system("dir $ENV{_NTTREE}\\processor_flat\\inc /s/b/a-d > pdkincs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "pdkincs.ddk.ini","PDKINCS","Build_Environment",
"PDK_Include_Files","processor",$bldno);
}
# --------------------------------------------------------------------------
HALINCS: {
if ($INCREMENTAL) {
last HALINCS unless ( defined $MAKECAB{HALINCS} );
}
system("dir $ENV{_NTTREE}\\HAL_flat\\inc /s/b/a-d > HALincs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "HALincs.ddk.ini","HALINCS","Build_Environment",
"HAL_Include_Files","HAL",$bldno);
}
# --------------------------------------------------------------------------
HALBINS: {
if ($INCREMENTAL) {
last HALBINS unless ( defined $MAKECAB{HALBINS} );
}
# List all files under \inc\ddk\...
system("dir $ENV{_NTTREE}\\HAL_flat\\bin /s/b/a-d > HALbins.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "HALbins.ddk.ini","HALBINS","Build_Environment",
"HAL_Binary_Files","HAL",$bldno);
}
# --------------------------------------------------------------------------
DDKDBG: {
if ($INCREMENTAL) {
last DDKDBG unless ( defined $MAKECAB{DDKDBG} );
}
# Make DBG cabs only on CHK builds
last DDKDBG if (uc $ENV{_BuildType} ne "CHK");
my $plat = substr($ENV{_BUILDARCH}, 0, 1);
system("dir $ENV{_NTTREE}\\ddk_flat\\debug /s/b/a-d > ddkdbg.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "ddkdbg.ddk.ini","DDK_DBG${plat}","Build_Environment",
"Extra_Debug_Files","DDK",$bldno);
}
# --------------------------------------------------------------------------
DDKTOOLS: {
if ($INCREMENTAL) {
last DDKTOOLS unless ( defined $MAKECAB{DDKTOOLS} );
}
# We don't want to ship checked versions of the tools
last DDKTOOLS if (uc $ENV{_BuildType} eq "CHK");
opendir(hDIR, "$ENV{_NTTREE}\\DDK_flat\\tools"); # Get the first level directories
@dir_list1=readdir(hDIR);
closedir(hDIR);
foreach $dir (@dir_list1) {
# Skip . & .. as well as non-directory files (which shouldn't be there anyhow).
next unless ((-d "$ENV{_NTTREE}\\DDK_flat\\tools\\$dir") and ($dir ne ".") and ($dir ne ".."));
chomp $dir;
$cabname=sprintf("%s_%s\n","TOOL",lc substr($dir,0,6) );
chomp $cabname;
next if (($INCREMENTAL) and (! defined $MAKECAB{$cabname}));
##
## Need to handle tools on the per-arch basis. Can't just look for \%arch, since
## the tools may also have files in root. (.htm's, etc). Instead, break we'll
## break this into 3 cabs per tool, TOOL_%tool%, TOOL_%tool%x (x86) TOOL_%tool%i (ia64)
##
# At tools\\$dir, now, we need all the sub dirs
my @subs = `dir $ENV{_NTTREE}\\DDK_flat\\tools\\$dir /s/b/ad`;
my $sub;
my $plat = substr($ENV{_BUILDARCH}, 0, 1);
# Drop in an empty file as placeholder so we can force the general cab for this tool
# to be built.
system("echo. >$ENV{_NTTREE}\\DDK_flat\\tools\\$dir\\.empty");
# Make sure we're not appending to old .ini's
unlink("TOOLS${dir}${plat}.ddk.ini") if (-e "TOOLS${dir}${plat}.ddk.ini");
unlink("TOOLS${dir}.ddk.ini") if (-e "TOOLS${dir}.ddk.ini");
# Now, create the .ini for the common cab
foreach (`dir $ENV{_NTTREE}\\DDK_flat\\tools\\$dir /b/a-d`) {
chomp;
system("echo $ENV{_NTTREE}\\DDK_flat\\tools\\$dir\\$_ >> TOOLS${dir}.ddk.ini");
}
# For every subdir, if it ends in %arch%, create the arch specific cab, otherwise
# create the general cab.
foreach $sub (@subs) {
chomp $sub;
if ($sub =~ /DDK_flat\\.*\\$ENV{_BUILDARCH}/i) {
system("dir $ENV{_NTTREE}\\DDK_flat\\tools\\$dir /s/b/a-d >> TOOLS${dir}${plat}.ddk.ini 2>nul");
} elsif ( uc($ENV{_BUILDARCH}) eq "X86" ) {
# i386 is a valid alias of x86
if ($sub =~ /DDK_flat\\.*\\i386/i) {
system("dir $ENV{_NTTREE}\\DDK_flat\\tools\\$dir /s/b/a-d >> TOOLS${dir}${plat}.ddk.ini 2>nul");
}
}
}
# Create the cabs
CreateCAB ("TOOLS${dir}.ddk.ini","${cabname}","Build_Environment","${dir}_TOOL", "ddk", "$bldno");
CreateCAB ("TOOLS${dir}${plat}.ddk.ini","${cabname}${plat}","Build_Environment","${dir}_TOOL", "ddk", "$bldno")
if (-e "TOOLS${dir}${plat}.ddk.ini"); # May not have arch-specific cab
}
}
# --------------------------------------------------------------------------
IFSTOOLS: {
if ($INCREMENTAL) {
last IFSTOOLS unless ( defined $MAKECAB{IFSTOOLS} );
}
# List all files under \inc\ddk\...
system("dir $ENV{_NTTREE}\\IFS_flat\\tools /s/b/a-d > ifstools.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "ifstools.ddk.ini","IFSTOOLS","Build_Environment",
"Development_Tools","IFS",$bldno);
}
# --------------------------------------------------------------------------
SDKINCS: {
if ($INCREMENTAL) {
last SDKINCS unless ( defined $MAKECAB{SDKINCS} );
}
# List all files under \inc\.
opendir(hDIR, "$sdkincs");
@dir_list1 = readdir(hDIR);
closedir(hDIR);
#
# Look for all WXP specific headers
#
opendir(hDIR, "$sdkincs\\wxp");
@dir_list2 = readdir(hDIR);
closedir(hDIR);
foreach (@dir_list2) {
$_ = "wxp\\$_";
}
push(@dir_list1, @dir_list2);
undef(@dir_list2);
#
# Look for all CRT headers
#
opendir(hDIR, "$sdkincs\\crt");
@dir_list2 = readdir(hDIR);
closedir(hDIR);
foreach (@dir_list2) {
$_ = "crt\\$_";
}
push(@dir_list1, @dir_list2);
undef(@dir_list2);
opendir(hDIR, "$sdkincs\\crt\\sys");
@dir_list2 = readdir(hDIR);
closedir(hDIR);
foreach (@dir_list2) {
$_ = "crt\\sys\\$_";
}
push(@dir_list1, @dir_list2);
undef(@dir_list2);
opendir(hDIR, "$sdkincs\\crt\\gl");
@dir_list2 = readdir(hDIR);
closedir(hDIR);
foreach (@dir_list2) {
$_ = "crt\\gl\\$_";
}
push(@dir_list1, @dir_list2);
undef(@dir_list2);
opendir(hDIR, "$sdkincs\\crt\\wxp");
@dir_list2 = readdir(hDIR);
closedir(hDIR);
foreach (@dir_list2) {
$_ = "crt\\wxp\\$_";
}
push(@dir_list1, @dir_list2);
undef(@dir_list2);
open(sdk1, ">sdk1.ddk.ini");
open(sdk2, ">sdk2.ddk.ini");
open(sdk3, ">sdk3.ddk.ini");
for ($i=0;$i<=$#dir_list1;$i++) {
next if ($dir_list1[$i] =~ /\.$/);
next if (-d "$sdkincs\\$dir_list1[$i]");
if (($i%3) == 0) {
print(sdk1 "$sdkincs\\$dir_list1[$i]\n");
} elsif (($i%3) == 1) {
print(sdk2 "$sdkincs\\$dir_list1[$i]\n");
} else {
print(sdk3 "$sdkincs\\$dir_list1[$i]\n");
}
}
close(sdk1);
close(sdk2);
close(sdk3);
# CAB 1
# Create the .ini
CreateCAB( "sdk1.ddk.ini","SDKINCS1","Build_Environment",
"SDK_Include_Files","DDK",$bldno);
# CAB 2
# Create the .ini
CreateCAB( "sdk2.ddk.ini","SDKINCS2","Build_Environment",
"SDK_Include_Files","DDK",$bldno);
# CAB 3
# Create the .ini
CreateCAB( "sdk3.ddk.ini","SDKINCS3","Build_Environment",
"SDK_Include_Files","DDK",$bldno);
}
# --------------------------------------------------------------------------
DDKLIBS: {
if ($INCREMENTAL) {
last DDKLIBS unless ( defined $MAKECAB{DDKLIBS} );
}
if ( -e "$ENV{_NTTREE}\\ddk_flat\\lib\\w2k\\i386" && (uc($ENV{_BuildArch}) eq "X86")) {
# List all files under \inc\ddk\...
system("dir $ENV{_NTTREE}\\ddk_flat\\lib\\w2k /s/b/a-d > w2klibs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "w2klibs.ddk.ini","W2K_LIBS","Build_Environment",
"W2K_Library_Files","DDK",$bldno);
}
if (uc($ENV{_BUILDARCH}) eq "IA64") {
$cabname="IA6dLIB";
} else {
$cabname="X86dLIB";
}
$samplename ="$ENV{_BuildArch}_Libraries";
$friendlyname="$ENV{_BuildArch}_Libraries";
# List all files under \tools
opendir(hDIR, "$ENV{_NTTREE}\\ddk_flat\\$libdir");
@dir_list1=readdir hDIR;
closedir(hDIR);
open(LIBS1, ">libs1.ddk.ini");
open(LIBS2, ">libs2.ddk.ini");
open(LIBS3, ">libs3.ddk.ini");
for ($i=0;$i<=$#dir_list1;$i++) {
next if ($dir_list1[$i] =~ /^\./);
if (($i % 3) == 0) {
print(LIBS1 "$ENV{_NTTREE}\\ddk_flat\\$libdir\\$dir_list1[$i]\n");
} elsif (($i % 3) == 1) {
print(LIBS2 "$ENV{_NTTREE}\\ddk_flat\\$libdir\\$dir_list1[$i]\n");
} else {
print(LIBS3 "$ENV{_NTTREE}\\ddk_flat\\$libdir\\$dir_list1[$i]\n");
}
}
close(LIBS1);
close(LIBS2);
close(LIBS3);
# CAB 1
# Create the .ini
CreateCAB( "libs1.ddk.ini","${cabname}1","Build_Environment",
"${samplename}","DDK",$bldno);
# CAB 2
# Create the .ini
CreateCAB( "libs2.ddk.ini","${cabname}2","Build_Environment",
"$samplename","DDK",$bldno);
# CAB 3
# Create the .ini
CreateCAB( "libs3.ddk.ini","${cabname}3","Build_Environment",
"$samplename","DDK",$bldno);
}
# --------------------------------------------------------------------------
IFSLIBS: {
if ($INCREMENTAL) {
last IFSLIBS unless ( defined $MAKECAB{IFSLIBS} );
}
if (uc($ENV{_BUILDARCH}) eq "IA64") {
$cabname="IA6iLIB";
} else {
$cabname="X86iLIB";
}
# List all files under \inc\ddk\...
system("dir $ENV{_NTTREE}\\ifs_flat\\$libdir /s/b/a-d > ifslibs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "ifslibs.ddk.ini","${cabname}1","Build_Environment",
"Library_Files","IFS",$bldno);
}
# --------------------------------------------------------------------------
PDKLIBS: {
if ($INCREMENTAL) {
last PDKLIBS unless ( defined $MAKECAB{PDKLIBS} );
}
if (uc($ENV{_BUILDARCH}) eq "IA64") {
$cabname="IA6pLIB";
} else {
$cabname="X86pLIB";
}
# List all files under \inc\ddk\...
system("dir $ENV{_NTTREE}\\processor_flat\\$libdir /s/b/a-d > pdklibs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "pdklibs.ddk.ini","${cabname}1","Build_Environment",
"Library_Files","processor",$bldno);
}
# --------------------------------------------------------------------------
HALLIBS: {
if ($INCREMENTAL) {
last HALLIBS unless ( defined $MAKECAB{HALLIBS} );
}
if (uc($ENV{_BUILDARCH}) eq "IA64") {
$cabname="IA6hLIB";
} else {
$cabname="X86hLIB";
}
# List all files under \inc\ddk\...
system("dir $ENV{_NTTREE}\\hal_flat\\$libdir /s/b/a-d > hallibs.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "hallibs.ddk.ini","${cabname}1","Build_Environment",
"Library_Files","HAL",$bldno);
}
# --------------------------------------------------------------------------
DDKBINS: {
if ($INCREMENTAL) {
last DDKBINS unless ( defined $MAKECAB{DDKBINS} );
}
$bindir ="$ENV{_NTTREE}\\ddk_flat\\bin";
# List all files under bin
opendir(hDIR, "$bindir"); # Get the first level directories
@dir_list1=readdir(hDIR);
closedir(hDIR);
open(hDIR, ">cmnbins.ddk.ini");
foreach $dir (@dir_list1) {
# Skip . & .. as well as files.
next if ( -d "$bindir\\$dir");
next if (($dir eq ".") or ($dir eq ".."));
print(hDIR "$bindir\\$dir\n");
}
close(hDIR);
system("dir $ENV{_NTTREE}\\ddk_flat\\bin\\wppconfig /s/b/a-d >>cmnbins.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "cmnbins.ddk.ini","CMNBINS","Build_Environment",
"Comon_Build_Tools","DDK",$bldno);
if (uc($ENV{_BUILDARCH}) eq "IA64") {
$cabname="IA6dBIN";
} else {
$cabname="X86bBIN";
}
$samplename ="$ENV{_BuildArch}_$ENV{_BuildType}_Binaries";
$friendlyname="$ENV{_BuildArch}_$ENV{_BuildType}_Binaries";
if (-e "$bindir\\x86") {
# List all files under bin\x86
opendir(hDIR, "$bindir\\x86"); # Get the first level directories
@dir_list1=readdir(hDIR);
closedir(hDIR);
open(hDIR, ">x86bins.ddk.ini");
foreach $dir (@dir_list1) {
# Skip . & .. as well as directory files (which shouldn't be there anyhow).
next unless ((! -d "$bindir\\x86\\$dir") and ($dir ne ".") and ($dir ne ".."));
print(hDIR "$bindir\\x86\\$dir\n");
}
close(hDIR);
# Create the .ini
CreateCAB( "x86bins.ddk.ini","X86dBINS","Build_Environment",
"X86_Build_Tools","DDK",$bldno);
}
if (-e "$bindir\\ia64") {
# List all files under bin\ia64
opendir(hDIR, "$bindir\\ia64"); # Get the first level directories
@dir_list1=readdir(hDIR);
closedir(hDIR);
open(hDIR, ">ia64bins.ddk.ini");
foreach $dir (@dir_list1) {
# Skip . & .. as well as directory files (which shouldn't be there anyhow).
next unless ((! -d "$bindir\\ia64\\$dir") and ($dir ne ".") and ($dir ne ".."));
print(hDIR "$bindir\\ia64\\$dir\n");
}
close(hDIR);
# Create the .ini
CreateCAB( "ia64bins.ddk.ini","IA6dBINS","Build_Environment",
"IA64_Build_Tools","DDK",$bldno);
}
}
# --------------------------------------------------------------------------
COREDDK: {
if ($INCREMENTAL) {
last COREDDK unless ( defined $MAKECAB{COREDDK} );
}
system("dir $ENV{_NTTREE}\\ddk_flat /b/a-d > core.ddk.ini 2>nul");
# Create the .ini
CreateCAB( "core.ddk.ini","COREDDK","Build_Environment",
"DDK_Core_Files","DDK",$bldno);
}
# --------------------------------------------------------------------------
COREPDK: {
if ($INCREMENTAL) {
last COREPDK unless ( defined $MAKECAB{COREPDK} );
}
last COREPDK unless (-e "$ENV{_NTTREE}\\processor_flat\\src\\processor");
@dir_list1=`dir $ENV{_NTTREE}\\processor_flat\\src\\processor /b/a-d`;
foreach (@dir_list1) {
next if (m/^\s*$/);
chomp;
system("echo $ENV{_NTTREE}\\processor_flat\\src\\processor\\$_ >> pdkcore.ddk.ini");
}
# Create the .ini
CreateCAB( "pdkcore.ddk.ini","COREPDK","Build_Environment",
"PDK_Core_Files","processor",$bldno);
}
# --------------------------------------------------------------------------
COREHAL: {
if ($INCREMENTAL) {
last COREHAL unless ( defined $MAKECAB{COREHAL} );
}
last COREHAL unless (-e "$ENV{_NTTREE}\\hal_flat\\src\\hals");
@dir_list1=`dir $ENV{_NTTREE}\\hal_flat\\src\\hals /b/a-d`;
foreach (@dir_list1) {
next if (m/^\s*$/);
chomp;
system("echo $ENV{_NTTREE}\\hal_flat\\src\\hals\\$_ >> halcore.ddk.ini");
}
# Create the .ini
CreateCAB( "halcore.ddk.ini","COREHAL","Build_Environment",
"HAL_Core_Files","HAL",$bldno);
}
# --------------------------------------------------------------------------
COREIFS: {
if ($INCREMENTAL) {
last COREIFS unless ( defined $MAKECAB{COREIFS} );
}
last COREIFS unless (-e "$ENV{_NTTREE}\\ifs_flat");
@dir_list1=`dir $ENV{_NTTREE}\\ifs_flat\\src\\filesys /b/a-d`;
foreach (@dir_list1) {
next if (m/^\s*$/);
chomp;
system("echo $ENV{_NTTREE}\\ifs_flat\\src\\filesys\\$_ >> ifscore.ddk.ini");
}
# Create the .ini
CreateCAB( "ifscore.ddk.ini","COREIFS","Build_Environment",
"IFS_Core_Files","IFS",$bldno);
}
# --------------------------------------------------------------------------
DDKDOCS: {
if ($INCREMENTAL) {
last DDKDOCS unless ( defined $MAKECAB{DDKDOCS} );
}
# Make the Docs
opendir(hDir, "$ENV{_NTTREE}\\ddk_flat\\help")||warn("Can't open $ENV{_NTTREE}\\ddk_flat\\help: $!\n");
@dir_list1=readdir(hDir);
closedir(hDir);
my @general_cab;
foreach $file (@dir_list1) {
next if ($file =~ /^\./);
next if ($file =~ /\.chi$/); # Don't use .chi, use .chm below
next if (-d "$ENV{_NTTREE}\\ddk_flat\\help\\$file");
if ($file =~ /\.chm$/i) {
# We have a .chm
$file =~ s/\.chm$//i; # Remove the extension
system("dir $ENV{_NTTREE}\\ddk_flat\\help\\$file.* /s/b/a-d > $file.ddk.ini 2>nul");
$file=uc($file); # Force uppercase
# Create the .ini
CreateCAB( "$file.ddk.ini","$file","Documentation",
"${file}_Doc","DDK",$bldno);
} else {
system("dir $ENV{_NTTREE}\\ddk_flat\\help\\$file /s/b/a-d >> general_docs.ddk.ini 2>nul");
}
}
CreateCAB("general_docs.ddk.ini","CMNDOCS", "Documentation", "Common_Docs_Files", "DDK",$bldno);
}
# --------------------------------------------------------------------------
IFSDOCS: {
if ($INCREMENTAL) {
last IFSDOCS unless ( defined $MAKECAB{IFSDOCS} );
}
# Make the Docs
opendir(hDir, "$ENV{_NTTREE}\\ifs_flat\\help")||warn("Can't open $ENV{_NTTREE}\\ifs_flat\\help: $!\n");
@dir_list1=readdir(hDir);
closedir(hDir);
foreach $file (@dir_list1) {
next if ($file =~ /^\./);
next if ($file =~ /\.chi$/); # Don't use .chi, use .chm below
next if (-d "$ENV{_NTTREE}\\ifs_flat\\help\\$file");
if ($file =~ /\.chm$/i) {
# We have a .chm
$file =~ s/\.chm$//i; # Remove the extension
system("dir $ENV{_NTTREE}\\ifs_flat\\help\\$file.* /s/b/a-d > $file.ddk.ini 2>nul");
$file=uc($file); # Force uppercase
# Create the .ini
CreateCAB( "$file.ddk.ini","$file","Documentation",
"${file}_Doc","IFS",$bldno);
} else {
logdebug("Not including \\help\\$file\n");
}
}
}
# Don't exit until all subprocesses have completed.
WaitForAllProcesses();
if (-e "$ENV{_NTTREE}\\ddk_cd\\common\\cabs.in_") {
system("copy $ENV{_NTTREE}\\ddk_cd\\common\\cabs.in_ $ENV{_NTTREE}\\ddk_cd\\common\\cabs.ini >nul");
open(hF, ">>$ENV{_NTTREE}\\ddk_cd\\common\\cabs.ini");
print(hF "Build=$bldno\n");
close(hF);
}
if (-e "$ENV{_NTTREE}\\ifs_cd\\common\\cabs.in_") {
system("copy $ENV{_NTTREE}\\ifs_cd\\common\\cabs.in_ $ENV{_NTTREE}\\ifs_cd\\common\\cabs.ini >nul");
open(hF, ">>$ENV{_NTTREE}\\ifs_cd\\common\\cabs.ini");
print(hF "Build=$bldno\n");
close(hF);
}
if (-e "$ENV{_NTTREE}\\hal_cd\\common\\cabs.in_") {
system("copy $ENV{_NTTREE}\\hal_cd\\common\\cabs.in_ $ENV{_NTTREE}\\hal_cd\\common\\cabs.ini >nul");
open(hF, ">>$ENV{_NTTREE}\\hal_cd\\common\\cabs.ini");
print(hF "Build=$bldno\n");
close(hF);
}
if (-e "$ENV{_NTTREE}\\processor_cd\\common\\cabs.in_") {
system("copy $ENV{_NTTREE}\\processor_cd\\common\\cabs.in_ $ENV{_NTTREE}\\processor_cd\\common\\cabs.ini >nul");
open(hF, ">>$ENV{_NTTREE}\\processor_cd\\common\\cabs.ini");
print(hF "Build=$bldno\n");
close(hF);
}
$time = time() - $time;
logmsg("Total run time: $time seconds.\n");
print(STDERR "$0: Finished.\n\n");
END {
# Delete .tmp file so postbuild.cmd knows the script has finished
unlink ("$ENV{TEMP}\\ddkcabs.tmp");
}
# --------------------------------------------------------------------------
# Creates a CAB and INF from a list of files
# --------------------------------------------------------------------------
sub CreateCAB {
print(".") unless ($verbose); # Print something so the user knows the script is still running
my $filelist = shift;
my $cabname = shift;
my $groupname = shift;
my $samplename = shift;
my $kit = shift;
my $bldno = shift;
my $FileIndex = -1;
my $friendlyname = $samplename;
my $GroupIndex = -1;
my $InfCopyFileList = "InfFiles";
my $PrevCommand = "";
my $PrevDestDir = "";
my $TotalSize = 0;
my @files;
my $file;
my $FileProcessed;
my $hFILE;
my $NewSection;
my $source_file;
my $source_dir;
my $dest_dir;
my $ERRORLEVEL;
my $FileSize;
my $CabFileName;
chomp($cabname);
unless (-e $filelist) {
logerror("$filelist did not exist - cannot build cab.");
return(5);
}
# These files get rolled into the INF once the entire filelist
# is processed.
open(hFILE, ">${cabname}_DestDirsFiles")
|| die("Couldn't write to ${cabname}_DestDirsFile: $!\n");
printf(hFILE "[DestinationDirs]\n");
close(hFILE);
open(hFILE, ">${cabname}_SourceFiles")
|| die("Couldn't write to ${cabname}_SourceFiles: $!\n");
printf(hFILE "\n");
close(hFILE);
open(hFILE, ">${cabname}_SourceDisk")
|| die("Couldn't write to ${cabname}_SourceDisk: $!\n");
printf(hFILE "[SourceDisksFiles]\n");
close(hFILE);
#
# Process the filelist
#
open(hFILE, "$filelist");
@files=<hFILE>;
close(hFILE);
# For every file in the list, split it up into the format expected by genddkcab.bat:
# $source_dir, $source_file, $dest_dir, $dest_file, $command
foreach $file (@files) {
chomp($file);
$file =~ m/^(.*)\\.*$/;
# source_dir is %_NTTREE%\[ddk|hal|ifs]_flat + dest_dir
if (! defined($1)) {
$source_dir = "$ENV{_NTTREE}\\ddk_flat";
} else {
$source_dir = $1;
}
$file =~ m/^.*\\(.*)$/;
# source_file is filename
if (! defined($1)) {
$source_file = $file;
} else {
$source_file = $1;
}
$file =~ m/^.*_flat(\\.*\\).*$/;
# dest_dir is dir less %_NTTREE%\[ddk|hal|ifs]_flat
if (! defined($1)) {
$dest_dir= "\\";
} else {
$dest_dir= $1;
}
$FileProcessed=FALSE;
# Optimization to not generate excessive install sections in the inf.
$NewSection=TRUE;
$NewSection=FALSE if (uc($dest_dir) eq uc($PrevDestDir));
$PrevDestDir=$dest_dir;
if ($NewSection) {
$GroupIndex+=1;
open(hDDF, ">>${cabname}_DestDirsFiles");
printf(hDDF "Files_${GroupIndex}=49000,\"$dest_dir\"\n");
close(hDDF);
$InfCopyFileList="${InfCopyFileList},Files_${GroupIndex}";
open(hDDF, ">>${cabname}_SourceFiles");
printf(hDDF "[Files_${GroupIndex}]\n");
close(hDDF);
}
if (! -e "$source_dir\\$source_file") {
logerror("489: File $source_dir\\$source_file does not exist");
next;
}
# Move on to the next file number
$FileIndex += 1;
# Generate the name of the file within the cabfile.
$CabFileName="${cabname}_FILE_${FileIndex}";
# process the source file into the temporary cabfile name
$ERRORLEVEL=system("COPY $source_dir\\$source_file $CabFileName >nul 2>nul");
# check for errors
if ($ERRORLEVEL) {
logerror("545: COPY of file $source_dir\\$source_file failed (ErrorLevel $ERRORLEVEL)");
}
# Get the size of the file, so the size requirements of the cab can be computed.
$FileSize = (stat("$CabFileName"))[7];
printf("adding $CabFileName size $FileSize\n") if ($CABDEBUG);
$TotalSize += $FileSize;
# Write the DestinationFileName, CabFileName into the inf so the files
# can be extracted and installed properly.
open(hDDF, ">>${cabname}_SourceDisk")
|| die("Couldn't write to ${cabname}_SourceDisk: $!\n");;
printf(hDDF "${CabFileName}=1,,$FileSize\n");
close(hDDF);
open(hDDF, ">>${cabname}_SourceFiles");
printf(hDDF "$source_file,$CabFileName,,\n");
close(hDDF);
}
# If there were not files, just leave
if ($FileIndex == -1) {
logerror("241: No files in the cab ($cabname)");
unlink("$filelist") ||die("$!\n");;
unlink("${cabname}_SourceFiles") ||die("$!\n");;
unlink("${cabname}_SourceDisk") ||die("$!\n");;
unlink("${cabname}_DestDirsFiles")||die("$!\n");;
return(15);
}
if ($verbose) {
print STDERR "Creating $cabname\n";
}
# Create the INF
CreateINF($cabname, $friendlyname, $InfCopyFileList, $FileIndex, $TotalSize);
# start cabarc
CreateNewProcess($cabname, $kit);
# Delete the temporary file list
unlink("$filelist");
return(1);
}
# --------------------------------------------------------------------------
# Builds the installation inf
# --------------------------------------------------------------------------
sub CreateINF {
my $CabName = shift;
my $FriendlyName = shift;
my $InfCopyFileList = shift;
my $FileIndex = shift;
my $TotalSize = shift;
my @lines;
open(hFILE, ">>${CabName}.inf")||return(25);
print hFILE<<EOF;
[Version]
AdvancedInf = 2
Signature =\"\$CHICAGO\$\"
SetupClass = Base
[DefaultInstall]
CopyFiles=${InfCopyFileList}
CustomDestination= PDCDest
RequiredEngine = setupapi;
AddReg = RegVersion,DocKey
[DefaultUninstall]
DelFiles=${InfCopyFileList}
CustomDestination= PDCDest
DelReg = RegVersion,DocKey
EOF
open(hADDFILE, "<${CabName}_DestDirsFiles");
@lines=<hADDFILE>;
close(hADDFILE);
foreach (@lines) {
printf(hFILE "$_");
}
unlink("${CabName}_DestDirsFiles")||die("$!\n");;
print hFILE<<EOF;
InfFiles=17,\"msddk\\${bldno}\"
DefaultDestDir=49000,\"${CabName}\"
[RegVersion]
\"HKLM\",\"SOFTWARE\\Microsoft\\WINDDK\\Restart\\Cabs\",\"${CabName}\",0,\"done\"
[PDCDest]
49000,49001,49002=SDKCust, 17
[SDKCust]
;if key below exists, use this string to seed install path
\"HKLM\", \"Software\\Microsoft\\WINDDK\", \"SFNDirectory\",,\"%DefaultDir%\"
[DocKey]
[InfFiles]
${CabName}.inf
EOF
open(hADDFILE, "<${CabName}_SourceFiles");
@lines=<hADDFILE>;
close(hADDFILE);
foreach (@lines) {
printf(hFILE "$_");
}
unlink("${CabName}_SourceFiles")||die("$!\n");;
printf(hFILE "\n");
printf(hFILE "[SourceDisksNames]\n");
printf(hFILE "1=\"${CabName}.cab\",${CabName}.cab,0\n");
open(hADDFILE, "<${CabName}_SourceDisk");
@lines=<hADDFILE>;
close(hADDFILE);
foreach (@lines) {
printf(hFILE "$_");
}
unlink("${CabName}_SourceDisk")||die("$!\n");
$FileIndex++;
printf(hFILE "\n\n");
printf(hFILE "[Strings]\n");
printf(hFILE "FriendlyName=${FriendlyName}\n");
printf(hFILE "AppKey=SOFTWARE\\Microsoft\\WINDDK\n");
printf(hFILE "FileCount=${FileIndex}\n");
printf(hFILE "TotalSize=${TotalSize}\n");
close(hFILE);
return(0);
}
# --------------------------------------------------------------------------
# Starts a new process once there is room in the process table
# --------------------------------------------------------------------------
sub CreateNewProcess {
my $CabName = shift;
my $kit = shift;
my $ERRORLEVEL = 0;
my $ExitCode = 0;
my $i;
# Limit total running processes- label/goto construct needed because otherwise
# all processes are tested for instead of just finding the first one that has
# finished.
top:
while (@Processes >= $MAX_PROCESSES) {
for ($i=0;$i<=$#Processes;$i++) {
$Processes[$i][0]->GetExitCode( $ExitCode );
if ($ExitCode != 259 ) {
# Do post processes commands before removing it
$ERRORLEVEL= system("move /Y $Processes[$i][1].CAB $ENV{_NTTREE}\\$Processes[$i][2]_cd\\Common >nul 2>nul");
logerror("341: $Processes[$i][1].CAB could not be placed") if ($ERRORLEVEL);
$ERRORLEVEL= system("move /Y $Processes[$i][1].INF $ENV{_NTTREE}\\$Processes[$i][2]_cd\\Common >nul 2>nul");
logerror("342: $Processes[$i][1].INF could not be placed") if ($ERRORLEVEL);
$ERRORLEVEL=system("del /f $Processes[$i][1]_FILE_* 2>nul");
splice(@Processes,$i,1);
$i--; # Decrement count since the array changed
goto top;
}
}
sleep(2);
}
# Create the new process
Win32::Process::Create($i, $exe, "$exe $global_param ${CabName}.cab ${CabName}_FILE_*",
0, DETACHED_PROCESS, "$ENV{TEMP}");
# Update the process table
push(@Processes, [$i,$CabName,$kit]);
}
# --------------------------------------------------------------------------
# Waits for all currently running processes to finish
# --------------------------------------------------------------------------
sub WaitForAllProcesses {
my $i;
my $ERRORLEVEL = 0;
for ($i=0;$i<=$#Processes;$i++) {
# Wait for current process to end
print(".") unless ($verbose);
$Processes[$i][0]->Wait( INFINITE );
# Do post processes commands
$ERRORLEVEL= system("move /Y $Processes[$i][1].CAB $ENV{_NTTREE}\\$Processes[$i][2]_cd\\Common >nul 2>nul");
$ERRORLEVEL+=system("move /Y $Processes[$i][1].INF $ENV{_NTTREE}\\$Processes[$i][2]_cd\\Common >nul 2>nul");
logerror(__LINE__.": $Processes[$i][1] could not be placed") if ($ERRORLEVEL);
$ERRORLEVEL=system("del /f $Processes[$i][1]_FILE_* 2>nul");
}
print("\n");
}
# --------------------------------------------------------------------------
# Error logging routines
# --------------------------------------------------------------------------
sub logdebug { my($errormsg)="DEBUG_MSG : @_";
logprint($errormsg);
return(TRUE);}
sub logerror { my($errormsg)="ERROR_MSG : @_";
logprint($errormsg);
return(TRUE);}
sub logmsg { my($errormsg)="BUILD_MSG : @_";
logprint($errormsg);
return(TRUE);}
sub logprint { open(hLogFile,">>$handle")||warn("@_\n");
printf(hLogFile "$0 : @_\n");
close(hLogFile);
return(TRUE);}
# --------------------------------------------------------------------------
# Program description and usage
# --------------------------------------------------------------------------
sub Usage {
print "
Usage: $0 [-n <N>] [-f] [-l <language>] [-s] [-v]
This tool requires a Razzle window.
Generates CABs for the Kernelmode Development Kits. N, which is
optional, indicates the number of processes to start per processor.
The default value is 2.
By default, $0 will exit early if the environment variable
OFFICAL_BUILD_MACHINE is not defined. To override this behavior,
and for CAB generation, use -F.
-L is used, and any language other than 'usa' is passed, CAB
generation will not take place.
-V turns on verbose mode. See what cabs are being built.
-S spoofs full postbuild. (DDKCabs.bat otherwise relies upon build_number.cmd)
Dependencies:
o The following environment variables are expected to be defined:
%_NTDRIVE%, %_NTROOT%, %_BUILDARCH%, %_BUILDTYPE%, %_NTTREE%,
%RazzleToolPath%, %NUMBER_OF_PROCESSORS%, %TEMP%, and
%PROCESSOR_ARCHITECTURE%.
o The following directory trees are assumed to exist:
1) %_NTTREE%\\ddk_cd
2) %_NTTREE%\\ddk_flat
3) %_NTTREE%\\ifs_cd
4) %_NTTREE%\\ifs_flat
5) %_NTTREE%\\hal_cd
6) %_NTTREE%\\hal_flat
";
return(30);
}
__END__
:endofperl
Reference in a new issue Copy permalink