windows-xp/Source/XPSP1/NT/tools/postbuildscripts/cddata.cmd

@echo off
REM  ------------------------------------------------------------------
REM
REM  cddata.cmd
REM     Reads inf files and generates file lists for postbuild
REM
REM  Copyright (c) Microsoft Corporation. All rights reserved.
REM
REM  ------------------------------------------------------------------
perl -x "%~f0" %*
goto :EOF
#!perl
use strict;
use File::Basename;
use IO::File;

use lib $ENV{RAZZLETOOLPATH} . "\\PostBuildScripts";
use lib $ENV{RAZZLETOOLPATH};
use PbuildEnv;
use ParseArgs;
use Logmsg;
use cksku;
use A2U;

BEGIN {
    # A2u is setting itself as the script_name
    $ENV{SCRIPT_NAME} = 'cddata.cmd';
}

sub Usage { print<<USAGE; exit(1) }
cddata [-f] [-c] [-d] [-x] [-g <search>] [-o <filename>] [-l <language>]

    -f            Force list generation -- don't read old list
    -c            Create CDFs
    -d            Create CD lists (compression lists, link lists)
    -t            Create exTension lists
    -x            Don't truncate against bindiff file
    -g <search>   Print to STDOUT or <Filename> the results
                  of a search on the given input (see below)
    -o <filename> Send search output to the given filename
    -n            Make dosnet checks

    For the search command, valid expressions are:
    Field=xxx     Return entries whose "Field" is exactly xxx
    Field?yyy     Return entries whose "Field" contains yyy
    Field!zzz     Return entries whose "Field" does not contain zzz
    Field1=xxx:Field2=yyy logically 'and's results

Field names can be found in the keylist file
USAGE

# avoid search and replace for now, new template sets lang in the env.
my $lang = $ENV{lang};

# global switches/values set on the command line
my ($ForceCreate, $CreateCDFs, $CreateLists, $CreateExtLists, $NoUseBindiff, 
    $ArgSearchList, $OutputFile, $MakeDosnetChecks);

parseargs('?' => \&Usage,
          'f' => \$ForceCreate,
          'c' => \$CreateCDFs,
          'd' => \$CreateLists,
          'x' => \$NoUseBindiff,
          't' => \$CreateExtLists,
          'g:'=> \$ArgSearchList,
          'o:'=> \$OutputFile,
          'n' => \$MakeDosnetChecks);


# Global variables
my( $LogFilename );
my( $TempDir );
my( $Argument, $KeyFileName, $i );
my( $nttree, $razpath );
my( $BigDosnet, $PerDosnet, $BlaDosnet, $SbsDosnet, $SrvDosnet, $EntDosnet, $DtcDosnet );
my( $BigDrvIndex, $PerDrvIndex, $BlaDrvIndex, $SbsDrvIndex, $SrvDrvIndex, $EntDrvIndex, $DtcDrvIndex );
my( $BigExc, $PerExc, $BlaExc, $SbsExc, $SrvExc, $EntExc, $DtcExc, $Media, $DrmTxt );
my( $Excludes, $Specsign, $Subdirs, $Layout, $LayoutTXT );
my( $BigPrint, $BldArch, $AmX86 );
my( @StructFields, $NumFields, %FieldLocations, @StructDefaults );
my( $DefaultSettings, $Default, @KeyListLines, %Hash, $KeyListLine );
my( $KeyValues, @TheseSettings, $CurSet, $Key, @PrinterFiles, %Drmfiles );
my( $Printer, $FieldName, @SearchPatterns, $SOperator, $SFieldName );
my( $SFlagValue, $SearchHitCount, $FoundFlag, $SearchPattern );
my( $BinDiffFile, $KeyFileName2, $IncFlag, $RootCdfDir);
my( %CopyLocations );
my( %CDDataSKUs );
my( @ConvertList );
my (%TabHash);


# call into the Main sub, too much indentation to make this
#   toplevel right now
&Main();

