#!/usr/bin/perl

# Branch engine for cdsp4
# Author: Shiv Sikand 


open(DT,"date|") || die;

while(<DT>) {
    $date=$_;
}


use Getopt::Long;

$Getopt::Long::autoabbrev=0;  #make them specify exact option

unless($result=GetOptions("h",
			  "tp=s","block=s",
			  "user=s",
			  "lib=s",
			  "add=s",
			  "site=s",
			  "bname=s","from=s", "noint","force","lastchange=s")){
    die "Illegal Input Options, -h for help\n";
}

$HELP="OPTION ERRORS\n";

$opt_top=1;


if($opt_block && $opt_top) {

    die "Mutex block/top !!!!\n";
}

$opt_sp=$ENV{"PROJECT"};

print "Project is $opt_sp\n";


unless($opt_sp && $opt_tp && ( $opt_top || $opt_block || $opt_lib) && ($opt_bname || $opt_user)) {
    print "$HELP\n";
    exit;
}


if($opt_from && $opt_lastchange) {
    print "from and lastchange are conflicting options !!\n";
    exit;
}

if($opt_add && !$opt_bname) {
    print "add requires the bname argument!!\n";
    exit;
}


# Project specific variables

(@projparse)=split('/',$opt_sp);


# Derived chip and rev from $opt_sp

