windows-server-2003/tools/intlmap.pl

# USE section

  use lib $ENV{ "RazzleToolPath" };
  use GetParams;
  use CkLang;
  use strict;
  no strict 'vars';

# GLOBALS

  $ScriptName=$0;

  $SDXROOT=$ENV{SDXROOT};
  $INTLVIEW_FNAME="$SDXROOT\\tools\\intlview.map";

  %SDMAP=();
  %INTLVIEW=();

  $Lang="";
  $Project="";
  $Quiet="";
  $FullView="";

  $CODEBASE="NT";
  $BRANCH=$ENV{_BuildBranch};

  $LOGGING=0;
  $ERROR=1;
  $WARNING=2;
  %MSG=($LOGGING => "", $ERROR => "error: ", $WARNING => "warning: ");

# MAIN {

  # Parse the command line parameters.
  &ParseCmdLine( @ARGV );
  # print $FullView ? "Selective Mapping\n" :  "Selective/Exclusionary Mapping\n";
  # Verify the command line parameters and the environment.
  &VerifyParams();

  # Mark sd.map as read only.
  &MarkReadWrite();

  # Load data from the "SD.MAP" file.
  &LoadSDMap();

  &LoadIntlview();

  if ( $Lang ) {
    &EnlistLangProj($Lang);
  } else {
    &EnlistCodeProj($Project);
  }

  # Mark sd.map as read only.
  &MarkReadOnly();
 
# } # MAIN


sub EnlistLangProj {

  my ( $lang ) = @_;

  &EnlistProject("$lang\_res");
  &EnlistProject("$lang\_bin");
  &MapProject("$lang\_res");
  &MapProject("$lang\_bin");

} # EnlistLangProj


sub EnlistCodeProj {

  my ( $projname ) = @_;

  foreach (sort keys %INTLVIEW) {

    if ( $projname && lc($projname) ne lc($_) ) {
      next;
    }
    &EnlistProject($_);
    &MapProject($_);

  }

} # EnlistCodeProj


sub EnlistProject {

  my ( $projname ) = @_;

  if ( !$Quiet ) {
    &AskForOK( $projname );
  }

  printf "\n";
  &DisplayMsg( $LOGMSG, "Enlisting project \"$projname\" in branch \"$BRANCH\"...");

  if ( exists $SDMAP{lc($projname)} ) {
    &DisplayMsg( $LOGMSG, "Already enlisted in project \"$projname\".");
    return;
  }

  &ExecuteCmd( "sdx enlist $projname /q");

  # As sdx does not set the error level in case of errors, reload the SD.MAP
  # mapping file to verify that the project got actually enlisted.

  &LoadSDMap();

  if ( ! exists $SDMAP{lc($projname)} ){
    &FatalError( "Enlist project \"$projname\" command failed." );
  } else {
    &DisplayMsg( $LOGMSG, "Project \"$projname\" enlisted successfully." );
  }

  return;

} # EnlistProject


sub MapProject {

  my ( $projname ) = @_;

  my $workdir = "$SDXROOT\\$SDMAP{lc($projname)}";

  &DisplayMsg( $LOGMSG, "cd /d $workdir");
  chdir ( $workdir ) ||
  &FatalError( "Unable to change directory to \"$workdir\" to update project's \"$projname\" client view.");

  &ExecuteCmd( "sd client -o \> sd.client" );
  if ( &UpdateClient( $projname ) ) {
    &ExecuteCmd( "sd client -i \< sd.client" );
    &DisplayMsg( $LOGMSG, "Project \"$projname\" mapped successfully." );
  }
  &ExecuteCmd( "del sd.client" );

} # MapProject


sub UpdateClient {

  my ( $projname ) = @_;

  my $workdir = "$SDXROOT\\$SDMAP{lc($projname)}";
  my @sdclient = ();
  my $i = 0;
  my $j = 0;

  open( FILE, "sd.client" ) ||
  &FatalError("Unable to open file \"$workdir\\sd.client\" for reading.");
  @sdclient = <FILE>;
  close( FILE );

  for ( $i=0; $i < @sdclient; $i++ ) {
    if ( $sdclient[$i] =~ /^View:/ ) {
      last;
    }
  }

  if ( $i == @sdclient ) {
    &FatalError( "");
  }

  if ($projname=~/$lang/i) {
    while( $i < @sdclient ) {
      if ( ($sdclient[$i] =~ /$projname/i) || ($sdclient[$i] =~ /^\s*$/) ) {
        # remove this language's item in client view
        splice(@sdclient, $i, 1);
      } else {
        $i++;
      }
    }
  }

  $#sdclient=$i;

  for ( $j=0; $j < @{$INTLVIEW{lc($projname)}}; $j++ ) {
    $sdclient[$i+$j+1] = sprintf( "\t%s\n", ${$INTLVIEW{lc($projname)}}[$j]);
    $sdclient[$i+$j+1] =~ s/\<client\>/$SDMAP{client}/;
  }

  &DisplayMsg( $LOGMSG, "Saving project's \"$projname\" updated client view...");

  open(FILE, ">sd.client") ||
  &FatalError( "Unable to open \"$workdir\\sd.client\" for writing." );

  for ($i=0; $i < @sdclient; $i++ ) {
    printf FILE "$sdclient[$i]";
  }

  close (FILE);

  return 1;

} # UpdateClient


