songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cgal/Scripts/developer_scripts/create_internal_release

857 lines
26 KiB
Perl
Executable File
Raw Blame History

#!/usr/bin/env perl
#this script generates the internal release
use Cwd;
use File::Find;
use Getopt::Std;
sub usage() {
print STDERR<<"EOF";
usage:
$0 (-h|-r)
[-n version number]
[-d releasedir] [-a allpackagesdir]
[-s scriptsdir]
[-l lockfile] [-p packagesfile]
Exactly one of the options -h or -r must be present.
-h show this message and quit
-r release version to be created
-n version number (CGAL_VERSION_NR)
-d releasedir, default releasedir is the current dir
-a allpackagesdir, default is releasedir/trunk
-s scriptsdir, default is releasedir
-l lockfile, default is releasedir/release_creation.lock
-p packagesfile, default is releasedir/include_in_release
The version number is stored in include/CGAL/version.h.
The RELEASEDIR is the place where the new release will be created.
The ALLPACKAGESDIR is the directory that contains the checked out packages
from the SVN. Could be trunk or some branch.
The SCRIPTSDIR is the place where you have the cgal_create_makefile script.
You can take this script from SVN/Scripts/scripts/cgal_create_makefile.
You need this script to create the default makefiles for examples and
tests.
The LOCKFILE is some file used by lockfile command as a mutex.
The PACKAGESFILE is the file that contains a list of the packages you want
to include in this release. In fact it is a filter for packages you have
in ALLPACKAGESDIR. There is one file that is used to create the CGAL
internal release in SVN/Maintenance/release_building/include_in_release.
You can take that one too.
Example of how to use the script:
>svn co svn+ssh://scm.gforge.inria.fr/svn/cgal/trunk
>./create_internal_release -r CGAL-3.3-I-1
or
>./create_internal_release -r CGAL-3.3-I-7 -d \$HOME -a \$HOME/CGALSVN/trunk -s \$HOME/scripts -l release_creation.lock -p include_in_release
EOF
}
my $TEMPFILE="TEMPFILE.$$";
#----------------------------------------------------#
# Initialisation #
#----------------------------------------------------#
my (
$VERSION,
$VERSION_NR,
$LOCKFILE,
$ALLPACKAGESDIR,
$RELEASEDIR,
$MAINDIR,
$SCRIPTSDIR,
$LOCKCMD,
$packages_file
);
$RELEASEDIR=cwd();
$ALLPACKAGESDIR="$RELEASEDIR/trunk";
$LOCKFILE="$RELEASEDIR/release_creation.lock";
$SCRIPTSDIR=$RELEASEDIR;
$LOCKCMD='lockfile';
$packages_file="$RELEASEDIR/include_in_release";
sub termination_signal_handler {
unlink $LOCKFILE;
exit 1;
}
sub lock()
{
if (system("$LOCKCMD", "-r", '10', "$LOCKFILE") != 0) {
print STDERR <<"TOTHIER";
The script could not proceed because
it could not acquire the needed lock on file $LOCKFILE.
TOTHIER
exit 1;
}
$SIG{INT} = \&termination_signal_handler;
$SIG{TERM} = \&termination_signal_handler;
}
sub unlock()
{
unlink $LOCKFILE;
$SIG{INT} = 'DEFAULT';
$SIG{TERM} = 'DEFAULT';
}
sub create_packages_dir(){
print "Creating $VERSION/Packages directory ...\n";
chdir $RELEASEDIR or die;
if (! -f $packages_file){
print STDERR "$packages_file file does not exist\n";
unlock;
die "\n";
}
open PACKAGES_TO_INCLUDE, "$packages_file" or die;
while (<PACKAGES_TO_INCLUDE>){
chomp;
s/\s*//g;
next if /^$/;
$is_permitted_package{$_}=1;
}
close PACKAGES_TO_INCLUDE;
opendir ALLPACKAGESDIR, $ALLPACKAGESDIR or die;
while (defined($package_name = readdir(ALLPACKAGESDIR))) {
next unless $is_permitted_package{$package_name};
chdir "$RELEASEDIR/$VERSION" or die;
mkdir('Packages', 0775);
chdir 'Packages';
mkdir($package_name, 0775);
if (-f "$ALLPACKAGESDIR/$package_name/maintainer"){
system('cp', "$ALLPACKAGESDIR/$package_name/maintainer", "$RELEASEDIR/$VERSION/Packages/$package_name");
}
if (-f "$ALLPACKAGESDIR/$package_name/version"){
system('cp', "$ALLPACKAGESDIR/$package_name/version", "$RELEASEDIR/$VERSION/Packages/$package_name");
}
if (-f "$ALLPACKAGESDIR/$package_name/changes.txt"){
system('cp', "$ALLPACKAGESDIR/$package_name/changes.txt", "$RELEASEDIR/$VERSION/Packages/$package_name");
}
if (-f "$ALLPACKAGESDIR/$package_name/description.txt"){
system('cp', "$ALLPACKAGESDIR/$package_name/description.txt", "$RELEASEDIR/$VERSION/Packages/$package_name");
}
}
closedir ALLPACKAGESDIR;
}
sub create_global_makefile{
printf("Creating the global makefile in the test dir ...\n");
chdir "$RELEASEDIR/$VERSION" or die;
if ( -e "test/Makefile"){
system("rm -f Makefile");
}
opendir testdir, "test";
@dirs = readdir testdir;
closedir testdir;
shift @dirs; shift @dirs;
chdir "test" or die;
open(TEMPFILE, ">tempfile") or die;
print TEMPFILE "testsuite: ";
foreach $dir (@dirs){
if ( -d $dir){
print TEMPFILE "test_$dir ";
}
}
print TEMPFILE "\n";
foreach $dir (@dirs){
if ( -d $dir){
print TEMPFILE "test_$dir:\n\t+ ./run_testsuite $dir\n";
}
}
system('mv', "tempfile", 'Makefile');
};
sub install_packages() {
my ($filename, $direc, %is_permited_package, $package_name, $tmp_package_name);
print "Installing packages ...\n";
chdir $RELEASEDIR or die;
if (! -f $packages_file){
print STDERR "$packages_file file does not exist\n";
unlock;
die "\n";
}
open PACKAGES_TO_INCLUDE, "$packages_file" or die;
while (<PACKAGES_TO_INCLUDE>){
chomp;
s/\s*//g;
next if /^$/;
$is_permitted_package{$_}=1;
}
close PACKAGES_TO_INCLUDE;
opendir ALLPACKAGESDIR, $ALLPACKAGESDIR or die;
while (defined($package_name = readdir(ALLPACKAGESDIR))) {
next unless $is_permitted_package{$package_name};
$dont_submit="$ALLPACKAGESDIR/$package_name/dont_submit";
$exclude_command="--exclude-from=$dont_submit";
chdir "$ALLPACKAGESDIR" or die;
if(-f $dont_submit){
system('tar', '-cf', "$RELEASEDIR/temppack.tar", '--exclude=.svn', "$exclude_command", '--exclude=TODO', '--exclude=dont_submit', '--exclude=maintainer', '--exclude=description.txt', '--exclude=changes.txt', "$package_name");
} else {
system('tar', '-cf', "$RELEASEDIR/temppack.tar", '--exclude=.svn', '--exclude=dont_submit', '--exclude=maintainer', '--exclude=description.txt', '--exclude=changes.txt', '--exclude=TODO', "$package_name");
}
system('mv', "$RELEASEDIR/temppack.tar", "$RELEASEDIR/$VERSION/");
chdir "$RELEASEDIR/$VERSION" or die;
system('tar', '-xf', "temppack.tar");
$tmp_package_name = "temp_${package_name}";
system("mv", "$package_name", "$tmp_package_name");
opendir packagename, "$tmp_package_name";
@fichiers = readdir packagename;
closedir packagename;
shift @fichiers; shift @fichiers;
foreach $fichier (@fichiers){
system('cp', '-r', "$tmp_package_name/$fichier", "$RELEASEDIR/$VERSION");
}
system('rm', '-rf', "$tmp_package_name");
}
closedir ALLPACKAGESDIR;
unlink 'temppack.tar', 'description.txt', 'long_description.txt', 'changes.txt', 'submission_info', 'long_description.txt.old';
}
#-----------------------------------------------------------------------#
# set the version information in the include/CGAL/version.h #
#-----------------------------------------------------------------------#
sub create_version_file()
{
chdir "$RELEASEDIR/$VERSION/include/CGAL" or die;
open(TEMPFILE, ">tempfile") or die;
#if VERSION starts with CGAL-, we remove "CGAL-" from version
#the $newver variable will store the right version
if ($result = $VERSION =~ /CGAL-(.*)/){
$newver = $1;
} else {
$newver = $VERSION;
}
# TODO : add `svnversion` Revision.
print TEMPFILE << 'EOF';
// Copyright (c) 2006 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Author(s) : -
// This file is automatically created by create_internal_release.
// Do not edit manually.
#ifndef CGAL_VERSION_H
#define CGAL_VERSION_H
EOF
print TEMPFILE "#define CGAL_VERSION $newver\n";
print TEMPFILE "#define CGAL_VERSION_NR $VERSION_NR\n\n#endif\n";
close TEMPFILE || die "Error closing temporary file: $!\n";
system('mv', "tempfile", 'version.h');
chdir '../..' or die;
}
#-----------------------------------------------------------------------#
# set the version information in the doc_tex/version.tex #
#-----------------------------------------------------------------------#
sub create_version_tex_file()
{
chdir "$RELEASEDIR/$VERSION/doc_tex" or die;
open(TEMPFILE, ">tempfile") or die;
#if VERSION starts with CGAL-, we remove "CGAL-" from version
#the $newver variable will store the right version
if ($result = $VERSION =~ /CGAL-(.*)/){
$newver = $1;
} else {
$newver = $VERSION;
}
print TEMPFILE << 'EOF';
%% This file is automatically created by create_internal_release.
%% Do not edit manually.
EOF
print TEMPFILE "\\gdef\\cgalversion{$newver}\n";
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
my @months = ( "January", "February", "March", "April",
"May", "June", "July", "August", "September",
"October", "November", "December" );
print TEMPFILE "\\gdef\\cgalversiondate{$mday $months[$mon] ", 1900 + $year, "}\n";
close TEMPFILE || die "Error closing temporary file: $!\n";
system('mv', "tempfile", 'version.tex');
chdir '../..' or die;
}
#---------------------------------------------------------------#
# CreateExampleTestDirs
#---------------------------------------------------------------#
sub CreateExampleTestDirs()
{
my $DIR;
print "Creating $VERSION/test/example directories ...\n";
chdir "$RELEASEDIR/$VERSION" or die;
chdir 'examples' or return;
foreach $DIR (glob("*")) {
if ( -d $DIR ) {
system('cp', '-r', "$DIR", "../test/${DIR}_Examples");
}
}
chdir '..';
}
#---------------------------------------------------------------#
# CreateDemoTestDirs
#---------------------------------------------------------------#
sub CreateDemoTestDirs()
{
my $DIR;
print "Creating $VERSION/test/demo directories ...\n";
chdir "$RELEASEDIR/$VERSION" or die;
chdir 'demo' or return;
foreach $DIR (glob("*")) {
if ( -d $DIR ) {
system('cp', '-r', "$DIR", "../test/${DIR}_Demo");
open(CGAL_TEST,">../test/${DIR}_Demo/cgal_test");
print CGAL_TEST <<'EOF';
#! /bin/sh
# This is a script for the CGAL test suite. Such a script must obey
# the following rules:
#
# - the name of the script is cgal_test
# - for every target two one line messages are written to the file 'error.txt'
# the first one indicates if the compilation was successful
# the second one indicates if the execution was successful
# if one of the two was not successful, the line should start with 'ERROR:'
# - running the script should not require any user interaction
# - the script should clean up object files and executables
ERRORFILE=error.txt
#---------------------------------------------------------------------#
# compile
#---------------------------------------------------------------------#
compile()
{
if eval 'make CGAL_MAKEFILE=$CGAL_MAKEFILE \
TESTSUITE_CXXFLAGS="$TESTSUITE_CXXFLAGS" \
TESTSUITE_LDFLAGS="$TESTSUITE_LDFLAGS" all' >compiler_output 2>&1 ; then
echo " succesful compilation " >> $ERRORFILE
cat compiler_output
else
echo " ERROR: compilation " >> $ERRORFILE
eval "2>&1 make CGAL_MAKEFILE=$CGAL_MAKEFILE clean > /dev/null "
eval 'make -k CGAL_MAKEFILE=$CGAL_MAKEFILE \
TESTSUITE_CXXFLAGS="$TESTSUITE_CXXFLAGS" \
TESTSUITE_LDFLAGS="$TESTSUITE_LDFLAGS" all'
fi
rm compiler_output
eval "2>&1 make CGAL_MAKEFILE=$CGAL_MAKEFILE clean > /dev/null "
}
#---------------------------------------------------------------------#
# remove the previous error file
#---------------------------------------------------------------------#
rm -f $ERRORFILE
touch $ERRORFILE
#---------------------------------------------------------------------#
# compile and run the tests
#---------------------------------------------------------------------#
compile
EOF
close(CGAL_TEST);
chmod 0755, "../test/${DIR}_Demo/cgal_test";
}
}
chdir '..';
}
sub CreateConfigurationTestdir(){
print "Creating $VERSION/test/Configuration directory ...\n";
chdir "$RELEASEDIR/$VERSION" or die;
system('cp', '-r', 'config/testfiles', 'test/Configuration');
}
#---------------------------------------------------------------#
# CreateSrcQtTestDir
#---------------------------------------------------------------#
sub CreateSrcQtTestDir()
{
print "Creating $VERSION/test/src_Qt directory ...\n";
chdir "$RELEASEDIR/$VERSION/" or die;
system('cp', '-r', 'src/CGALQt', 'test/src_Qt');
# Must be called after CreateSrcTestDir().
system('cp', 'test/src_CGAL/cgal_test', 'test/src_Qt');
}
#---------------------------------------------------------------#
# CreateSrcCoreTestDir
#---------------------------------------------------------------#
sub CreateSrcCoreTestDir()
{
print "Creating $VERSION/test/src_Core directory ...\n";
chdir "$RELEASEDIR/$VERSION/" or die;
system('cp', '-r', 'src/Core', 'test/src_Core');
# Must be called after CreateSrcTestDir().
system('cp', 'test/src_CGAL/cgal_test', 'test/src_Core');
}
#---------------------------------------------------------------#
# CreateSrcTestDir
#---------------------------------------------------------------#
sub CreateSrcTestDir()
{
print "Creating $VERSION/test/src_CGAL directory ...\n";
chdir "$RELEASEDIR/$VERSION" or die;
system('cp', '-r', 'src/CGAL', 'test/src_CGAL');
open(CGAL_TEST,">test/src_CGAL/cgal_test");
print CGAL_TEST <<'EOF';
#! /bin/sh
# This is a script for the CGAL test suite. Such a script must obey
# the following rules:
#
# - the name of the script is cgal_test
# - for every target two one line messages are written to the file 'error.txt'
# the first one indicates if the compilation was successful
# the second one indicates if the execution was successful
# if one of the two was not successful, the line should start with 'ERROR:'
# - running the script should not require any user interaction
# - the script should clean up object files and executables
ERRORFILE=error.txt
#---------------------------------------------------------------------#
# compile_and_run <target>
#---------------------------------------------------------------------#
compile()
{
echo "Compiling $1 ... "
SUCCES="y"
if eval 'make CGAL_MAKEFILE=$CGAL_MAKEFILE \
TESTSUITE_CXXFLAGS="$TESTSUITE_CXXFLAGS" \
TESTSUITE_LDFLAGS="$TESTSUITE_LDFLAGS" -k $1' ; then
echo " compilation of $1 succeeded" >> $ERRORFILE
else
echo " ERROR: compilation of $1 failed" >> $ERRORFILE
SUCCES=""
fi
eval "2>&1 make CGAL_MAKEFILE=$CGAL_MAKEFILE clean > /dev/null "
}
#---------------------------------------------------------------------#
# remove the previous error file
#---------------------------------------------------------------------#
rm -f $ERRORFILE
touch $ERRORFILE
#---------------------------------------------------------------------#
# compile and run the tests
#---------------------------------------------------------------------#
if [ $# -ne 0 ] ; then
for file in $* ; do
compile $file
done
else
compile lib_no_install
fi
EOF
close(CGAL_TEST);
chmod 0755, 'test/src_CGAL/cgal_test';
}
#---------------------------------------------------------------#
# create cgal_test script in tests
#---------------------------------------------------------------#
sub create_test(){
open(CGAL_TEST,">cgal_test");
print CGAL_TEST <<'EOF';
#! /bin/sh
# This is a script for the CGAL test suite. Such a script must obey
# the following rules:
#
# - the name of the script is cgal_test
# - for every target two one line messages are written to the file 'error.txt'
# the first one indicates if the compilation was successful
# the second one indicates if the execution was successful
# if one of the two was not successful, the line should start with 'ERROR:'
# - running the script should not require any user interaction
# - the script should clean up object files and executables
ERRORFILE=error.txt
#---------------------------------------------------------------------#
# compile_and_run <target>
#---------------------------------------------------------------------#
compile_and_run()
{
echo "Compiling $1 ... "
SUCCES="y"
if eval 'make CGAL_MAKEFILE=$CGAL_MAKEFILE \
TESTSUITE_CXXFLAGS="$TESTSUITE_CXXFLAGS" \
TESTSUITE_LDFLAGS="$TESTSUITE_LDFLAGS" $1' ; then
echo " succesful compilation of $1" >> $ERRORFILE
else
echo " ERROR: compilation of $1" >> $ERRORFILE
SUCCES=""
fi
if [ -n "${SUCCES}" ] ; then
OUTPUTFILE=ProgramOutput.$1.$PLATFORM
rm -f $OUTPUTFILE
COMMAND="./$1"
if [ -f $1.cmd ] ; then
COMMAND="$COMMAND `cat $1.cmd`"
fi
if [ -f $1.cin ] ; then
COMMAND="cat $1.cin | $COMMAND"
fi
echo "Executing $1 ... "
echo
ulimit -t 3600 2> /dev/null
if eval $COMMAND > $OUTPUTFILE 2>&1 ; then
echo " succesful execution of $1" >> $ERRORFILE
else
echo " ERROR: execution of $1" >> $ERRORFILE
fi
else
echo " ERROR: not executed $1" >> $ERRORFILE
fi
eval "make CGAL_MAKEFILE=$CGAL_MAKEFILE clean > /dev/null 2>&1 "
}
#---------------------------------------------------------------------#
# remove the previous error file
#---------------------------------------------------------------------#
rm -f $ERRORFILE
touch $ERRORFILE
#---------------------------------------------------------------------#
# compile and run the tests
#---------------------------------------------------------------------#
if [ $# -ne 0 ] ; then
for file in $* ; do
compile_and_run $file
done
else
EOF
close(CGAL_TEST);
open(CGAL_TEST,">>cgal_test");
my $cfile;
foreach $cfile (glob("*.C")) {
substr($cfile, -2, 2) = "";
print CGAL_TEST " compile_and_run $cfile\n";
}
print CGAL_TEST "fi\n";
close(CGAL_TEST);
chmod 0755, 'cgal_test';
}
#---------------------------------------------------------------#
# make_testscripts and generate makefiles in test and examples
#---------------------------------------------------------------#
sub make_testscripts()
{
my ($DIR, $BASEDIR);
chdir "$RELEASEDIR/$VERSION" or die;
$BASEDIR = cwd();
print "Creating and checking makefiles ...\n";
chdir 'test';
foreach $DIR (glob("*")) {
if ( -d $DIR ) {
chdir $DIR;
if ( -f 'Makefile') {
rename 'Makefile', 'makefile';
}
if ( -f 'makefile' ) {
open MAKEFILE, "makefile";
open NEW_MAKEFILE, ">makefile.new";
while (<MAKEFILE>) {
s/\.o\b/\$(OBJ_EXT)/g;
s/-g\b/\$(DEBUG_OPT)/g;
print NEW_MAKEFILE $_;
}
close NEW_MAKEFILE;
close MAKEFILE;
rename("makefile.new","makefile");
} else {
my $options = '-t';
if ( -f 'cgal_create_makefile_options') {
if (open(OPTIONS, "<cgal_create_makefile_options")) {
$_ = <OPTIONS>;
chomp;
if (/^[\w\s-]+$/) { $options = $_;
} else {
print STDERR "Rejected cgal_create_makefile_options in $DIR\n";
}
close OPTIONS;
}
}
system("$SCRIPTSDIR/cgal_create_makefile", $options) == 0 or die "Execution of $SCRIPTSDIR/cgal_create_makefile failed";
}
if ( ! -f 'cgal_test' ) {
create_test();
}
chdir '..';
}
}
chdir $BASEDIR;
chdir 'examples';
# Windows specific stuff
print "Creating VC++ projects in examples\n";
system("../developer_scripts/examples/C2vcproj", glob("*"));
print "Creating makefiles in examples\n";
foreach $DIR (glob("*")) {
if ( -d $DIR ) {
chdir $DIR;
if ( -f 'Makefile') {
rename 'Makefile', 'makefile';
}
if ( -f 'makefile' ) {
open MAKEFILE, "makefile";
open NEW_MAKEFILE, ">makefile.new";
while (<MAKEFILE>) {
s/\.o\b/\$(OBJ_EXT)/g;
s/-g\b/\$(DEBUG_OPT)/g;
print NEW_MAKEFILE $_;
}
close NEW_MAKEFILE;
close MAKEFILE;
rename("makefile.new","makefile");
} else {
my $options = '-d';
if ( -f 'cgal_create_makefile_options') {
if (open(OPTIONS, "<cgal_create_makefile_options")) {
$_ = <OPTIONS>;
chomp;
if (/^[\w\s-]+$/) { $options = $_;
} else {
print STDERR "Rejected cgal_create_makefile_options in $DIR\n";
}
close OPTIONS;
}
}
system("$SCRIPTSDIR/cgal_create_makefile", $options) == 0 or die "Execution of $SCRIPTSDIR/cgal_create_makefile failed";
}
chdir '..';
}
}
chdir $BASEDIR;
}
#----------------------------------------------------------------#
# check_and_update_file #
#----------------------------------------------------------------#
sub check_and_update_file($$)
{
my ($filename, $filename_with_dir) = @_;
my $header_type = 0;
my $lines_exceeding_length = 0;
my $has_line_directives = 0;
unlink $TEMPFILE;
open SOURCE_FILE, "<$filename" || die "Error opening $filename_with_dir: $!\n";
open TEMPFILE, ">$TEMPFILE" || die;
while ( <SOURCE_FILE> ) {
$header_type = 1
if m|^Copyright \(c\) \d{4](,\s?\d{4})* The CGAL Consortium|;
$header_type = 2
if m|^// Copyright \(c\) \d{4}(,\s?\d{4})* The CGAL Consortium|;
$lines_exceeding_length +=1 if length $_ > 80;
$has_line_directives = 1 if m|^\s*#\s*line\s|;
print TEMPFILE $_;
}
close SOURCE_FILE || die "Error closing $filename_with_dir: $!";
close TEMPFILE || die "Error closing temporary file: $!\n";
rename($TEMPFILE, $filename )
|| system('mv', "$TEMPFILE", "$filename")
|| warn "Could not update file $filename_with_dir\n";
if ($header_type == 0) {
print FILE_CHECKS "$filename_with_dir has unrecognised header.\n";
} elsif ($header_type == 1) {
print FILE_CHECKS "$filename_with_dir has old style header.\n";
}
if ($lines_exceeding_length) {
print FILE_CHECKS "$filename_with_dir has $lines_exceeding_length",
" lines over 80 characters.\n";
}
if ($has_line_directives) {
print FILE_CHECKS "$filename_with_dir has line directives.\n";
}
}
#----------------------------------------------------------------#
# set_file_headers #
#----------------------------------------------------------------#
sub set_file_headers()
{
print "Setting file headers...\n";
chdir "$RELEASEDIR/$VERSION";
open(FILE_CHECKS,">$PARENT_DIR/code_check_$VERSION");
find(\&file_header_setting, 'include', 'src', 'examples', 'config/testfiles');
close FILE_CHECKS;
chdir $MAIN_DIR;
}
sub file_header_setting
{
my ($filename,$dev,$ino,$mode,$nlink,$uid,$gid,$filetype);
$filename = $_;
if ( ! /\.[h|C]$/ ||
! (($dev,$ino,$mode,$nlink,$uid,$gid) = lstat($filename)) ||
! -f _ ) {
return;
}
check_and_update_file($filename, $File::Find::name);
}
#----------------------------------------------------#
# Main entry point #
#----------------------------------------------------#
sub main(){
getopts('hr:a:d:l:p:s:n:');
if ($::opt_h ) {
usage();
die "\n";
}
if ($::opt_d){
$RELEASEDIR = $::opt_d;
$ALLPACKAGESDIR = "$RELEASEDIR/trunk";
$SCRIPTSDIR = "$RELEASEDIR";
$LOCKFILE="$RELEASEDIR/release_creation.lock";
$packages_file="$RELEASEDIR/include_in_release";
}
if ($::opt_r){
$VERSION = $::opt_r;
if ($::opt_n){
$VERSION_NR = $::opt_n;
} else {
$VERSION_NR = $VERSION;
}
} else {
usage();
die "\n";
}
if ($::opt_a){
$ALLPACKAGESDIR = $::opt_a;
}
if ($::opt_s){
$SCRIPTSDIR = $::opt_s;
}
if ($::opt_l){
$LOCKFILE = $::opt_l;
}
if ($::opt_p){
$packages_file = $::opt_p;
}
print "Initializing variables ...\n";
print " Release dir: $RELEASEDIR\n";
print " All packages dir: $ALLPACKAGESDIR\n";
print " Scripts dir: $SCRIPTSDIR\n";
print " Lockfile: $LOCKFILE\n";
print " Packages file : $packages_file\n";
umask(002);
chdir $RELEASEDIR or die;
if (! -d $VERSION){
print "Creating release directory ${VERSION} ...\n";
mkdir($VERSION, 0775);
} else {
print "$VERSION already exists in $RELEASEDIR\n";
print "Please remove it first\n";
exit 1;
}
lock;
create_packages_dir();
install_packages();
CreateConfigurationTestdir();
CreateDemoTestDirs();
CreateExampleTestDirs();
create_version_file();
create_version_tex_file();
make_testscripts();
set_file_headers();
CreateSrcTestDir();
CreateSrcCoreTestDir(); # Must be called after CreateSrcTestDir()
CreateSrcQtTestDir(); # Must be called after CreateSrcTestDir()
create_global_makefile();
unlock;
}
main();
Reference in New Issue View Git Blame Copy Permalink