sub Main {
    # /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
    # Begin Main code section
    # /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
    # Return when you want to exit on error
    # <Implement your code here>

    $Logmsg::DEBUG = 0; # set to 1 to activate logging of dbgmsg's
    $LogFilename = $ENV{ "LOGFILE" };
    if ( ! defined( $LogFilename ) ) {
	$TempDir = $ENV{ "TMP" };
	$LogFilename = "$TempDir\\$0.log";
    }

    timemsg( "Beginning ...", $LogFilename );

    $KeyFileName = "cddata.txt";

    # set up paths to important files
    $nttree = $ENV{ "_NTPostBld" };
    $razpath= $ENV{ "RazzleToolPath" };
    $TempDir = $ENV{ "TMP" };
    $BigDosnet = $nttree . "\\dosnet.inf";
    $PerDosnet = $nttree . "\\perinf\\dosnet.inf";
    $BlaDosnet = $nttree . "\\blainf\\dosnet.inf";
    $SbsDosnet = $nttree . "\\sbsinf\\dosnet.inf";
    $SrvDosnet = $nttree . "\\srvinf\\dosnet.inf";
    $EntDosnet = $nttree . "\\entinf\\dosnet.inf";
    $DtcDosnet = $nttree . "\\dtcinf\\dosnet.inf";
    $BigDrvIndex = $nttree . "\\drvindex.inf";
    $PerDrvIndex = $nttree . "\\perinf\\drvindex.inf";
    $BlaDrvIndex = $nttree . "\\blainf\\drvindex.inf";
    $SbsDrvIndex = $nttree . "\\sbsinf\\drvindex.inf";
    $SrvDrvIndex = $nttree . "\\srvinf\\drvindex.inf";
    $EntDrvIndex = $nttree . "\\entinf\\drvindex.inf";
    $DtcDrvIndex = $nttree . "\\dtcinf\\drvindex.inf";
    $BigExc = $nttree . "\\excdosnt.inf";
    $PerExc = $nttree . "\\perinf\\excdosnt.inf";
    $BlaExc = $nttree . "\\blainf\\excdosnt.inf";
    $SbsExc = $nttree . "\\sbsinf\\excdosnt.inf";
    $SrvExc = $nttree . "\\srvinf\\excdosnt.inf";
    $EntExc = $nttree . "\\entinf\\excdosnt.inf";
    $DtcExc = $nttree . "\\dtcinf\\excdosnt.inf";
    $Media = $nttree . "\\congeal\_scripts\\\_media.inx";
    $DrmTxt = $nttree . "\\congeal\_scripts\\drmlist.txt";
    $Excludes = $razpath . "\\PostBuildScripts\\exclude.lst";
    $Specsign = $razpath . "\\PostBuildScripts\\specsign.lst";
    $Subdirs = $razpath . "\\PostBuildScripts\\subdirs.lst";
    $Layout = $nttree . "\\congeal\_scripts\\layout.inx";
    $LayoutTXT = $nttree . "\\congeal\_scripts\\layout.txt";
    $BinDiffFile = $nttree . "\\build\_logs\\bindiff.txt";
    $RootCdfDir = "$TempDir\\CDFs";

    %CDDataSKUs = map({uc$_ => cksku::CkSku($_, $lang, $ENV{_BuildArch})} qw(PRO PER SRV BLA SBS ADS DTC));

    # Remove the RootCdfDir
    system ( "if exist $RootCdfDir rd /s /q $RootCdfDir" );

    # Set IncFlag to false until we know otherwise
    $IncFlag = "FALSE";

    $BigPrint = $nttree . "\\ntprint.inf";
    $BldArch = $ENV{ "\_BuildArch" };
    undef( $AmX86 );
    if ( ( $BldArch =~ /x86/i ) || ( $BldArch =~ /amd64/i ) || ( $BldArch =~ /ia64/i ) ) {
	$AmX86 = "TRUE";
    }

    # enumerate fields
    # Signed -- am i catalog signed?
    # Prods -- what prods am i in? any combo in order of w, p, s, e, d
    # Driver -- am i in driver.cab? i.e., did i come from an excdosnt?
    # Comp -- do i get compress by default?
    # Print -- am i a printer?
    # Dosnet -- did i come from a dosnet?
    # Unicode -- do i get converted to unicode?
    # DrvIndex -- which drivercab am i in? i.e. w p s e d
    # DrmLevel -- am i drm encrypted?
    # Tablet -- am i a Tablet PC File
    #
    # also, see default settings for each of these fields just below.
    @StructFields = ( "Signed", "Prods", "Driver", "Comp", "Print", "Dosnet",
		      "Unicode", "DrvIndex", "DRMLevel" ,"TabletPC"); # CHANGEME
    $NumFields = @StructFields;
    %FieldLocations = {};
    for ( $i = 0; $i < $NumFields; $i++ ) {
	$FieldLocations{ $StructFields[ $i ] } = $i;
    }

    # create defaults
    @StructDefaults = ( "t", "nul", "f", "t", "f", "f", "f",
			"nul", "f" ,"f"); # CHANGEME
    undef( $DefaultSettings );
    foreach $Default ( @StructDefaults ) {
	if ( defined( $DefaultSettings ) ) {
	    $DefaultSettings .= "\:$Default";
	}
	else { $DefaultSettings = $Default; }
    }

    # see if we've already made our lists. if so, don't regen them.
    if ( ( ! ( defined( $ForceCreate ) ) ) &&
	 ( -e "$TempDir\\$KeyFileName" ) ) {
	logmsg( "Reading previously created key list ...",
			 $LogFilename );
	# read in the list instead of creating it
	unless ( open( INFILE, "$TempDir\\$KeyFileName" ) ) {
	    errmsg( "Failed to parse old keylist.txt.",
			     $LogFilename );
	    exit( 1 );
	}
	
	@KeyListLines = <INFILE>;
	close( INFILE );

	undef( %Hash );
	foreach $KeyListLine ( @KeyListLines ) {
	    chomp( $KeyListLine );
	    if ( ( length( $KeyListLine ) == 0 ) ||
		 ( substr( $KeyListLine, 0, 1 ) eq ";" ) ) { next; }
	    # <filename> = a:bbbb:c:d:e:f
	    $KeyListLine =~ /^(\S*)( = )(\S*)$/;
	    $KeyFileName2 = $1; $KeyValues = $3;
	    @TheseSettings = split( /\:/, $KeyValues );
	    undef( $CurSet );
	    for ( $i = 0; $i < $NumFields; $i++ ) {
		if ( defined( $CurSet ) ) {
		    $CurSet .= ":$StructFields[$i]\=$TheseSettings[$i]";
		} else {
		    $CurSet = "$StructFields[$i]\=$TheseSettings[$i]";
		}
	    }
	    &NewSettings( $KeyFileName2, $CurSet );
	}

	if ( -e $BinDiffFile ) { &HandleDiffFiles(); }

	if ( defined( $MakeDosnetChecks ) ) {
	    &CheckDosnet( $BigDosnet );# if ( $CDDataSKUs{'PRO'});
	    &CheckDosnet( $PerDosnet );# if ( $CDDataSKUs{'PER'});
	    &CheckDosnet( $SrvDosnet );# if ( $CDDataSKUs{'SRV'});
	    &CheckDosnet( $BlaDosnet );# if ( $CDDataSKUs{'BLA'});
	    &CheckDosnet( $SbsDosnet );# if ( $CDDataSKUs{'SBS'});
	    &CheckDosnet( $EntDosnet );# if ( $CDDataSKUs{'ADS'});
	    &CheckDosnet( $DtcDosnet );# if ( $CDDataSKUs{'DTC'});
	}

	logmsg( "Writing keylist to $KeyFileName ...", $LogFilename );
	unless ( open( OUTFILE, ">$TempDir\\$KeyFileName" ) ) {
	    errmsg( "Failed to open $KeyFileName for writing.",
			     $LogFilename );
	    exit( 1 );
	}

	print( OUTFILE "; Fields are listed as follows:\n; " );
	foreach $FieldName ( @StructFields ) {
	    print( OUTFILE " $FieldName" );
	}
	print( OUTFILE "\n" );
	
	foreach $Key ( keys( %Hash ) ) {
	    print( OUTFILE "$Key = $Hash{ $Key }\n" );
	}
	
	close( OUTFILE );
	
    } else {
	
	# begin!
	undef( %Hash );
	undef( %CopyLocations );
	# Need to get these for all flavors as
        # this is a cumulative thing DTC = ADS + SRV + PRO
        &AddDosnet( $BigDosnet, "Prods+w:Dosnet=t" );
	&AddDosnet( $PerDosnet, "Prods+p:Dosnet=t" );
	&AddDosnet( $SrvDosnet, "Prods+s:Dosnet=t" );
	&AddDosnet( $BlaDosnet, "Prods+b:Dosnet=t" );
	&AddDosnet( $SbsDosnet, "Prods+l:Dosnet=t" );
	&AddDosnet( $EntDosnet, "Prods+e:Dosnet=t" );
	&AddDosnet( $DtcDosnet, "Prods+d:Dosnet=t" );
	# EXCDOSNT is built during postbuild, only for
        # required flavors -- note that AddDosnet() in this
        # case is actually "removing" files from dosnet
        # (marking them as Dosnet=f and Comp=f")
        &AddDosnet( $BigExc, "Driver=t:Prods+w:Dosnet=f:Comp=f" ) if ( $CDDataSKUs{'PRO'});
	&AddDosnet( $PerExc, "Driver=t:Prods+p:Dosnet=f:Comp=f" ) if ( $CDDataSKUs{'PER'});
	&AddDosnet( $SrvExc, "Driver=t:Prods+s:Dosnet=f:Comp=f" ) if ( $CDDataSKUs{'SRV'});
	&AddDosnet( $BlaExc, "Driver=t:Prods+b:Dosnet=f:Comp=f" ) if ( $CDDataSKUs{'BLA'});
	&AddDosnet( $SbsExc, "Driver=t:Prods+l:Dosnet=f:Comp=f" ) if ( $CDDataSKUs{'SBS'});
	&AddDosnet( $EntExc, "Driver=t:Prods+e:Dosnet=f:Comp=f" ) if ( $CDDataSKUs{'ADS'});
	&AddDosnet( $DtcExc, "Driver=t:Prods+d:Dosnet=f:Comp=f" ) if ( $CDDataSKUs{'DTC'});
	&AddDosnet( $Media, "Prods=wpsbled" );
	
	# now add specsign.lst files and subdirs.lst files
	&AddSpecsign( $Specsign );
	&AddSubdirs( $Subdirs );
	
	# at this point, we have all files from dosnet's excdosnt's and _media
	# now, if a key is in sedinf dir, add a listing for sedinf\key
	logmsg( "Adding keys for files in perinf, blainf, sbsinf, srvinf, entinf, dtcinf ...", $LogFilename );
	foreach $Key ( keys( %Hash ) ) {
	    $Key = "\L$Key";
	    if ( -e "$nttree\\dtcinf\\$Key" ) {
		$Hash{ "dtcinf\\$Key" } = $Hash{ $Key };
		&ChangeSettings( "dtcinf\\$Key", "Prods-w:Prods-p:Prods-s:Prods-e:Prods-b:Prods-l" );
		if ( &GetFlag( "dtcinf\\$Key", "Prods" ) eq "nul" ) {
		    delete( $Hash{ "dtcinf\\$Key" } );
		}
		if ( defined( $Hash{ $Key } ) ) {
		    &ChangeSettings( $Key, "Prods-d" );
		}
	    }
	    if ( -e "$nttree\\entinf\\$Key" ) {
		$Hash{ "entinf\\$Key" } = $Hash{ $Key };
		&ChangeSettings( "entinf\\$Key", "Prods-w:Prods-p:Prods-s:Prods-b:Prods-l" );
		if ( &GetFlag( "entinf\\$Key", "Prods" ) eq "nul" ) {
		    delete( $Hash{ "entinf\\$Key" } );
		}
		if ( defined( $Hash{ $Key } ) ) {
		    &ChangeSettings( $Key, "Prods-e:Prods-d" );
		}
		if ( &GetFlag( $Key, "Prods" ) eq "nul" ) { delete( $Hash{ $Key } ); }
            }
	    if ( -e "$nttree\\blainf\\$Key" ) {
		$Hash{ "blainf\\$Key" } = $Hash{ $Key };
		&ChangeSettings( "blainf\\$Key", "Prods-w:Prods-p:Prods-s:Prods-e:Prods-d:Prods-l" );
		if ( &GetFlag( "blainf\\$Key", "Prods" ) eq "nul" ) {
		    delete( $Hash{ "blainf\\$Key" } );
		}
		if ( defined( $Hash{ $Key } ) ) {
		    &ChangeSettings( $Key, "Prods-b" );
		}
            }
	    if ( -e "$nttree\\sbsinf\\$Key" ) {
		$Hash{ "sbsinf\\$Key" } = $Hash{ $Key };
		&ChangeSettings( "sbsinf\\$Key", "Prods-w:Prods-p:Prods-s:Prods-e:Prods-d:Prods-b" );
		if ( &GetFlag( "sbsinf\\$Key", "Prods" ) eq "nul" ) {
		    delete( $Hash{ "sbsinf\\$Key" } );
		}
		if ( defined( $Hash{ $Key } ) ) {
		    &ChangeSettings( $Key, "Prods-l" );
		}
            }	    
	    if ( -e "$nttree\\srvinf\\$Key" ) {
		$Hash{ "srvinf\\$Key" } = $Hash{ $Key };
		&ChangeSettings( "srvinf\\$Key", "Prods-w:Prods-p" );
		if ( &GetFlag( "srvinf\\$Key", "Prods" ) eq "nul" ) {
		    delete( $Hash{ "srvinf\\$Key" } );
		}
		if ( defined( $Hash{ $Key } ) ) {
		    &ChangeSettings( $Key, "Prods-l:Prods-b:Prods-s:Prods-e:Prods-d" );
		}
	    }
	    if ( -e "$nttree\\perinf\\$Key" ) {
		$Hash{ "perinf\\$Key" } = $Hash{ $Key };
		&ChangeSettings( "perinf\\$Key", "Prods-w:Prods-s:Prods-b:Prods-l" );
		if ( &GetFlag( "perinf\\$Key", "Prods" ) eq "nul" ) {
		    delete( $Hash{ "perinf\\$Key" } );
		}
		if ( defined( $Hash{ $Key } ) ) {
		    &ChangeSettings( $Key, "Prods-p" );
		}
	    }
	    if ( &GetFlag( $Key, "Prods" ) eq "nul" ) {
		delete( $Hash{ $Key } );
	    }
	}

	# mark all driver files
	if ( $CDDataSKUs{ 'PRO' } ) {
	    &AddDrvIndex( $BigDrvIndex, "DrvIndex+w", "pro" );
	}
	if ( $CDDataSKUs{ 'PER' } ) {
	    &AddDrvIndex( $PerDrvIndex, "DrvIndex+p", "per" );
	}
	if ( $CDDataSKUs{ 'SRV' } ) {
	    &AddDrvIndex( $SrvDrvIndex, "DrvIndex+s", "srv" );
	}
	if ( $CDDataSKUs{ 'BLA' } ) {
	    &AddDrvIndex( $BlaDrvIndex, "DrvIndex+b", "bla" );
	}
	if ( $CDDataSKUs{ 'SBS' } ) {
	    &AddDrvIndex( $SbsDrvIndex, "DrvIndex+l", "sbs" );
	}
	if ( $CDDataSKUs{ 'ADS' } ) {
	    &AddDrvIndex( $EntDrvIndex, "DrvIndex+e", "ads" );
	}
	if ( $CDDataSKUs{ 'DTC' } ) {
	    &AddDrvIndex( $DtcDrvIndex, "DrvIndex+d", "dtc" );
	}

	&SpecialExclusions();

	# mark all printer keys
	timemsg( "Marking all printer entries ...", $LogFilename );
	# @PrinterFiles = `infflist.exe $BigPrint`;
	# the GetPrinterFiles subroutine will populate the @PrinterFiles array
	# in the same manner that calling infflist.exe would.
	&GetPrinterFiles( $BigPrint );
	foreach $Printer ( @PrinterFiles ) {
	    chomp( $Printer );
	    if ( length( $Printer ) == 0 ) { next; }
	    &ChangeSettings( $Printer, "Print=t" );
	}

	# Get the list of files to convert to unicode.
	@ConvertList = &A2U::CdDataUpdate;
	foreach my $convertfile ( @ConvertList ) {
	    &ChangeSettings( $convertfile, "Unicode=t" );
	}
        #
        # Get the list of files with DRMLevel attributes
        #
        undef(%Drmfiles);
        &GetDrmFiles( \%Drmfiles, $DrmTxt );
        foreach $Key ( sort keys %Drmfiles )
        {
            chomp $Key;
            if( length( $Key ) == 0 ) { next; }
            &ChangeSettings( $Key, "DRMLevel=$Drmfiles{$Key}" );
        }

	# mark all uncompressable keys
	timemsg( "Marking all uncompressable entries ...",
			  $LogFilename );
	&MarkUncomps( $Layout );
	&MarkUncomps( $Media );
	&MarkUncomps( $LayoutTXT );

	# mark all unsigned keys and remove non-existent key/files:
	# unsigned files are printers, *.cat, and things in exclude.lst
	&ExcludeSigning( $Excludes ); # must be done after subdirs.lst !!!
	logmsg( "Marking all unsignable entries ...", $LogFilename );
	foreach $Key ( keys( %Hash ) ) {
	    if ( ( ! ( -e "$nttree\\$Key" ) ) &&
		 ( substr( $Key, -4, 4 ) ne ".cat" ) ) {
		delete( $Hash{ $Key } );
	    }
	    elsif ( ( &GetFlag( $Key, "Print" ) eq "t" ) ||
		    ( substr( $Key, -4, 4 ) eq ".cat" ) ) {
		&ChangeSettings( $Key, "Signed=f" );
	    }
	}

	# save off a copy of the full key file for bindiff.pl to cue off of
	if ( ( ! ( -e "$TempDir\\$KeyFileName.full" ) ) ||
	     ( defined( $ForceCreate ) ) ) {
	    logmsg( "Writing keylist to $KeyFileName.full ...",
			     $LogFilename );
	    unless ( open( OUTFILE, ">$TempDir\\$KeyFileName.full" ) ) {
		errmsg( "Failed to open $KeyFileName.full for " .
				 "writing.", $LogFilename );
		exit( 1 );
	    }
	
	    print( OUTFILE "; Fields are listed as follows:\n; " );
	    foreach $FieldName ( @StructFields ) {
		print( OUTFILE " $FieldName" );
	    }
	    print( OUTFILE "\n" );

	    foreach $Key ( keys( %Hash ) ) {
		print( OUTFILE "$Key = $Hash{ $Key }\n" );
	    }
	}
	close( OUTFILE );
	if ( -e "$TempDir\\$KeyFileName.full" ) {
	    system( "copy $TempDir\\$KeyFileName.full $nttree\\build_logs" .
		    "\\$KeyFileName.full" );
	}
	
	if ( -e $BinDiffFile ) { &HandleDiffFiles(); }
	
	# at this point, we'll check our dosnets if asked.
	if ( defined( $MakeDosnetChecks ) ) {
	    &CheckDosnet( $BigDosnet );
	    &CheckDosnet( $PerDosnet );
	    &CheckDosnet( $BlaDosnet );
	    &CheckDosnet( $SbsDosnet );
	    &CheckDosnet( $SrvDosnet );
	    &CheckDosnet( $EntDosnet );
	    &CheckDosnet( $DtcDosnet );
	}
	
	# jeezuz! we're done!
	
	if ( ( ! ( -e "$TempDir\\$KeyFileName" ) ) ||
	     ( defined( $ForceCreate ) ) ) {
	    logmsg( "Writing keylist to $KeyFileName ...",
			     $LogFilename );
	    unless ( open( OUTFILE, ">$TempDir\\$KeyFileName" ) ) {
		errmsg( "Failed to open $KeyFileName for writing.",
				 $LogFilename );
		exit( 1 );
	    }
	
	    print( OUTFILE "; Fields are listed as follows:\n; " );
	    foreach $FieldName ( @StructFields ) {
		print( OUTFILE " $FieldName" );
	    }
	    print( OUTFILE "\n" );

	    foreach $Key ( keys( %Hash ) ) {
		print( OUTFILE "$Key = $Hash{ $Key }\n" );
	    }
	}
	close( OUTFILE );
    }


    if ( defined( $ArgSearchList ) ) {
	logmsg( "Search pattern is \'$ArgSearchList\' ...",
			 $LogFilename );
	# user has asked to see a search on the hash
	if ( defined( $OutputFile ) ) {
	    if ( open( OUTFILE, ">$OutputFile" ) ) {
		print( OUTFILE "; Results for search $ArgSearchList\n" );
	    } else {
		errmsg( "Failed to open $OutputFile for writing.",
				 $LogFilename );
		undef( $OutputFile );
	    }
	}
	@SearchPatterns = split( /\:/, $ArgSearchList );
	$SearchHitCount = 0;
	foreach $Key ( keys( %Hash ) ) {
	    $FoundFlag = "TRUE";
	    foreach $SearchPattern ( @SearchPatterns ) {
		$SearchPattern =~ /^(\S*)([\=\?\!])(\S*)$/;
		$SOperator = $2;
		$SFieldName = $1; $SFlagValue = $3;
		if ( ( $SOperator eq "\=" ) &&
		     ( &GetFlag( $Key, $SFieldName ) ne $SFlagValue ) ) {
		    $FoundFlag = "FALSE";
		} elsif ( ( $SOperator eq "\?" ) &&
			  ( &GetFlag( $Key, $SFieldName ) !~
			    /$SFlagValue/ ) ) {
		    $FoundFlag = "FALSE";
		} elsif ( ( $SOperator eq "\!" ) &&
			  ( &GetFlag( $Key, $SFieldName ) =~
			      /\Q$SFlagValue\E/ ) ) {
		    $FoundFlag = "FALSE";
		} # matches if
	    } # matches foreach
	    if ( $FoundFlag eq "TRUE" ) {
		$SearchHitCount++;
		if ( defined( $OutputFile ) ) {
		    print( OUTFILE "$Key = " . $Hash{ $Key } . "\n" );
		} else {
		    print( "$Key = " . $Hash{ $Key } . "\n" );
		}
	    }
	}
	if ( defined( $OutputFile ) ) { close( OUTFILE ); }
	logmsg( "Files found: $SearchHitCount" );
    }

    # now we can generate cdfs and any other lists we need
    &MakeLists();

    # Generate extension lists for rebase/rebind
    MakeExtensionLists() if ($IncFlag eq "FALSE" || defined $CreateExtLists);

    timemsg( "Finished.", $LogFilename );

    # /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
    # End Main code section
    # /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
}