sub LoadIntlview {
  
  my @mapfile = ();
  my $i=0;
  my $key;
  my $value;

  open( FILE, $INTLVIEW_FNAME ) ||
  &FatalError( "Unable to load input file $INTLVIEW_FNAME." );

  @mapfile = <FILE>;

  close( FILE );

  for ($i=0; $i < @mapfile; $i++) {

    foreach ($mapfile[$i]) {

      SWITCH: {

        # commented line
        if ( /\s*;/ ) { last SWITCH;}

        # valid entry
        if (/\s*(\S+)\s+(\S+.*)/ ) {
          ($key, $value) = ($1, $2);
          next if (( !$Lang ) && ( $key =~ /lang/ ));
          $key =~ s/\<lang\>/lc$Lang/eg;
          $value =~ s/\<lang\>/lc$Lang/eg;
	  $value =~ s/\<branch\>/lc$BRANCH/eg;
          next if $FullView and $value =~/^\-/;
          push @{$INTLVIEW{lc($key)}}, $value;
          last SWITCH;
        }

        # default
        last SWITCH;

      } # SWITCH

    } # foreach

  } # for

#  foreach (sort keys %INTLVIEW) {
#    for ($i=0; $i < @{$INTLVIEW{$_}}; $i++ ) {
#       printf "key=$_, value[$i]=${$INTLVIEW{$_}}[$i]\n";
#    }
#  }

} # LoadIntlview