$chip=$projparse[$#projparse-1];
$rev=$projparse[$#projparse];

# Define cadence location within the tree

#$libsubdir="layout/cadence";
$libsubdir="cdslibs";
$sourceproj=$opt_sp;
$targetproj=$opt_tp;

# Define cds.lib and cds.p4client locations

$cdslibsfile=$sourceproj."/$libsubdir/cds.lib";
$cdslibtfile=$targetproj."/$bdir"."/$libsubdir/cds.lib";
$cfile=$sourceproj."/$libsubdir/cds.p4client";


# Traling slashes can cause a big nightmare
# if they exist in one but not in the other



if(substr($opt_sp,-1,1) eq "/") {
    print "ERROR: No trailing slashes allowed in sp or tp\n";
    exit;
}

if(substr($opt_tp,-1,1) eq "/") {
    print "ERROR: No trailing slashes allowed in sp or tp\n";
    exit;
}

$user=$ENV{USER};
$block=$opt_block;
$ubname=$opt_bname;



if(!$ubname) {
    
    @df=split(' ',$date);
    $cnumspec="";
    # build the branch spec
    if($opt_block) {
      if($opt_block eq "tapeout") {
	$bname=$chip."_".$rev."_".$block."_".$df[1].$df[2]."_".$df[5];
      } else {
	$bname=$chip."_".$rev."_".$block."_".$df[1].$df[2]."_".$df[5]."_$opt_user";
      }
    }
    elsif($opt_top) {
	$bname=$chip."_".$rev."_top_".$df[1].$df[2]."_".$df[5]."_$opt_user";
    }
    
    elsif($opt_lib) {
	$bname=$chip."_".$rev."_".$lib."_".$df[1].$df[2]."_".$df[5];
    }
  }
else {
    $bname = $ubname;
  }


# add the site based postfix

if(!$ubname && $opt_site) {
  $bname=$bname."_".$opt_site;
}



if($opt_lastchange) {
    print "\nBranch will be integrated to state at Change $opt_lastchange\n\n";
    $cnumspec="@".$opt_lastchange;
}

if($opt_from) {

    $bfname=$opt_from;
# get the file list for the client (excludes cds libs)
    $bfclient=$bfname."_client";
#set up the names
    if(!$opt_bname) {
	(@bname2)=split('_',$opt_from);
	$bname=$bname."_".$bname2[2];
	# has the name got a month field instead of a year field at the end
	# if so, it was a bob itself
	# if that's the case we to contruct the complex name
	
	# find everything after the year field
	# and append it
	(@bname3)=split(/_[0-9]+/,$opt_from);
	if($bname3[1]) {
	    $bname=$bname.$bname3[1];
	}
    }

    $newclient=$bname."_client";

    if(!$opt_add) {
	# get the non cds data
	%flist=();
	%flistl=();
	&getfileparents($bfname,$bfclient,\%flist,\%flistl);
	# assoc array flist contains list of files for non-cds data
	# dump it to a file so we can use it with -x
	open(BFILES1,">/tmp/bfilesmain.$$") || die;
	foreach $key (sort(keys %flist)) {
	    print BFILES1 "$flist{$key}\n";
	}
	close(BFILES1);
	
	# locally edited files need to be handled separately
	
	if(%flistl) {
	    $dolocal=1;
	    open(BFILES2,">/tmp/bfilesmainl.$$") || die;
	    foreach $key (sort(keys %flistl)) {
		print BFILES2 "$flistl{$key}\n";
	    }
	    close(BFILES2);
	}

	# Build a label to mark the files so we can easily integrate the label's contents 
	$lname=$bfname."label";
	$cmd="p4 label -o $lname | p4 label -i > /dev/null";
	system($cmd);
	# sync the label to the file list
	print "Syncing to label for mainline files\n";
	$cmd="p4 -c $bfclient -x /tmp/bfilesmain.$$ labelsync -a -l $lname >> /tmp/bflsync.$$ 2>&1";
	system($cmd);
	#set up the integration command
	$int_cmd="p4 -c $newclient integrate //depot/...@".$lname." //depot/$bname/...";
	
	# Do the same (similar) for local files
	if($dolocal) {
	    $lnamel=$bfname."label_local";
	    $cmd="p4 label -o $lnamel | p4 label -i ";
	    system($cmd);
	    # sync the label to the file list
	    print "Syncing to label for local files\n";
	    $cmd="p4 -c $bfclient -x /tmp/bfilesmainl.$$ labelsync -a -l $lnamel >> /tmp/bflsyncl.$$ 2>&1";
	    system($cmd);
	    # create the crossbranch spec
	    $crossbranch="cb".$bfrom.$bname;
	    $cmd="p4 branch -o $crossbranch | p4 branch -i > /dev/null";
	    system($cmd);
	    # fix the view
	    $cmd="p4 branch -o $crossbranch | sed 's/\\/\\/depot\\/\\.\\.\\. \\/\\/depot\\/\\.\\.\\./\\/\\/depot\\/$bfname\\/\\.\\.\\. \\/\\/depot\\/$bname\\/\\.\\.\\./g' | p4 branch -i > /dev/null";
	    system($cmd);
	    #set up the integration command
	    $int_cmd2="p4 -c $newclient integrate -b $crossbranch //depot/...\@".$lnamel;
	}
    }
}
print "\nSource project is $sourceproj\n";

if($opt_block) {
    $branchdes=$opt_block;
}
else {
    if($opt_top) {
	$branchdes="top";
    } else {
	$branchdes=$opt_lib;
    }
}


# Build the branches

if($bname eq "") {
    die "Null bname!";
}

if($opt_add) {
    print "Updating $bname to include $opt_add\n";
    $newclient=$bname."_client";
    print "$newclient\n";
} else {

    if(!$opt_from2) {

      # Get the refclient spec
      $refclient=$chip."_".$rev."_ref_".$branchdes;

      # Check to see if it exists
      $cmd="p4 clients | grep $refclient > /dev/null";
      system($cmd);
      # Good exit means it exists
      if ($? ne 0) {
	print "Couldn't find $refclient, aborting\n";
	exit(1);
	
	
      }


      $cmd="p4 client -o $refclient | grep \"^\t//\*\" ";
      
      $bstring="Branch: $bname\nDescription: $branchdes $chip $rev (by $user)\nView:\n";

      # This gives us the LHS view mappings
      open(CMD, "$cmd|") || die ;
      while(<CMD>) {
	chop;
	(@ddata)=split;
	$rhs=$ddata[0];
	$rhs =~ s/$chip\/$rev/$bname/g;
	
	$dstring="\t$ddata[0] $rhs\n";
	$bstring=$bstring.$dstring;

      }

      $cmd="echo \"$bstring\" > /tmp/bspec; p4 branch -i < /tmp/bspec";
      system($cmd);
    }
    else {

      die("Cloning not supported\n");
    # Clone named branch
    if(!$ubname) {
      $bname=$opt_from2."_".$df[1].$df[2];
    }
	else {
	    $bname=$ubname;
	}
	print "Target project is $targetproj/$bname\n\n";
	print "Building branch $bname from $opt_from2\n";
	die("Broken");
	$cmd="echo \"Branch: $bname\nDescription: $branchdes sub branch built by $user\nView:\n\t//depot/$chip/$rev/$opt_from2/layout/blocks/$block/cadence/$block/... //depot/$bname/layout/blocks/$block/cadence/$block/...\n\t//depot/layout/reference/*/cadence/...  //depot/$bname/layout/reference/*/cadence/...\"> /tmp/bspec; p4 branch -i < /tmp/bspec > /dev/null";
	system($cmd);
	
    }

# build a client

# clone the main gfxdesign view spec
    
    $newclient=$bname."_client";


    if(!$opt_from2) {
	
	#$refclient=$chip."_ref_".$branchdes;
	$refclient=$chip."_".$rev."_ref_".$branchdes;	
    } else {
	
	$refclient=$opt_from2."_client";
    }

    # Make client building a subroutine with nocds flag
    if($opt_top) {
	&buildclient($refclient,$newclient,$sourceproj,$targetproj,1,1);
    }
    else {
	&buildclient($refclient,$newclient,$sourceproj,$targetproj,1,0);
    }
    

    if( !$opt_noint) {
	
	# Integrate the new branch 
	print "Integrating the branch\n";
	if(!$int_cmd) {
	    $int_cmd="p4 -c $newclient integrate -v -b $bname $cnumspec";
	}

	print "\n$int_cmd\n\n";
	system($int_cmd);
	
	if($int_cmd2) {
	    print "\n$int_cmd2\n\n";
	    system($int_cmd2);
	}

	
	if($opt_from) {
	    # delete the temp label
	    $cmd="p4 label -d $lname";
	    system($cmd);
	    $cmd="p4 label -d $lnamel";
	    system($cmd);
	}
	
	
# Submit the branch
	
	$cmd="p4 -c $newclient change -o | sed 's/<.*>/Branch submit by buildbranch/' > /tmp/subout.$$";
	system($cmd);
	open(SUB, "</tmp/subout.$$") || die "Couldn't read change description\n";
	$submit=0;
	while(<SUB>) {
	    
	    if(/^Files/) {
		$submit++;
		close(SUB);
	    }
	}
	if($submit) {
	    $cmd="p4 -c $newclient submit -i < /tmp/subout.$$";
	    system($cmd);
	}
    }


# Rebuild the client correctly

#&buildclient($refclient,$newclient,$sourceproj,$targetproj,0);

# Fake sync the client to update the files

#$cmd="p4 -c $newclient flush";
#system($cmd);


# Delete newclient if mode layout since it's now empty


}


if($opt_nocds) {
    exit;
}


$bdir="$bname";




# Build Cadence library clients


print "\nBuilding Cadence library clients\n";
$cdslibsfile=$sourceproj."/$libsubdir/cds.lib";

if($opt_block eq "tapeout") {
  $cdslibtfile=$targetproj."/$libsubdir/cds.lib";
} else {
  $cdslibtfile=$targetproj."/$bdir"."/$libsubdir/cds.lib";
}

$p4 = "p4";

open(CFILE, "<$cfile") || die "Couldn't read $cfile\n";

print "Reading $cfile\n";

while(<CFILE>) {

    if(/^\#/) {
	next;
    }

    chop;


(@cdata)=split;

$path=$cdata[1];

$client=$cdata[2];
(@cinfo)=split(':',$cdata[2]);

#$client2=$cinfo[0].":".$cinfo[1];

$client2=$cinfo[0];


# Read the client spec so that we can clone it
# Only clone libraries that are in the branch spec!!
if($opt_add) {
    if($client =~ /$opt_add/) {
	$vclient{$client}=$client2;
	print "Accepting requested client $client\n";
	close(CFILE);
    }
}

if(!$opt_add)  {
    if(!$opt_top) {
	$match=$blocklib.":".$chip."_".$rev;
	# Accept this blocks libraries or reference libs only
	if($client =~ /$match/ || $path =~ /reference/) {
	    #print "Accepting client $client\n";
	    $vclient{$client}=$client2;
	}
    } else {
	# Accept all clients since it's a top level build
	print "Accepting client $client\n";
	$vclient{$client}=$client2;
    }
}
}


foreach $client (keys %vclient) {
    
    $client2=$vclient{$client};
$cmd="p4 -c $client client -o";

open(CMD, "$cmd|") || die ;

open(CMDOUT, ">/tmp/cbout") || die ;

while(<CMD>) {


    if(/^Options/) {
	# Modtime is nice for sorting in lbb
	s/nomodtime/modtime/g;
	if($opt_site) {
	  s/nocompress/compress/g;
	}
	print CMDOUT $_;
    }

    if(/^Client/) {

	print CMDOUT "Client: $client2:$bdir\n\n";
	
    }
    
    if(/^Description/) {

	print CMDOUT "Description:\n\tcds library\n\n";
	
    }

    if(/^Root/) {
	# Add the branch spec to the root
	# where's a perl manual when you need one
	$swap=0;

	if($opt_block eq "tapeout") {
	  $newroot=$targetproj;
	} else {
	$newroot=$targetproj."/".$bdir;
      }
	$swap = s/$sourceproj/$newroot/g ;
	
	#s/$sourceproj/$newroot/g ;
	

	if($swap eq 1) {
	    print CMDOUT "$_\n";
	    
	}
	else {
	    print "Failed to map root for client $client\n$_\n";
	    print "Check your -sp flag!\n";
	    exit;
	}
	
    }


    if(/^View/) {

	print CMDOUT "$_\n";
    }



    # BOB depot spec has extra component that we need to skip
    if(/^\t\-{0,1}\/\/depot/) {
	
	if(!($opt_from || $opt_from2)) {
	    $newdepot="depot/".$bdir;
	    # New LHS
	    s/depot\/$chip\/$rev/$newdepot/g ; 
	    #print "$_\n";
	    # New RHS
	    # Everything before the colon
	    # eg aq:n1 becomes aq:n1_aq_Oct7_1999

	    $newcdsclient=$client2.":".$bdir ;
	    s/$client/$newcdsclient/g;
	    print CMDOUT $_;
	} else {
	    if($opt_from) {
		$newdepot="depot/".$bdir;
		s/$opt_from\///;
		s/depot\/$chip\/$rev/$newdepot/g ; 
		# New RHS
		$newcdsclient=$client2.":".$bdir ;
		s/$client/$newcdsclient/g;
		print CMDOUT $_;
	    }
	    
	    if($opt_from2) {
		$newdepot="depot/".$bdir;
		s/$opt_from2\///;
		s/depot\/$chip\/$rev/$newdepot/g ; 
		# New RHS
		$newcdsclient=$client2.":".$bdir ;
		s/$client/$newcdsclient/g;
		print CMDOUT $_;
	    }


	}
    }
}
close(CMDOUT);
#print "Building client $newcdsclient\n";
$cmd=$p4." -c $newcdsclient client -i < /tmp/cbout > /dev/null";
system($cmd);


# integrate the cadence libraries
# since we don't allow overlapping clients
# and need to set up the right state for a
# Fast integrate using -v


# These should already be integrated at branch build time


#if( !$opt_noint && !$opt_from && !opt_add) {
#    $cmd="p4 -c $newcdsclient integrate -v -b $bname $cnumspec";
#    print "$cmd\n";
#    system($cmd);
#}


if($opt_from) {
    # Do the same thing that we did earlier to build a file set
    %flist=();
    %flistl=();
    $cdsname=$client.":".$bfname;

    
    &getfileparents($bfname,$cdsname,\%flist,\%flistl);
    # assoc array flist contains list of files for non-cds data
    # dump it to a file so we can use it with -x
    if(%flist) {
	open(BFILES1,">/tmp/bfilecds.$newcdsclient.$$") || die;
	foreach $key (sort(keys %flist)) {
	    print BFILES1 "$flist{$key}\n";
	}
	close(BFILES1);
    }
    
    if(%flistl) {
	open(BFILES2,">/tmp/bfilecdsl.$newcdsclient.$$") || die;
	foreach $key (sort(keys %flistl)) {
	    print BFILES2 "$flistl{$key}\n";
	}
	close(BFILES2);
    }
    if(%flist) {
	# Build a label to mark the files so we can easily integrate the label's contents 
	$lname=$newcdsclient."label";
	$cmd="p4 label -o $lname | p4 label -i > /dev/null";
	system($cmd);
	# sync the label to the file list
	$cmd="p4 -c $newcdsclient -x /tmp/bfilecds.$newcdsclient.$$ labelsync -a -l $lname> /tmp/bflsync.$$ 2>&1";
	system($cmd);
	#set up the integration command
	print "INTEGRATING mainline\n";
	$int_cmd="p4 -c $newcdsclient integrate //depot/...@".$lname." //depot/$bname/...";
	print "\n$int_cmd\n\n";
	system($int_cmd);
	$cmd="p4 label -d $lname";
	system($cmd);
    }
    # Do the same for the locals
    if(%flistl) {
	$lnamel=$newcdsclient."label_local";
	$cmd="p4 label -o $lnamel | p4 label -i > /dev/null";
	system($cmd);
	# sync the label to the file list
	$cmd="p4 -c $newcdsclient -x /tmp/bfilecdsl.$newcdsclient.$$ labelsync -a -l $lnamel > /tmp/bflsyncl.$$ 2>&1";
	system($cmd);
	#set up the integration command
	print "INTEGRATING local edits\n";
	$int_cmd="p4 -c $newcdsclient integrate -b $crossbranch //depot/...\@".$lnamel;
	print "\n$int_cmd\n\n";
	system($int_cmd);
	$cmd="p4 label -d $lnamel";
	system($cmd);
    }
}

#Manual submit

# But don't submit empty files

$cmd="p4 -c $newcdsclient change -o | sed 's/<.*>/Branch submit by buildbranch/' > /tmp/subout.$$";
system($cmd);
open(SUB, "</tmp/subout.$$") || die "Couldn't read change description\n";
$submit=0;
while(<SUB>) {
    
    if(/^Files/) {
	$submit++;
	close(SUB);
    }
}
if($submit) {
    $cmd="p4 -c $newcdsclient submit -i < /tmp/subout.$$";
    system($cmd);
}

# Now sync to bring in the files

if($opt_force) {
    $cmd="p4 -c $newcdsclient sync -f";
} else {
    if(!$opt_add) {
	if(!$opt_noint) {
	    #print "Syncing client $newcdsclient\n";
	    $cmd="p4 -c $newcdsclient sync";
	} else {
	    $cmd="p4 -c $newcdsclient sync -n";
	}
    } else {
	# bring in the new data
	$cmd="p4 -c $newcdsclient integrate -v -b $bname\n";
    }
	
}


# Need to read stderror for the error
print "Int cmd is $cmd\n";
open(CMD, "$cmd 2>&1 |") || die "Couldn't do an integrate....\n";

while(<CMD>) {

    
    if(/No such file/) {

	# Delete the client, it's not valid
	print "ERROR: $newcdsclient does not contain any data\n";
	print "ERROR: If this is expected, please use the -skip option\n";
	print "ERROR: Or integrate this library explicitly by typing\n";
	print "p4 -c $newclient integrate -b $bname\n";
	print "Then run this script again with the -add option\n";
    }
}



}

close(CFILE);

#Manual submit

# But don't submit empty files

$cmd="p4 -c $newcdsclient change -o | sed 's/<.*>/Branch submit by buildbranch/' > /tmp/subout.$$";
system($cmd);
open(SUB, "</tmp/subout.$$") || die "Couldn't read change description\n";
$submit=0;
while(<SUB>) {
    
    if(/^Files/) {
	$submit++;
	close(SUB);
    }
}
if($submit) {
    $cmd="p4 -c $newcdsclient submit -i < /tmp/subout.$$";
    system($cmd);
}


# write the master client file

# branch may not have all the chip clients that match this grep spec

$cmd="$p4 clients | grep 'cds library' | grep '$bdir '  > /tmp/client";
system($cmd);

open(CDATA, "</tmp/client") || die ;

if($opt_block eq "tapeout") {
  $cfile=$targetproj."/$libsubdir/cds.p4client";
} else {
$cfile=$targetproj."/".$bdir."/$libsubdir/cds.p4client";
}


open(CDOUT, ">$cfile") || die "Couldn't write $cfile\n";

print "Writing $cfile\n";



if(!$opt_add) {
    print CDOUT "# Master Client file for $targetproj/$bdir\n# Built by buildbranch $date";
}

while(<CDATA>) {

    @cdata=split;
# Key it on the root
$cdslist{$cdata[4]}=$cdata[1];

(@lib)=split('/',$cdata[4]);

# Last element in path is lib name

$libname=$lib[($#)-1];

#print "LIB: $libname PATH:$cdata[4] CLIENT: $cdata[1]\n";

print CDOUT "$libname $cdata[4] $cdata[1]\n";

}

if($opt_add) {
    print "Updating branch cds.lib file\n";
}
else {
    print "Building branch cds.lib file\n";
}

# Unamanaged in trex

#$cmd="p4 -c $newclient edit $cdslibtfile";
#system($cmd);

# Process it !
open(CDSL, "<$cdslibsfile") || die "Couldn't read $cdslibsfile!\n";

if($opt_add) {
    open(CDSLB, ">>$cdslibtfile") || die "Couldn't open $cdslibtfile!\n";
} else {
    open(CDSLB, ">$cdslibtfile") || die "Couldn't open $cdslibtfile!\n";
}


if(!$opt_add) {
    print CDSLB "--  File Created by buildbranch $date\n";
}


$client=0;


# write new cds.lib

while(<CDSL>) {

    $match=0;
    if($opt_add) {
	if(!(/ $opt_add /)) {
	    next;
	}
    }

    # keep comments
    if (/^#/) {
	print CDSLB $_;
	next;
    } elsif (/^--/) {
	print CDSLB $_;
	next;
    }

    if( /^DEFINE/ || /^INCLUDE/) {
	$save=$_;
	($ig,$libname,$path)=split;

	if($opt_add) {
	    if(!(/ $opt_add /)) {
		next;
	    }
	}

	$newproj=$targetproj."/$bdir";
	# only map out the library if it is p4 controlled
	# since it won't exist in the branch otherwise
	$gotc=0;

	$bpath=$path;
	$bpath=~ s/$sourceproj/$newproj/g;

	if($client=$cdslist{$bpath}) {
	    $gotc++;
	}

	# handle basic library
	# bring it in exactly as defined !
	if(/INCLUDE/) {
	    print "Bringing in $_\n";
	    print CDSLB $_;
	    next;
	}

    
	if($gotc) {
	    $client=$save;
	    s/$sourceproj/$newproj/g;
	
	    # Check to see if the directory exists
	    # since it may not have been branched
	    $copy=$_;
	    (@elements)=split(' ',$copy);
	    $cmd="ls -d $elements[2] >>/dev/null 2>&1";
	    #print "$cmd\n";
	    system($cmd);
	
	    if($? ne 0) {
		print "Skipping unbranched lib: $elements[1]\n";
		next;
	    }
	    print "Mapping $libname in branch cds.lib\n";
	    print CDSLB $_;
	}
	else {
	    # bring in non-managed libs directly as references to mainline
	    # except for rams
	    if(!( $save =~ /$chip_ram/)) {
		print "Writing $libname in branch cds.lib file\n";
		print CDSLB $save;
	    }
	}
    } elsif (/ \./)  {

	print "# WARNING: Couldn't map dot in $_\n";
	print "# WARNING: Check generated cds.lib\n";
	# exit;

    } else {

	# otherwise just print
	print CDSLB $_;
    }
}


close(CDSLB);
close(CDSL);



unlink("/tmp/cbout");
unlink("/tmp/client");

if($opt_from) {
    system("rm /tmp/bf*.$$");
}

# delete crossbranch
if($crossbranch) {
    $cmd="p4 branch -d $crossbranch";
system($cmd);
}

# delete main labels ????


sub buildclient {


    my($refclient,$newclient,$sourceproj,$targetproj,$nominus,$top)=@_;
    
    print "Reading reference client $refclient\n";

    #Check to see if it really exists
    # Check to see if it exists
    $cmd="p4 clients | grep $refclient";
    system($cmd);
    # Good exit means it exists
    if ($? ne 0) {
      print "Couldn't find it, aborting\n";
      exit(1);
      

    }

    print "Newclient is $newclient\n";
    
    $cmd="p4 -c $refclient client -o";
    
    open(CMD, "$cmd|") || die ;
    
    open(CMDOUT, ">/tmp/cbout") || die ;
    
    while(<CMD>) {


      # Enable site compression
      if($opt_site) {
	if(/nocompress/) {
	  s/nocompress/compress/g;
	  
	  print CMDOUT "$_\n";
	}
      }
	
	if(/^Client/) {
	    
	    print CMDOUT "Client: $newclient\n\n";
	    
	}
	
	if(/^Description/) {
	    
	    print CMDOUT "Description: client for $bname $df[0] $df[1] $df[2] $df[5] built by $user\n";
	    
	}
	
	if(/^Root/) {
	    
	  if($opt_block eq "tapeout") {
	    $root=$targetproj;
	  } else {
	    $root=$targetproj."/".$bname;
	  }
	    print CMDOUT "Root: $root\n";
	    
	}
	
	if(/^View/) {
	    
	    print CMDOUT "$_\n";
	}
	

	if(/^\t\-{0,1}\/\/depot/) {
	    
	    if(!$opt_from2) {
		$newdepot="depot/".$bname;
		
		# New LHS
		s/depot\/$chip\/$rev/$newdepot/g ; 
	    } else {
		$newdepot="depot/".$bname;
		s/$opt_from2\///g;
		s/depot\/$chip\/$rev/$newdepot/g ; 
	    }
	    # New RHS
	    
	    s/$refclient/$newclient/g;
	    
	    # Skip the minus
	    # to make sure that minus lines get branched
	    # even though we want them (the minus signs) in the client after
	    # branching is complete 
	    # to prevent overlapping Cadence library clients
	    # are you following me ?
	    
	    if($nominus eq "1") {
		if(/^\t\-/) {
		    s/\-//g;
		}
	    }

	    print CMDOUT $_;
	}
    }
    close(CMDOUT);
    
    print "Building $newclient from $refclient\n";
    
    $cmd="p4 -c $newclient client -i < /tmp/cbout > /dev/null";
    system($cmd);
}


sub getfileparents {

    if($opt_noint) {
	return;
    }

    # Minimise the number of system calls so use lots of files
    # and pass to p4 using -x option

    my($branch,$client,$flist,$flistl)=@_;

    my($cmd);

    print "\nGetting file list for $client\n";

    $cmd="p4 files //depot/".$branch."/...@".$client.">/tmp/bfiles.$$";
    system($cmd);


    # get branch and integrate files
    # since they (most likely) came from the mainline
    
    # TODO: TRAP if they didn't here or later 

    $cmd="grep  '\\- branch change'  /tmp/bfiles.$$ > /tmp/bfilesib.$$";
    system($cmd);
    $cmd="grep  '\\- integrate change' /tmp/bfiles.$$ >> /tmp/bfilesib.$$";
    system($cmd);

    $cmd="grep -v '\\- integrate change' /tmp/bfiles.$$ > /tmp/bfilesnib.$$";
    system($cmd);
    $cmd="grep -v '\\- branch change'  /tmp/bfilesnib.$$ > /tmp/bfileslocal.$$";
    system($cmd);

    #print "Generating integrated file list\n";
    &genlist("/tmp/bfilesib.$$",\%$flist,\%$flistl,"ib");
    #print "Generating local file list\n";
    &genlist("/tmp/bfileslocal.$$",\%$flist,\%$flistl,"local");
}



sub genlist {


    my($infile,$flist,$flistl,$faction)=@_;

    my($cmd,$record,$checkri,$catchver,@vinfo,$index,$count);
    my($version,$action,$dfv,@dinfo,$ldf,$getver,$pversion,@pdata,@copydata);
    
    
    # read the file list and produce a list to pass to filelog
    # but stash the version numbers in an array so we can pull 
    # out the right data from the filelog
    
    open(FLISTF, ">/tmp/bflist.$$") || die;
    open(INFILEF, "< $infile") || die ;
    
    
    while(<INFILEF>) {
	
	
	(@fdata)=split;

	$dfv=$fdata[0];

	(@dinfo)=split('#',$dfv);


	$df=$dinfo[0];
	$version=$dinfo[1];
	$action=$fdata[2];
	
	print FLISTF "$df\n";
	push(@vinfo,$version);
    }

    close(FLISTF);
    close(INFILEF);

    $cmd="p4 -x /tmp/bflist.$$ filelog >/tmp/bflog.$$";
    system($cmd);

    

    open(CMD, "</tmp/bflog.$$") || die;
    
    $record=0;
    # reverse integrate check
    $checkri=1;
    $catchver=0;
    $index=0;
    while(<CMD>) {
	chop;
	
	
	if( (/^\/\/depot/ || eof) && $record && $faction eq "local") {
	    $ldf=$depot."#".$getver;
	    #print "FLISTL $ldf\n";
	    $$flistl{$depot}=$ldf;
	    $record=0;
	    $catchver=0;
	    $index++;
	    
	}
	
	# if a branch back/from record could not be found treat as local edit
	if( /^\/\/depot/ && $record && $faction eq "ib") {
	    $ldf=$depot."#".$getver;
	    $$flistl{$depot}=$ldf;
	    $record=0;
	    $catchver=0;
	    $index++;
	}

	

	# New depot file record begins here
	if( /^\/\/depot/ && !$record) {
	    $depot=$_;
	    $catchver=1;
	    $checkri=1;
	}
	
	
	$getver=$vinfo[$index];
	

	# Got a new record, make sure we catch the right version
	# $record now signifies that we are ready to process the info
	
	if(/\.\.\. \#$getver/ && $catchver) {
	    $record=1;
	}

	# Look for branch into info if in local mode
	# if we find it, reset counter so we can find next valid record
	if(/\.\.\. \.\.\. [a-z]+ into \/\/depot\/BALI/ && $record && $faction eq "local") {
	    (@copydata)=split;
	    $count++;
	    (@pdata)=split('#',$copydata[4]);
	    # eliminate #1,#4 style syntax ( ie we want #4)
	    $pversion=$pdata[0]."#".$pdata[$#pdata];
	    #print "K $pdata[0]\n";
	    $$flist{$pdata[0]}=$pversion;	    
	    $checkri=0;
	    $record=0;
	    $catchver=0;
	    $index++;
	}

	#if we didn't find a branch into record, it was a local edit


	
	
	if(/\.\.\. \.\.\. [a-z]+ from/ && $record && $faction eq "ib" && !/gfx_$chip/) {
	    # may not have been branched from mainline
	    (@copydata)=split;
	    $count++;
	    #print "$count $pversion\n";
	    (@pdata)=split('#',$copydata[4]);
	    # eliminate #1,#4 style syntax ( ie we want #4)
	    $pversion=$pdata[0]."#".$pdata[$#pdata];
	    #print "Pushing $pversion\n";
	    $$flist{$pdata[0]}=$pversion;
	    $record=0;
	    $catchver=0;
	    $index++;
	}
    }
    close(OFILE);
    
}

# interrupt signal handler

sub handler {    
    my $sig = @_;
    $SIG{'INT'} = 'IGNORE';  # ignore SIGINT
    warn "Caught a SIG$sig--shutting down\n";
    exit();
}