# <Implement your subs here>

sub AddDosnet
{
    my( $DosnetName, $StructSettings ) = @_;
    my( $File, @Files, $FileName,$Key );
    my( $FileSpec, @FileSpecs, $ThisProd );

    logmsg( "Adding files in $DosnetName ...", $LogFilename );

    @Files = &ReadDosnet( $DosnetName );
    unless ( defined( @Files ) ) {
	errmsg( "Can't add $DosnetName files to hash.",
			 $LogFilename );
	return( undef );
    }

    foreach $File ( @Files ) {
	chomp( $File );
	if ( length( $File ) == 0 ) { next; }
	$File = "\L$File";
	if ( defined( $Hash{ $File } ) ) {
	    &ChangeSettings( $File, $StructSettings );
	} else {
	    &NewSettings( $File, $StructSettings );
	}
    }
    if (%TabHash) {
	foreach $Key ( keys(%TabHash) ) {
		    &ChangeSettings( $Key,"TabletPC=t" );
	}
    }
    return( "TRUE" );
}

sub ReadDosnet
{
    my( $DosnetName ) = @_;
    my( $File, @Files, @Lines, $Line, $ReadFlag,$TabFlag, $ExtraStuff );
    my( $MyName, $Junk, $CopyLocation );

    $File = "\L$File";

    unless ( open( INFILE, $DosnetName ) ) {
	errmsg( "Failed to open $DosnetName", $LogFilename );
	return( undef );
    }

    @Lines = <INFILE>;
    close( INFILE );

    undef( @Files );
    $ReadFlag = "FALSE";
    undef (%TabHash);

    foreach $Line ( @Lines ) {
	chomp( $Line );
	if ( ( length( $Line ) == 0 ) ||
	     ( substr( $Line, 0, 1 ) eq ";" ) ||
	     ( substr( $Line, 0, 1 ) eq "#" ) ||
	     ( substr( $Line, 0, 2 ) eq "@*" ) ) { next; }
	if ( $Line =~ /^\[/ ) { $ReadFlag = "FALSE"; }
	if ( ( $Line =~ /^\[Files\]/ ) ||
	     ( $Line =~ /^\[SourceDisksFiles\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $AmX86 eq "TRUE" ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.x86\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $BldArch =~ /amd64/i ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.amd64\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $BldArch =~ /ia64/i ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.ia64\]/ ) ) {
	    $ReadFlag = "TRUE";
	}

	if ( $ReadFlag eq "TRUE" ) {
	    if ($Line =~ /^d2/) {
		$TabFlag="TRUE";
	    }
	    $Line =~ s/^d1\,//;
	    $Line =~ s/^d2\,//;
	    ( $MyName, $CopyLocation ) = split( /\,/, $Line );
	    ( $MyName, $Junk ) = split( /\s/, $MyName );
 	    push( @Files, $MyName );
            if ($TabFlag eq "TRUE") {
		    $TabHash{$MyName}="TRUE";
	       	    $TabFlag="FALSE";		    
	    }
	}
    }

    return( @Files );
}


sub ChangeSettings
{
    my( $File, $StructSettings ) = @_;
    my( @Requests, $Request );
    my( @Currents, $Current, $NewSettings );
    my( $FldLoc, $Operator, $SetVal );

    if ( length( $File ) == 0 ) { return( undef ); }

    $File = "\L$File";

    if ( ! ( defined( $Hash{ $File } ) ) ) { return( undef ); }

    @Currents = split( /\:/, $Hash{ $File } );
    @Requests = split( /\:/, $StructSettings );
    foreach $Request ( @Requests ) {
	$Request =~ /^(\w+)([\=\+\-]{1})(\w+)$/;
	$FldLoc = $FieldLocations{ $1 };
	$Operator = $2; $SetVal = $3;
	# look for a "="
	if ( $Operator eq "\?" ) { next; }
	if ( $Operator eq "\=" ) {
	    # set the field explicitly
	    $Currents[ $FldLoc ] = $SetVal;
	}
	# look for a "+"
	elsif ( $Operator eq "\+" ) {
	    # add the field to the list if not there
	    if ( $Currents[ $FldLoc ] eq "nul" ) {
		$Currents[ $FldLoc ] = $SetVal;
	    } elsif ( ! ( $Currents[ $FldLoc ] =~ /$SetVal/ ) ) {
		$Currents[ $FldLoc ] .= $SetVal;
	    }
	}
	# look for a "-"
	elsif ( ( $Operator eq "\-" ) && ( $Currents[ $FldLoc ] ne "nul" ) ) {
	    # sub the field from the list if there
	    $Currents[ $FldLoc ] =~ s/$SetVal//;
	    if ( $Currents[ $FldLoc ] eq "" ) {
		$Currents[ $FldLoc ] = "nul";
	    }
	}
    }
    # make a string from @Currents
    undef( $NewSettings );
    foreach $Current ( @Currents ) {
	if ( defined( $NewSettings ) ) { $NewSettings .= "\:$Current"; }
	else { $NewSettings = $Current; }
    }
    $Hash{ $File } = $NewSettings;

    return( "TRUE" );
}


sub NewSettings
{
    my( $File, $StructSettings ) = @_;
    my( $DefaultString, $Default );

    $File = "\L$File";

    # use defaults for everything not in $StructSettings
    undef( $DefaultString );
    foreach $Default ( @StructDefaults ) {
	if ( defined( $DefaultString ) ) { $DefaultString .= "\:$Default"; }
	else { $DefaultString = $Default; }
    }
    $Hash{ $File } = $DefaultString;
    $StructSettings =~ s/\?/\=/g;
    &ChangeSettings( $File, $StructSettings );

    return( "TRUE" );
}


sub AddSpecsign
{
    my( $SpecFile ) = @_;
    my( @SpecLines, $Line );

    logmsg( "Adding files in $SpecFile ...", $LogFilename );
    unless ( open( INFILE, $SpecFile ) ) {
	errmsg( "Failed to open $SpecFile.", $LogFilename );
	return( undef );
    }

    @SpecLines = <INFILE>;
    close( INFILE );
    foreach $Line ( @SpecLines ) {
	chomp( $Line );
	if ( ( length( $Line ) == 0 ) ||
	     ( substr( $Line, 0, 1 ) eq ";" ) ) { next; }
	# add file with defaults to hash
	$Line = "\L$Line";
        if ( exists( $Hash{ $Line } ) ) {
	    &ChangeSettings( $Line, "Prods=wpsbled:Signed=t" );
	} else {
	    &NewSettings( $Line, "Prods=wpsbled:Signed=t:Comp=f" );
	}
    }

    return( "TRUE" );
}


sub AddSubdirs
{
    my( $SubdirsFile ) = @_;
    my( @DirsLines, $Line, $SubName );
    my( $DirName, $IsRecursive, @DirList, $TreeLen );

    logmsg( "Adding files in $SubdirsFile ...", $LogFilename );

    unless ( open( INFILE, $SubdirsFile ) ) {
	errmsg( "Failed to open $SubdirsFile.", $LogFilename );
	return( undef );
    }

    @DirsLines = <INFILE>;
    close( INFILE );
    $TreeLen = length( $nttree ) + 1;
    foreach $Line ( @DirsLines ) {
	chomp( $Line );
	if ( ( length( $Line ) == 0 ) || ( substr( $Line, 0, 1 ) eq ";" ) ) {
	    next;
	}
	( $DirName, $IsRecursive ) = split( /\s+/, $Line );
        if ( ! ( -e "$nttree\\$DirName" ) ) {
            wrnmsg( "$DirName from subdirs.lst does not exist,",
			     $LogFilename );
            wrnmsg( "skipping and continuing ...", $LogFilename );
            next;
        }
	if ( defined( $IsRecursive ) ) {
	    @DirList = `dir /a-d /b /s $nttree\\$DirName`;
	} else {
	    @DirList = `dir /a-d /b $nttree\\$DirName`;
	}
	foreach $SubName ( @DirList ) {
	    chomp( $SubName );
	    if ( defined( $IsRecursive ) ) {
		$SubName = substr( $SubName, $TreeLen );
	    } else {
		$SubName = "$DirName\\" . $SubName;
	    }
	    $SubName = "\L$SubName";
	    if ( length( $SubName ) == 0 ) { next; }
            if ( exists( $Hash{ $SubName } ) ) {
	        &ChangeSettings( $SubName, "Prods=wpsbled:Signed=t" );
	    } else {
	        &NewSettings( $SubName, "Prods=wpsbled:Signed=t:Comp=f" );
	    }
       
	    
            if ( $DirName eq "lang" ) {
		&ChangeSettings( $SubName, "Comp=t" );
	    }
	}
    }

    return( "TRUE" );
}


sub MarkUncomps
{
    my( $InfFile ) = @_;
    my( @InfLines, $Line, $ReadFlag );
    my( $LHS, $RHS, $FileName );
    my( @LeftStuff, @RightStuff );

    unless ( open( INFILE, $InfFile ) ) {
	errmsg( "Unable to open $InfFile.", $LogFilename );
	return( undef );
    }

    @InfLines = <INFILE>;
    close( INFILE );

    $ReadFlag = "FALSE";

    foreach $Line ( @InfLines ) {
	chomp( $Line );
	if ( ( length( $Line ) == 0 ) || ( substr( $Line, 0, 3 ) eq "@*:" ) ) {
	    next;
	}
	if ( $Line =~ /^\[/ ) { $ReadFlag = "FALSE"; }
	if ( ( $Line =~ /^\[Files\]/ ) ||
	     ( $Line =~ /^\[SourceDisksFiles\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $AmX86 eq "TRUE" ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.x86\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $BldArch =~ /amd64/i ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.amd64\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $BldArch =~ /ia64/i ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.ia64\]/ ) ) {
	    $ReadFlag = "TRUE";
	}
	elsif ( $ReadFlag eq "TRUE" ) {
	    if ( $Line =~ /\_/ ) {
		# there is an underscore, let's see where.
		$Line =~ s/\s//g;
		( $LHS, $RHS ) = split( /=/, $Line );
		@RightStuff = split( /\,/, $RHS );
		if ( $RightStuff[6] =~ /^\_/ ) {
		    @LeftStuff = split( /\:/, $LHS );
		    $FileName = pop( @LeftStuff );
		    $FileName = "\L$FileName";
		    &ChangeSettings( $FileName, "Comp=f" );
		    &ChangeSettings( "perinf\\$FileName", "Comp=f" );
		    &ChangeSettings( "srvinf\\$FileName", "Comp=f" );
		    &ChangeSettings( "blainf\\$FileName", "Comp=f" );
		    &ChangeSettings( "sbsinf\\$FileName", "Comp=f" );
		    &ChangeSettings( "entinf\\$FileName", "Comp=f" );
		    &ChangeSettings( "dtcinf\\$FileName", "Comp=f" );    
		}
	    }
	}
    }

    return( "TRUE" );
}


sub ExcludeSigning
{
    my( $ExcFile ) = @_;
    my( @ExcLines, $Line );

    unless ( open( INFILE, $ExcFile ) ) {
	errmsg( "Failed to open $ExcFile.", $LogFilename );
	return( undef );
    }

    @ExcLines = <INFILE>;
    close( INFILE );

    foreach $Line ( @ExcLines ) {
	chomp( $Line );
	if ( ( length( $Line ) == 0 ) || ( substr( $Line, 0, 1 ) eq ";" ) ) {
	    next;
	}
	&ChangeSettings( $Line, "Signed=f" );
    }

    return( "TRUE" );
}


sub GetFlag
{
    my( $Key, $FieldFlag ) = @_;
    my( @FieldList );

    @FieldList = split( /\:/, $Hash{ $Key } );
    return( $FieldList[ $FieldLocations{ $FieldFlag } ] );
}


sub MakeInfCdf
{
    my( $CdfName, $Product ) = @_;
    my( $Key, $Flags, $CdfDir, $CdfVolDir );
    my ( $CdfExt, $ThisInfName );

    if ( $IncFlag eq "TRUE") { $CdfExt = ".icr"; }
    else { $CdfExt = ".cdf"; }

    logmsg( "Generating \'$Product\' nt5inf$CdfExt ...",
		     $LogFilename );

    if ( $Product !~ /^(w|p|b|l|s|e|d)$/i ) {
       errmsg( "Invalid product '$Product'!" );
       return;
    }
    $ThisInfName = "" if ( $Product eq "w" );
    $ThisInfName = "\\perinf" if ( $Product eq "p" );
    $ThisInfName = "\\srvinf" if ( $Product eq "s" );
    $ThisInfName = "\\blainf" if ( $Product eq "b" );
    $ThisInfName = "\\sbsinf" if ( $Product eq "l" );
    $ThisInfName = "\\entinf" if ( $Product eq "e" );
    $ThisInfName = "\\dtcinf" if ( $Product eq "d" );
    
    $CdfDir    = "$TempDir\\CDFs". ( $ThisInfName ?"$ThisInfName":"" );
    system( "if not exist $CdfDir md $CdfDir" );
    
    # Open the CDF files for writing
    unless ( open( CDF, ">$CdfDir\\nt5inf$CdfExt" ) ) {
	errmsg( "Unable to open $CdfDir\\nt5inf$CdfExt for writing ($!).",
			 $LogFilename );
	return;
    }
    
    #print("$IncFlag");
    if ( $IncFlag eq "FALSE" ) {
         # put in CDF header crap
         foreach( ( "\[CatalogHeader\]",
                    "Name=nt5inf",
                    "PublicVersion=0x0000001",
                    "EncodingType=0x00010001",
                    "CATATTR1=0x10010001:OSAttr:2:5.1",
                    "",
                    "\[CatalogFiles\]" ) ) {
            print CDF "$_\n";
         }

         foreach $Key ( keys( %Hash ) ) {
	     $Flags = &GetFlag( $Key, "Prods" );
	     if ( ( $Flags ne "wpsbled" ) && ( $Flags ne "nul" ) &&
	          ( $Flags =~ /$Product/ ) &&
	          ( &GetFlag( $Key, "Signed" ) eq "t" ) ) {
	         print CDF "<hash>$nttree\\$Key=$nttree\\$Key\n";
	     }
         }
         # special exemptions
         # mark the wks layout.inf as signed in the srv nt5inf.cdf
         if ( $Product eq "s" ) {
              print CDF "<hash>$nttree\\layout.inf=$nttree\\layout.inf\n";
         }
     
     } else {
        foreach $Key ( keys( %Hash ) ) {
	    $Flags = &GetFlag( $Key, "Prods" );
	    if ( ( $Flags ne "wpsbled" ) && ( $Flags ne "nul" ) &&
	         ( $Flags =~ /$Product/ ) &&
	         ( &GetFlag( $Key, "Signed" ) eq "t" ) ) {
	        print CDF "$nttree\\$Key\n";
	    }
        }
        if  (( $Product eq "s" ) && ( $Hash{ "srvinf\\layout.inf" } )) {
             print CDF "$nttree\\layout.inf\n";
        }
    }
    close CDF;
    
    # copy the CDF to the build_logs for intl
    my( $BaseCopyDir ) = "$nttree\\build_logs\\cdfs$ThisInfName";
    mkdir( $BaseCopyDir, 0777 ) if ( ! -d $BaseCopyDir );
    
    my( $ReturnCode ) = system( "copy $CdfDir\\nt5inf$CdfExt $BaseCopyDir" );
    if ( $ReturnCode != 0 ) {
        wrnmsg( "Failed to copy a nt5inf.cdf into the build ...",
			 $LogFilename );
    }
}


sub MakeMainCdfs
{
    my( $CdfName ) = @_;
    my( $PrtName, $Key, $Flags, $DrmLevel );
    my ( $CdfExt );

    $DrmLevel = "ATTR1=0x10010001:DRMLevel:";

    if ( $IncFlag eq "TRUE") { $CdfExt = ".icr"; }
    else { $CdfExt = ".cdf"; }

    $PrtName = 'ntprint';

    logmsg( "Generating $CdfName$CdfExt and $PrtName$CdfExt ...",
		     $LogFilename );

    system( "if not exist $TempDir\\CDFs md $TempDir\\CDFs" );

    unless ( open( CDF, ">$TempDir\\CDFs\\$CdfName$CdfExt" ) ) {
	errmsg( "Unable to open $CdfName$CdfExt for writing.",
			 $LogFilename );
	return( undef );
    }
    unless ( open( PRINTER, ">$TempDir\\CDFs\\$PrtName$CdfExt" ) ) {
	errmsg( "Unable to open $PrtName$CdfExt for writing.",
			 $LogFilename );
	close( CDF );
	return( undef );
    }
    
    if ( $IncFlag eq "FALSE" ) {
        
        foreach( "\[CatalogHeader\]",
                 "Name=$CdfName",
                 "PublicVersion=0x0000001",
                 "EncodingType=0x00010001",
                 "CATATTR1=0x10010001:OSAttr:2:5.1",
                 "",
                 "\[CatalogFiles\]" ) {
                 
            print CDF "$_\n";
        }

        foreach( "\[CatalogHeader\]",
                 "Name=$PrtName",
                 "PublicVersion=0x0000001",
                 "EncodingType=0x00010001",
                 "CATATTR1=0x10010001:OSAttr:2:5.0,2:5.1",
                 "",
                 "\[CatalogFiles\]" ) {

            print PRINTER "$_\n";
        }

        foreach $Key ( keys( %Hash ) ) {
	    $Flags = &GetFlag( $Key, "Prods" );
	    if ( ( ( $Flags eq "wpsbled" ) || ( $Flags eq "nul" ) ) &&
	         ( &GetFlag( $Key, "Signed" ) eq "t" ) )
            {
	        print CDF "<hash>$nttree\\$Key=$nttree\\$Key\n";
	        print (CDF "<hash>$nttree\\$Key$DrmLevel", &GetFlag( $Key, "DRMLevel" ), "\n" ) if( &GetFlag( $Key, "DRMLevel" ) ne "f" );
	    }
	    if ( &GetFlag( $Key, "Print" ) eq "t" ) {
	        print PRINTER "<hash>$nttree\\$Key=$nttree\\$Key\n";
	    }
        }
    } else {
        foreach $Key ( keys( %Hash ) ) {
	    $Flags = &GetFlag( $Key, "Prods" );
	    if ( ( ( $Flags eq "wpsbled" ) || ( $Flags eq "nul" ) ) &&
	         ( &GetFlag( $Key, "Signed" ) eq "t" ) ) {
	        print CDF "$nttree\\$Key\n";
	    }
	    if ( &GetFlag( $Key, "Print" ) eq "t" ) {
	        print PRINTER "$nttree\\$Key\n";
	    }
        }
    }

    close CDF;
    close PRINTER;

    # copy the cdfs for intl
    my( $BaseCopyDir ) = "$nttree\\build_logs\\cdfs";
    mkdir( $BaseCopyDir, 0777 ) if ( ! -d $BaseCopyDir );
    my $ReturnCode = system( "copy $TempDir\\CDFs\\$CdfName$CdfExt $BaseCopyDir" );
    if ( $ReturnCode != 0 ) {
        wrnmsg( "Failed to copy nt5.cdf into the build ...",
			 $LogFilename );
    }
    $ReturnCode = system( "copy $TempDir\\CDFs\\nt5prt$PrtName$CdfExt $BaseCopyDir" );
    if ( $ReturnCode != 0 ) {
        wrnmsg( "Failed to copy nt5prtx.cdf into the build ...",
			 $LogFilename );
    }
}


sub MakeProdLists
{
    my( $Product ) = @_;
    my( $ProductFlag, $Key, $CompName );

    logmsg( "Generating product lists for \'$Product\' ...",
		     $LogFilename );

    unless ( ( open( ALL, ">$TempDir\\$Product.lst" ) ) &&
	     ( open( COMP, ">$TempDir\\" . $Product . "comp.lst" ) ) &&
	     ( open( UNCOMP, ">$TempDir\\" . $Product . "uncomp.lst" ) ) &&
	     ( open( SUB, ">$TempDir\\" . $Product . "sub.lst" ) ) &&
	     ( open( SUBCOMP, ">$TempDir\\" . $Product . "subcomp.lst" ) ) &&
	     ( open( SUBUNCOMP, ">$TempDir\\" . $Product . "subuncomp.lst" ) )
	     ) {
	errmsg( "Failed to open $Product comp, all, uncomp lists",
			 $LogFilename );
	close( ALL );
	close( COMP );
	close( UNCOMP );
	close( SUB );
	close( SUBCOMP );
	close( SUBUNCOMP );
	return( undef );
    }

    if ( ( $Product =~ /per/i ) ||
         ( $Product =~ /bla/i ) ||
         ( $Product =~ /srv/i ) ||
         ( $Product =~ /dtc/i ) ) {
        $ProductFlag = substr( $Product, 0, 1 );
    } else {
        # now do the freak cases, wks, ent, and sbs
        if ( $Product =~ /pro/i ) { $ProductFlag = "w"; }
        if ( $Product =~ /ads/i ) { $ProductFlag = "e"; }
        if ( $Product =~ /sbs/i ) { $ProductFlag = "l"; }
    }

    foreach $Key ( keys( %Hash ) ) {
	if ( ( &GetFlag( $Key, "Driver" ) eq "t" ) &&
	     ( &GetFlag( $Key, "Dosnet" ) eq "f" ) ) { next; }
	if ( ( &GetFlag( $Key, "Prods" ) =~ /$ProductFlag/ ) &&
	     ( &GetFlag( $Key, "Prods" ) ne "nul" ) ){
	        #In case a file is in PRO and is a tabletpc file then do not add it onto the product list for PRO SKU.
		if  (  !((&GetFlag( $Key, "TabletPC" ) eq "t") &&  ($Product =~ /pro/i) )) {
    		    if ( $Key =~ /\\(\S*)$/ ) { print( SUB "$1\n" ); }
		    else { print( ALL "$Key\n" ); }
		    if ( &GetFlag( $Key, "Comp" ) eq "t" ) {
			$CompName = &MakeCompName( $Key );
			if ( $CompName =~ /\\(\S*)$/ ) { print( SUBCOMP "$1\n" ); }
			else { print( COMP "$CompName\n" ); }
		    } else {
			if ( $Key =~ /\\(\S*)$/ ) { print( SUBUNCOMP "$1\n" ); }
			else { print( UNCOMP "$Key\n" ); }
		    }
		}
	}
    }

    close( ALL );
    close( COMP );
    close( UNCOMP );
    close( SUB );
    close( SUBCOMP );
    close( SUBUNCOMP );
}

sub MakeTabletList
{
	my($key,$CompName);
	unless ( open( FILE, ">$TempDir\\TabletPc.lst" ) ){
		errmsg( "Failed to open TabletPc.lst",$LogFilename );
	}
	unless ( open( FILECOMP, ">$TempDir\\TabletPcComp.lst" ) ){
		errmsg( "Failed to open TabletPcComp.lst",$LogFilename );
	}
       	      foreach $key ( keys( %Hash ) ) {
			if ( &GetFlag( $key, "TabletPC" ) eq "t" ){
				print( FILE "$key \n");		
				$CompName = &MakeCompName( $key );
				print( FILECOMP "$CompName \n");
			}
	       }
close (FILE);
close (FILECOMP);
}



#
# MakeDriverCabLists
#
# Arguments: $SkuName, $SkuLetter
#
# Purpose: generate driver lists for drivercab based on the sku given
#
# Returns: nothing
#
sub MakeDriverCabLists
{

   # get passed args
   my( $SkuName, $SkuLetter ) = @_;

   # declare locals
   my( $fh );           # file handle for writing the list
   my( $ListName );     # file name for this list

   # generate list file name and delete the old one
   $ListName = "$TempDir\\" . $SkuName . "drivers.txt";
   if ( -e $ListName ) {
       unlink( $ListName );
       if ( -e $ListName ) {
	   errmsg( "Failed to delete $ListName ...",
			    $LogFilename );
       }
   }

   # if we're in incremental mode, do not create a common list
   if ( ( $IncFlag eq "TRUE" ) && ( $SkuName eq "common" ) ) {
       return;
   }

   unless ( $fh = new IO::File $ListName, "w" ) {
      # failed to create file for open
      errmsg( "Failed to open $ListName for write ..." );
      return;
   }

   # generate all letters that we're operating over
   my( $SkuLetters );

   if ( $CDDataSKUs{ 'PRO' } ) { $SkuLetters .= "w"; }
   if ( $CDDataSKUs{ 'PER' } ) { $SkuLetters .= "p"; }
   if ( $CDDataSKUs{ 'SRV' } ) { $SkuLetters .= "s"; }
   if ( $CDDataSKUs{ 'BLA' } ) { $SkuLetters .= "b"; }
   if ( $CDDataSKUs{ 'SBS' } ) { $SkuLetters .= "l"; }
   if ( $CDDataSKUs{ 'ADS' } ) { $SkuLetters .= "e"; }
   if ( $CDDataSKUs{ 'DTC' } ) { $SkuLetters .= "d"; }

   #
   # begin writing drivers to each list
   #
   foreach $Key ( keys( %Hash ) ) {
       # check if this file is a driver for this prod
       next if ( &GetFlag( $Key, "DrvIndex" ) =~ /nul/i );

       if ( $IncFlag eq "TRUE" ) {
	   # we are in incremental mode
	   if ( &GetFlag( $Key, "DrvIndex" ) =~ /\Q$SkuLetter\E/i ) {
	       print( $fh "$Key\n" );
	   }
       } else {
           # we are in full mode
	   # if we're common, don't add us to uncommon lists.
	   # if we're not common, add us to regular lists.
	   if ( ( &GetFlag( $Key, "DrvIndex" ) =~ /\Q$SkuLetters\E/ ) &&
		( $SkuName eq "common" ) ) {
	       print( $fh "$Key\n" );
	   } elsif ( ( &GetFlag( $Key, "DrvIndex" ) =~ /\Q$SkuLetter\E/i ) &&
		     ( &GetFlag( $Key, "DrvIndex" ) !~ /\Q$SkuLetters\E/i ) ) {
	       print( $fh "$Key\n" );
	   }
       }
   }

   undef( $fh );

   # delete the list if it has zero length
   if ( -z $ListName ) {
       unlink( $ListName );
       if ( -e $ListName ) {
	   errmsg( "Failed to delete zero length driver list for ".
			    "$SkuName ...", $LogFilename );
       }
   }

}


sub MakeCompLists
{
     my( $Key, $CompKey, $Ext );
     my $Binaries = $ENV{'_NTPOSTBLD'};
     my $CompressedBinaries = "$Binaries\\comp";

    logmsg( "Generating compression lists ...", $LogFilename );

    unless ( ( open( ALL, ">$TempDir\\allcomp.lst" ) ) &&
	     ( open( PRE, ">$TempDir\\precomp.lst" ) ) &&
	     ( open( POST, ">$TempDir\\postcomp.lst" ) ) ) {
	errmsg( "Failed to open main compression lists.",
			 $LogFilename );
	close( ALL );
	close( PRE );
	close( POST );
	return( undef );
    }

    foreach $Key ( keys( %Hash ) ) {
	if ( &GetFlag( $Key, "Comp" ) eq "t" ) {
	    if ( $Key =~ /\\/ ) {
		unless ( ( $Key =~ /^perinf/ ) || ( $Key =~ /^srvinf/ ) ||
			 ( $Key =~ /^entinf/ ) || ( $Key =~ /^blainf/ ) ||
			 ( $Key =~ /^dtcinf/ ) || ( $Key =~ /^sbsinf/ ) || ( $Key =~ /^lang/) ) {
		    next;
		}
	    }
	    $CompKey = &MakeCompName( $Key );
	    print( ALL "$Binaries\\$Key $CompressedBinaries\\$CompKey\n" );
	    $Ext = substr( $Key, -4, 4 );
	    if ( ( $Ext ne ".exe" ) && ( $Ext ne ".dll" ) &&
		 ( $Ext ne ".cpl" ) && ( $Ext ne ".com" ) &&
		 ( $Ext ne ".ocx" ) && ( substr( $Ext, 1, 3 ) ne ".ax" ) &&
		 ( $Ext ne ".tsp" ) && ( $Ext ne ".drv" ) &&
		 ( $Ext ne ".scr" ) && ( $Ext ne ".cat" ) ) {
		print( PRE "$Binaries\\$Key $CompressedBinaries\\$CompKey\n" );
	    }
	    if ( ( ( $Ext ne ".cab" ) && ( $Ext ne ".msi" ) &&
		   ( $Ext ne ".cat" ) ) && (
                   ( $Ext eq ".exe" ) || ( $Ext eq ".dll" ) ||
		   ( $Ext eq ".cpl" ) || ( $Ext eq ".com" ) ||
		   ( $Ext eq ".ocx" ) || ( substr( $Ext, 1, 3 ) eq ".ax" ) ||
		   ( $Ext eq ".tsp" ) || ( $Ext eq ".drv" ) ||
		   ( $Ext eq ".scr" ) ) ) {
		print( POST "$Binaries\\$Key $CompressedBinaries\\$CompKey\n" );
	    }
	}
    }

    close( ALL );
    close( PRE );
    close( POST );
}

sub MakeExtensionLists
{
    logmsg( "Creating extension lists ...",
		     $LogFilename );

    my %handles_to_extension_lists;

    # Use our own subdirectory
    mkdir "$ENV{_NTPostBld}\\congeal_scripts\\exts", 0777 if ( ! -d "$ENV{_NTPostBld}\\congeal_scripts\\exts" );

    foreach my $key ( keys( %Hash ) ) {
        my ($ext) = $key =~ /\.([^\.]+)$/;
        $ext ||= 'noext';

        if ( !exists $handles_to_extension_lists{$ext} ) {
            $handles_to_extension_lists{$ext} = new IO::File "$ENV{_NTPostBld}\\congeal_scripts\\exts\\$ext\_files.lst", O_CREAT | O_WRONLY;
            if ( !exists $handles_to_extension_lists{$ext} ) {
                errmsg( "Error opening $ENV{_NTPostBld}\\congeal_scripts\\exts\\$ext\_files.lst for writing ($!)" );
                return;
            }
        }

        $handles_to_extension_lists{$ext}->print("$key\n");
    }

    # close all open handles
    foreach ( keys %handles_to_extension_lists ) {
        $handles_to_extension_lists{$_}->close();
    }

    return 1;
}


sub MakeLists
{
    if ( ( defined( $CreateCDFs ) ) || ( defined( $CreateLists ) ) ) {
	logmsg( "Beginning CDF and list generation ...",
			 $LogFilename );
    }

	&MakeTabletList();
    if ( defined( $CreateCDFs ) ) {
	# let's make some cdf's
	&MakeMainCdfs( "nt5" );
	&MakeInfCdf( "nt5winf", "w" );# if ( $CDDataSKUs{'PRO'});
	&MakeInfCdf( "nt5pinf", "p" );# if ( $CDDataSKUs{'PER'});
	&MakeInfCdf( "nt5sinf", "s" );# if ( $CDDataSKUs{'SRV'});
	&MakeInfCdf( "nt5binf", "b" );# if ( $CDDataSKUs{'BLA'});
	&MakeInfCdf( "nt5linf", "l" );# if ( $CDDataSKUs{'SBS'});
	&MakeInfCdf( "nt5einf", "e" );# if ( $CDDataSKUs{'ADS'});
	&MakeInfCdf( "nt5dinf", "d" );# if ( $CDDataSKUs{'DTC'});
    }

    if ( defined( $CreateLists ) ) {
	# let's make some product lists
	&MakeProdLists( "pro" );# if ( $CDDataSKUs{'PRO'});
	&MakeProdLists( "per" );# if ( $CDDataSKUs{'PER'});
	&MakeProdLists( "srv" );# if ( $CDDataSKUs{'SRV'});
	&MakeProdLists( "bla" );# if ( $CDDataSKUs{'BLA'});
	&MakeProdLists( "sbs" );# if ( $CDDataSKUs{'SBS'});
	&MakeProdLists( "ads" );# if ( $CDDataSKUs{'ADS'});
	&MakeProdLists( "dtc" );# if ( $CDDataSKUs{'DTC'});

	# let's make some drivercab lists
	&MakeDriverCabLists( "pro", "w" ) if ( $CDDataSKUs{ 'PRO' } );
	&MakeDriverCabLists( "per", "p" ) if ( $CDDataSKUs{ 'PER' } );
	&MakeDriverCabLists( "srv", "s" ) if ( $CDDataSKUs{ 'SRV' } );
	&MakeDriverCabLists( "bla", "b" ) if ( $CDDataSKUs{ 'BLA' } );
	&MakeDriverCabLists( "sbs", "l" ) if ( $CDDataSKUs{ 'SBS' } );
	&MakeDriverCabLists( "ads", "e" ) if ( $CDDataSKUs{ 'ADS' } );
	&MakeDriverCabLists( "dtc", "d" ) if ( $CDDataSKUs{ 'DTC' } );
	&MakeDriverCabLists( "common", "c" );

	# let's make some compression lists
	&MakeCompLists();

	logmsg( "Sorting generated lists ...", $LogFilename );

	system( "sort $TempDir\\allcomp.lst /o $TempDir\\allcomp.lst" );
	system( "sort $TempDir\\precomp.lst /o $TempDir\\precomp.lst" );
	system( "sort $TempDir\\postcomp.lst /o $TempDir\\postcomp.lst" );
    }

    if ( ( defined( $CreateCDFs ) ) || ( defined( $CreateLists ) ) ) {
	logmsg( "Finished creating CDFs and lists.", $LogFilename );
    }
}


sub MakeCompName
{
    my $fullname = shift;
    my ($filename, $path) = fileparse($fullname);
    $filename =~ s{(\.([^\.]*))?$}
                  {'.' . ((length $2 < 3) ? $2 : substr($2,0,-1)) . '_'}ex;
    
    return ($path eq '.\\'?'':$path).$filename;
}


sub CheckDosnet
{
    my( $DosnetName ) = @_;
    my( @DosLines, $Line, $ReadFlag, $ListName, $MyName, $CopyLocation );
    my( $Junk );

    # check all the dosnet's right now
    unless ( open( DOSNET, $DosnetName ) ) {
	errmsg( "Failed to open $DosnetName.", $LogFilename );
	return( undef );
    }
    @DosLines = <DOSNET>;
    close( DOSNET );

    $ListName = $TempDir . "\\wksnetck.lst";

    if ( $DosnetName =~ /perinf/ ) { $ListName = $TempDir . "\\pernetck.lst"; }
    if ( $DosnetName =~ /srvinf/ ) { $ListName = $TempDir . "\\srvnetck.lst"; }
    if ( $DosnetName =~ /blainf/ ) { $ListName = $TempDir . "\\blanetck.lst"; }
    if ( $DosnetName =~ /sbsinf/ ) { $ListName = $TempDir . "\\sbsnetck.lst"; }
    if ( $DosnetName =~ /entinf/ ) { $ListName = $TempDir . "\\entnetck.lst"; }
    if ( $DosnetName =~ /dtcinf/ ) { $ListName = $TempDir . "\\dtcnetck.lst"; }

    unless ( open( LIST, ">$ListName" ) ) {
	errmsg( "Failed to open $ListName for writing.",
			 $LogFilename );
	return( undef );
    }

    $ReadFlag = "FALSE";
    foreach $Line ( @DosLines ) {
	chomp( $Line );
	if ( ( length( $Line ) == 0 ) ||
	     ( substr( $Line, 0, 1 ) eq ";" ) ||
	     ( substr( $Line, 0, 1 ) eq "#" ) ||
	     ( substr( $Line, 0, 2 ) eq "@*" ) ) { next; }
	if ( $Line =~ /^\[/ ) { $ReadFlag = "FALSE"; }
	if ( ( $Line =~ /^\[Files\]/ ) ||
	     ( $Line =~ /^\[SourceDisksFiles\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $AmX86 eq "TRUE" ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.x86\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $BldArch =~ /amd64/i ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.amd64\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( ( $BldArch =~ /ia64/i ) &&
		  ( $Line =~ /^\[SourceDisksFiles\.ia64\]/ ) ) {
	    $ReadFlag = "TRUE";
	} elsif ( $ReadFlag eq "TRUE" ) {
	    $Line =~ s/^d1\,//;
	    ( $MyName, $CopyLocation ) = split( /\,/, $Line );
	    ( $MyName, $Junk ) = split( /\s/, $MyName );
	    # myname is considered "good"
	    # BUGBUG
	    # this will NOT notice missing files of the following nature:
	    # if a file is different in any two products, and it's only
	    # missing from _one_ of the directories below, it will be
	    # marked as fine.
	    if ( ( ! ( -e "$nttree\\$MyName" ) ) &&
		 ( ! ( -e "$nttree\\perinf\\$MyName" ) ) &&
		 ( ! ( -e "$nttree\\srvinf\\$MyName" ) ) &&
		 ( ! ( -e "$nttree\\blainf\\$MyName" ) ) &&
		 ( ! ( -e "$nttree\\sbsinf\\$MyName" ) ) &&
		 ( ! ( -e "$nttree\\entinf\\$MyName" ) ) &&
		 ( ! ( -e "$nttree\\dtcinf\\$MyName" ) ) ) {
		print( LIST "$MyName\n" );
	    }
	}
    }
}


sub SpecialExclusions
{

    # force ntkrnlmp.exe to be uncompressed on ia64 builds
    if ( $BldArch =~ /ia64/i ) {
        &ChangeSettings( "ntkrnlmp.exe", "Comp=f" );
    }
    # Change settings only works on existing keys,
    # so try to change all possible driver.cab files
    # to unsigned
    &ChangeSettings( "driver.cab", "Signed=f" );
    &ChangeSettings( "perinf\\driver.cab", "Signed=f" );
    &ChangeSettings( "srvinf\\driver.cab", "Signed=f" );
    &ChangeSettings( "sbsinf\\driver.cab", "Signed=f" );
    &ChangeSettings( "blainf\\driver.cab", "Signed=f" );
    &ChangeSettings( "entinf\\driver.cab", "Signed=f" );
    &ChangeSettings( "dtcinf\\driver.cab", "Signed=f" );
    

}


sub UsageAndQuit
{
    print( "\n$0 [-f] [-cdf] [-cdl] [-g:<Search> [-o:<Filename>]]\n" );
    print( "\n\t-f\t\tForce list generation -- don't read old list\n" );
    print( "\t-cdf\t\tCreate CDFs\n" );
    print( "\t-cdl\t\tCreate CD lists (compression lists, link lists)\n" );
    print( "\t-g:<Search>\tPrint to STDOUT or <Filename> the results\n" );
    print( "\t\t\tof a search on the given input (see below)\n" );
    print( "\t-o:<Filename>\tSend search output to the given filename\n" );
    print( "\n\tFor the search command, valid expressions are:\n" );
    print( "\t\tField=xxx\tReturn entries whose \"Field\" is exactly xxx\n" );
    print( "\t\tField?yyy\tReturn entries whose \"Field\" contains yyy\n" );
    print( "\t\tField1=xxx:Field2=yyy logically \'and\'s results\n" );
    print( "\n\tField names can be found in the keylist file $KeyFileName\n" );
    print( "\n" );

    exit( 1 );
}


sub HandleDiffFiles
{
    # declare locals
    my( @BinDiffs, $NumDiffsLimit, %DiffFiles, $Line );

    # here we need to make a decision.
    # we can either do an incremental build if the diff list is smaller than
    # some number of files, or we can run a full postbuild.

    # first, set the limit on the number of differing files before running
    # a full postbuild.
    $NumDiffsLimit = 100;
    $IncFlag = "FALSE";
    
    # if the user specifically asked for no bindiff truncation, just return
    if ( defined( $NoUseBindiff ) ) {
	logmsg( "Not truncating against bindiff files ...",
			 $LogFilename );
	return( 1 );
    }

    # open the diff file and read it in
    unless ( open( INFILE, $BinDiffFile ) ) {
	errmsg( "Failed to open new file list '$BinDiffFile',",
			 $LogFilename );
	errmsg( "will assume a full postbuild is needed.",
			 $LogFilename );
	return( undef );
    }
    @BinDiffs = <INFILE>;
    close( INFILE );

    # make sure we're under the limit
    if ( @BinDiffs > $NumDiffsLimit ) {
	logmsg( "Too many files have changed, will perform a full",
			 $LogFilename );
	logmsg( "postbuild, non-incremental.", $LogFilename );
	return( undef );
    }

    # if we're here, then we have a small enough number of different files
    # that we'll run an incremental postbuild.
 
    # set a flag to indicate we are in incremental mode
    $IncFlag = "TRUE";

    # so what we want to do is remove all hashes that do NOT appear in
    # the diff file.
    foreach $Line ( @BinDiffs ) {
	chomp( $Line );
	$Line = "\L$Line";
	# add the files to the temp hash
	# print( "DEBUG: diff file '$Line'\n" );
	$DiffFiles{ $Line } = "TRUE";
    }

    foreach $Key ( keys( %Hash ) ) {
	$Line = "\L$nttree\\$Key";
	# print( "DEBUG: key check '$Line'\n" );
	unless ( $DiffFiles{ $Line } ) { delete( $Hash{ $Key } ); }
    }

    # and we're done!
    # just return true.
    return( 1 );
}


sub GetPrinterFiles
{

    # get passed args
    my( $PrintFileName ) = @_;

    # declare locals
    my( @PrintLines, $Line, $PrintMe, $PrinterName, $Junk );

    unless ( open( INFILE, $PrintFileName ) ) {
	errmsg( "Failed to open $PrintFileName to determine printers",
			 $LogFilename );
	undef( @PrinterFiles );
	return;
    }

    @PrintLines = <INFILE>;
    close( INFILE );

    undef( $PrintMe );
    foreach $Line ( @PrintLines ) {
	# first, a simple unicode conversion
	$Line =~ s/\000//g;
	# now a chomp that handles \r also
	$Line =~ s/[\r\n]//g;
	if ( ( length( $Line ) == 0 ) || ( $Line =~ /^\;/ ) ) { next; }
	if ( $Line =~ /^\[/ ) { undef( $PrintMe ); }
	if ( $PrintMe eq "TRUE" ) {
	    ( $PrinterName, $Junk ) = split( /\s+/, $Line );
	    push( @PrinterFiles, $PrinterName );
	}
	if ( $Line =~ /\[SourceDisksFiles\]/ ) { $PrintMe = "TRUE"; }
    }

}


#
# AddDrvIndex
#
# Arguments: $IndexFileName, $StatusChange, $SkuName
#
# Purpose: this routine scans the given drvindex.inf file for driver files and
#          adds the appropriate status change to the DrvIndex field of the hash
#          the $PathFromBinaries is to find the right version of the file.
#
# Returns: nothing
#
sub AddDrvIndex
{

   # get passed args
   my( $IndexFileName, $StatusChange, $SkuName ) = @_;

   # declare locals
   my( $fh );           # file handle for the index files
   my( $FileLine );     # for reading files line by line
   my( $ReadFlag );     # bool for reading files or not
   my( $FilePrepend );  # hold "perinf\" or whatever

   # declare status
   logmsg( "Marking drivers in $IndexFileName ...", $LogFilename );

   #
   # open the drvindex file
   #
   unless ( $fh = new IO::File $IndexFileName, "r" ) {
      # failed to open the file
      errmsg( "Failed to open $IndexFileName ...", $LogFilename );
      return;
   }

   #
   # parse the file
   #

   # create the filename to look for first, i.e. if the sku we're checking
   # is per, look for a perinf\$FileName first
   #
   $FilePrepend = "";
   if ( $SkuName !~ /pro/i ) { $FilePrepend = $SkuName . "inf\\"; }
   if ( $SkuName =~ /ads/i ) { $FilePrepend = "entinf\\"; }

   #
   $ReadFlag = "FALSE";
   while ( $FileLine = <$fh> ) {
      chomp( $FileLine );
      if ( length( $FileLine ) == 0 ) { next; }
      if ( $FileLine =~ /^\;/ ) { next; }
      if ( $FileLine =~ /\[/ ) { $ReadFlag = "FALSE"; }
      if ( $ReadFlag eq "TRUE" ) {
	  # add the file to the appropriate field
	  # prepend with $FilePrepend to see if that file exists
	  if ( $Hash{ "$FilePrepend$FileLine" } ) {
	      &ChangeSettings( "$FilePrepend$FileLine", $StatusChange );
	  } elsif ( $Hash{ "$FileLine" } ) {
	      &ChangeSettings( $FileLine, $StatusChange );
	  } else {
              &NewSettings( $FileLine, $StatusChange );
          }
      }
   
      if ( $FileLine =~ /\[driver\]/ ) { $ReadFlag = "TRUE"; }
   }

   undef( $fh );

}


#--
# GetDrmFiles
#
# First parameter is reference to associate array
# Associated array will be filled with values from $DrmTxt file.
#--
sub GetDrmFiles
{
    #--
    # Passed parameters
    #--

    my( $ref, $txtfile ) = @_;

    #--
    # Local variables
    #--

    my( $line, @DrmFileLines, $filename, $drmvalue, $rem );

    unless( -f $txtfile )
    {
        wrnmsg( "Failed to find $txtfile to determine drm files", $LogFilename );
        undef( %$ref );
        return;
    }

    unless( open( INFILE, $txtfile ) )
    {
        errmsg( "Failed to open $txtfile to determine drm files", $LogFilename );
        undef( %$ref );
        return;
    }

    @DrmFileLines = <INFILE>;
    close( INFILE );

    foreach $line ( @DrmFileLines )
    {
        chomp $line;
        if( ( $line =~ /^\s*$/ ) || ( $line =~ /^[\;\#]/ ) ) { next; }
        ( $filename, $drmvalue, $rem ) = split( /\:/, $line );
        $$ref{$filename} = $drmvalue;
    }
}