sub LoadSDMap {

  my @mapfile=();
  my $i=0;
  my $sdmap="$SDXROOT\\sd.map";

  foreach (keys %SDMAP) {
    delete $SDMAP{$_};
  }

  ( -e $sdmap ) || &FatalError( "Unable to find file $sdmap" );
      
  open( FILE, $sdmap ) || &FatalError( "Unable to open file $sdmap." );

  @mapfile=<FILE>;

  close(FILE);
   
  for ($i=0; $i < @mapfile; $i++) {

    foreach ($mapfile[$i]) {
       
      SWITCH: {
      
        # commented lines
        if ( /\s*#/ ) { last SWITCH;}

        # valid entries
        if (/\s*(\S+)\s*=\s*(\S+)/ ) {
          $SDMAP{lc($1)}=$2;
          last SWITCH;  
        }

        # default
        last SWITCH;

      } # SWITCH

    } # foreach

  } # for

  # verify codebase

  ( exists $SDMAP{codebase} ) || 
  &FatalError( "CODEBASE is not listed in the SD mapping file $sdmap." );
  
  ( lc($SDMAP{codebase}) eq lc($CODEBASE) ) || 
  &FatalError( "Codebase '$CODEBASE' does not match the SDXROOT '$SDMAP{codebase}' codebase." );

  # verify branch

  ( exists $SDMAP{branch} ) || 
  &FatalError( "BRANCH is not listed in the SD mapping file $sdmap." );

  ( lc($SDMAP{branch}) eq lc($BRANCH) ) || 
  &DisplayMsg( $WARNING, "Branch \"$BRANCH\" does not match the SDXROOT \"$SDMAP{branch}\" branch.");

  # verify client

  ( exists $SDMAP{client} ) || 
  &FatalError( "CLIENT is not listed in the SD mapping file $sdmap." );

} # LoadSDMap

sub MarkReadOnly {
  my $sdmap="$SDXROOT\\sd.map";
  &ExecuteCmd( "attrib +h +r $sdmap");
} # MarkReadOnly

sub MarkReadWrite {
  my $sdmap="$SDXROOT\\sd.map";
  &ExecuteCmd( "attrib +h -r $sdmap");
} # MarkReadWrite

sub AskForOK {

  my ( $projname ) = @_;

  printf( "\n  About to enlist in project $projname.\n" );
  printf( "  Press Ctrl+C in the next 30s if you wish to exit script.\n");
  printf( "  ...");
  sleep 30;

} # AskForOK


sub ExecuteCmd {

  my ($command) = @_;

  DisplayMsg( $LOGMSG, $command );
  if ( system( "$command" ) ) {
    &FatalError( "Command \"$command\" failed." );
  }

} # ExecuteCmd

sub ParseCmdLine {

  my @arguments = @_;

  my @syntax = (
          -n => '',
          -o => 'b:l:p:fq',
          -p => "BRANCH Lang Project FullView Quiet"
          );

  &GetParameters( \@syntax, \@arguments );

} # ParseCmdLine


sub GetParameters {

  my ($syntax, $arguments)=@_;

  my $getparams=GetParams->new;
  &{$getparams->{-Process}}(@$syntax,@$arguments);

  if ( $HELP ) {
    &Usage();
  }

} # GetParameters


sub VerifyParams {

  # Must run this script from a razzle

  if ( !$ENV{RazzleToolPath} || !$ENV{SDXROOT} ) {
    &DisplayMsg( $ERROR, "Please run this script from a razzle." );
    &Usage();
  }

  if ( $Lang ) {

      if( uc($Lang) eq "INTL" ){
          $Lang = "";
      }
      else
      {
          # Only MAIN is accepted for language projects.
          if ( ! &cklang::CkLang($Lang) ) {
              &DisplayMsg( $ERROR, "Invalid language $Lang." );
              &Usage();
          }

          if ( lc($BRANCH) ne "main" && lc($BRANCH) ne "locpart" && lc($BRANCH) ne "idx01" && lc($BRANCH) ne "idx02" && lc($BRANCH) ne "idx03" && lc($BRANCH) ne "dnsrv" && lc($BRANCH) ne "dnsrv_dev" && lc($BRANCH) ne "srv03_rtm" ) {
              $BRANCH = "main";
              &DisplayMsg( $WARNING, "Branch has been reset to \"$BRANCH\". The only valid branches for language projects are \"main\", \"locpart\", \"idx01\", \"idx02\", \"idx03\", \"dnsrv\", \"dnsrv_dev\" and \"srv03_rtm\"." );
          }
      }
  }


  if ( $Lang && $Project ) {
    &DisplayMsg( $ERROR, "You can specify language or project, but not both." );
    &Usage();
  }

} # VerifyParams


sub DisplayMsg {

  print "$ScriptName : $MSG{@_[0]}@_[1]\n";

} # DisplayMsg


sub FatalError {

  my ( $strerr ) = @_;

  &DisplayMsg( $ERRMSG, $strerr );
  exit 1;

} # FatalError


sub Usage {
    print <<USAGE;

perl $0 - Enlist and map the projects pertinent to Whistler international.

  Usage:

    perl $0 [-b:<branch>] [-l:<language> | -p:<project>] [-q] [-f]

    <branch >   Source depot branch.
		Enlist in the specified branch. 
                Default is %_BuildBranch%, $BRANCH in this case.

    <language>  Language. 
                If not specified, enlist in the source projects.
                Acepted values are "intl" and any language 
                listed in codes.txt.
                If "intl", enlist the source projects.
                Otherwise, enlist and map the language projects 
                <language>_res and <language>_bin.

    <project>   Project name.
                If specified, enlist and map the given source project.

    <f>ullfview Flag to supply when generating integration/reverse integration 
                enlistment.
                If specified, client view will be build without
                exclusionary mapping  ('-') lines.


    If no project or language is specified, enlist and map the source
    projects. Tools\\intlview.map lists the projects and the client 
    view mappings pertinent to international builds.


    q           Quiet mode.              

  Examples:

    perl $0 /q
        Enlist and map the source projects, default branch.
    perl $0 -b:beta1 -l:intl /q
        Same as above, beta1 branch.
    perl $0 -p:Admin
        Enlist and map the admin project, default branch.
    perl $0 -l:jpn /q /f
        Enlist and map jpn for integration clients. 
    perl $0 -l:ger /q
        Enlist and exclusionary map ger_res, ger_bin, main branch for
        ger project build. The client view will contain e.g.

        //depot/main/ger_res/... //XXXX/loc/res/ger/...
        -//depot/main/ger_res/.../EDBs/... //XXXX/loc/res/ger/.../EDBs/...


USAGE

    exit(1);

} # Usage