~ubuntu-branches/ubuntu/oneiric/kdesdk/oneiric-updates

#!/usr/bin/perl

# Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>

$COMMAND = "unsercmake";

$VERSION = "$COMMAND 0.32";

# This script allows you to build a target library including dependency checking, but it

# limits the dependency checking to the current dir and its subdirs meaning a lot of

# unwanted steps are skipped.

# user settings...

# if we assume the user has something like:  /kde/project as a sourcedir and /kde/current/project

# as a build dir then we can auto-switch between those dirs

# Please alter the variable to set the basedir and the builddir.  Like this:

#  BASE=BUILD

# Examples:

#  $buildDirType = "/kde=/kde/current";

#  $buildDirType = "kde/{project}=kde/{project}/build";

$buildDirType = "";

##########################

# Copyright (c) 2006-2010 Thomas Zander <zander@kde.org>

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License,

# or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

if ($buildDirType eq "") {

    print "Not setup!\n";

    print "  This tool can automatically switch from your source dir to the builddir.\n";

    print "  To do this correctly you have to alter the $COMMAND using your editor\n";

    print "  and alter the buildDirType variable according to the comments.\n";

    exit;

}

#argument options

$argMap{"C"}="directory";

$argMap{"j"}="jobs";

$argMap{"n"}="just-print";

$argMap{"v"}="verbose";

$argMap{"k"}="keep-going";

$argMap{"p"}="projecthelp";

$argMap{"h"}="help";

$argMap{"e"}="exclude";

$argMap{"q"}="quiet";

@options=split(" ", "help directory jobs just-print verbose keep-going version projecthelp exclude quiet");

@argCommands=split(" ","directory jobs exclude");

&parseArguments(@ARGV);

if(defined $help) {

    print "Usage: $COMMAND [OPTION] ...\n";

    print "Available options:\n\n";

    print "  -h,	--help     	This help.\n";

    print "  -p 	--projecthelp	print project help information\n";

    print "  -j,	--jobs=N	Allow N parallel jobs.\n";

    print "  -k,	--keep-going	Keep going when some targets can't be made.\n";

    print "  -C,	--directory=dir	Change to directory dir before doing anything.\n";

    print "  -v,	--verbose	Show verbose output.\n";

    print "     	--version	Show version information and copyright notice.\n";

    print "  -n 	--just-print	Only print out the commands to call.\n";

    print "  -q 	--quiet     	Don't print details\n";

    print "  -e 	--exclude=RegEx	Exclude libraries and subdirs based on a regular expression\n";

    exit;

}

if(defined $version) {

    print "$VERSION\nWritten by Thomas Zander\n\nThis is free software see the source for copying conditions.  There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n";

    exit;

}

if(defined $directory) {

    chdir $directory || die "Failed to change directory to '$directory'\n";

}

while(! -f "CMakeFiles" && ! -f "CMakeLists.txt") {

    # for the case where there is a subdir but that subdir does not have a cmakefile

    chdir ".." || die "Error: Can not find a cmake based basedir\nPlease start from the source dir\n";

    if(`pwd` eq "/\n") {

        die "Error: Can not find a cmake based basedir\nPlease start from the source dir\n";

    }

}

$dir=`pwd`;

chomp($dir);

$builddir = "$dir/";

# find the build-dir where the Makefile lives

@bd = split("=", $buildDirType);

if($#bd > 0) {

    # make sure slashes are all round

    $bd[0]="/$bd[0]/";

    $bd[1]="/$bd[1]/";

    $bd[0]=~s/\/\//\//g;

    $bd[1]=~s/\/\//\//g;

    my $wildcard="";

    if($bd[0]=~/(\{.*\})/) { # used {project} wildcard

        $wildcard=$1;

        if($bd[1]=~/$wildcard/) {

            $bd[0]=~s/$wildcard/(.*?)/;

        }

    }

    if($builddir=~/$bd[0]/ && $builddir=~/$bd[1]/ == false) {

        my $project=$wildcard;

        $builddir=~/$bd[0]/;

        if($builddir=~m/$bd[0]/) {

            $project=$1;

        }

        $builddir=~s/$bd[0]/$bd[1]/;

        if($wildcard ne "" && $project ne "") {

            $builddir=~s/$wildcard/$project/;

        }

        #print "$dir => $builddir\n";

    }

}

$makeDependNeeded = 0;

&readCmakeFile(".");

if(defined $projecthelp) {

    print "\nLibraries:\n\n";

    foreach $key (sort {uc($a) cmp uc($b)} @libraries) {

        print " $key";

        if(defined $exclude && $key=~/$exclude/) {

            print "  [excluded]";

        }

        print "\n";

    }

    exit;

}

$doInstall = 0;

if($#userArgs >= 0) { # limit to user request

    foreach $lib (@userArgs) {

        if($lib eq "install") {

            $doInstall = 1;

            if($#userArgs == 0) {

                @targets = @libraries;

            }

            next;

        }

        my $pureLib = $lib;

        $pureLib=~s/^[\/ \\]*//;

        $pureLib=~s/[\/ \\]*$//;

        if(&contains($pureLib, @libraries)) {

            push @targets, $pureLib;

        }

        else {

            push @nonLibTargets, $lib;

        }

    }

}

else {

    @targets=@libraries;

}

foreach $lib (@targets) { # add dependencies

    @deps = &dependencies(0, $lib);

    LIB: foreach $l (@deps) {

        if($l eq "ERROR") {

            exit 1;

        }

        if(defined $exclude && $l=~/$exclude/) {

            next;

        }

        foreach $x (@maketargets) {

            if($l eq $x) {

                next LIB;

            }

        }

        push @maketargets, $l;

    }

}

# cd to builddir

chdir $builddir || die "Can't find builddir '$builddir'\n";

if($makeDependNeeded) {

    system ("make depend") == 0 or exit 1;

}

@actualTargets=`make help`;

foreach $target (@nonLibTargets) {

    foreach $h (@actualTargets) {

        if($h=~/\b$target\b/) {

            push @maketargets, $target;

        }

    }

}

if($doInstall == 0 && $#maketargets < 0) {

    print "No targets\n";

    exit;

}

if(defined $jobs) {

    $jobs="-j $jobs";

}

if(defined $verbose) {

    $verbose="VERBOSE=0";

}

foreach $lib (@maketargets) {

    chdir "$builddir/$locations{$lib}";

    $dir = $locations{$lib};

    $dir=~s/^\.\///;

    if(&checkTargetAvail($lib) == 1) {

        if(! defined $quiet) {

            print "Building lib: $lib (in $dir)\n";

        }

        if(defined $just_print) {

            next;

        }

        foreach $h (@actualTargets) {

            if($h=~/(\b$lib\_automoc)/) {

                system ("make $jobs $verbose $1");

                last;

            }

        }

        my $rc = system ("make $jobs $verbose $lib/fast");

        if(!(defined $keep_going) && $rc != 0) {

            exit 1;

        }

    }

    elsif(! defined $quiet) {

        print "Skipping lib: $lib (in $dir)\n";

    }

}

# install!

if($doInstall == 1) {

    if(! defined $quiet) {

        print "Installing changed files";

        #if($dir ne ".") { print " in '$dir'"; }

        print "\n";

    }

    if(! defined $just_print) {

        @output=`(cd $builddir && make install/fast)`;

        my $line;

        foreach $line (@output) {

            if ($line=~/^-- (Installing: .*)$/) {

                print "$1\n";

            }

        }

    }

}

###############

sub readCmakeFile {

    my $dir=shift(@_);

    my $file="CMakeLists.txt";

    if($makeDependNeeded == 0) {

        my $buildAge = (stat("$builddir/$dir/CMakeFiles/CMakeDirectoryInformation.cmake"))[9];

        my $fileAge = (stat("$dir/$file"))[9];

        if($fileAge > $buildAge) {

            $makeDependNeeded = 1;

            print "makeDepend needed due to $dir\n";

        }

    }

    my @subdirs;

    open FILE, "$dir/$file";

    my $inLink=0;

    my $lib = "";

    foreach $line (<FILE>) {

        if($inLink == 0 && $line=~/^\s*add_subdirectory\s*\((.*)\)/i) {

            my $d=$1;

            $d=~s/^\s*//;  #chomp

            $d=~s/\s*$//;

            push @subdirs, $d;

        }

        my $libs = "";

        if($inLink == 1) {

            $libs = $line;

        }

        if($line=~/^\s*target_link_libraries\s*\((.*)/) {

            $libs = $1;

            $inLink=1;

        }

        if($inLink == 1 && $libs ne "") {

            foreach $i (split(" ", $libs)) {

                if($i=~/\)$/) {  # incase no space was used

                    $i=~s/\)$//;

                    $inLink = 0;

                }

                if($i eq ")") { #incase a space was used

                    $inLink = 0;

                }

                elsif($inLink==1 && $lib eq "") { # a library is defined in this file

                    $lib = $i;

                    push @libraries, $lib;

#print "found lib: $lib\n";

                    $locations{$lib} = "$dir";

                }

                else { # and that libraries dependencies

                    $$lib .= "$i ";

#print "   supportlib $i\n";

                }

            }

            $libs ="";

        }

        if($inLink == 0) {

            $lib = "";

        }

    }

    close FILE;

    # only go into subdir when the DartTestfile lists the subdir.

    open FILE, "$builddir/$dir/DartTestfile.txt";

    foreach $line (<FILE>) {

        if($line=~/^SUBDIRS\s*\((.*)\)/) {

            my $subdir;

            foreach $subdir (@subdirs) {

                if(defined $exclude && "/$subdir/"=~/$exclude/) {

                    next;

                }

                if($line=~/\b$subdir\b/) {

                    &readCmakeFile("$dir/$subdir");

                }

            }

            last;

        }

    }

    close FILE;

}

sub dependencies() {

    my $level=shift(@_);

    my $target=shift(@_);

    if($level > 12) {

        print "ERROR; dependency checking hit 12 levels deep, probably a circular dependency, baling out\n";

        print " dependencies traceback (bottom depends on top):\n";

        print " $target\n";

        return "ERROR";

    }

#my $inset ="";

#for($i=0; $i < $level; $i++) { $inset .="  "; }

#print "$inset |dependencies of '$target'\n";

    my @depend;

    my $lib;

#print "$inset depsLine='$$target'\n";

    foreach $lib (split(" ", $$target)) {

        my $found=0;

        my $l;

        # if not in our libraries, skip it.

        foreach $l (@libraries) {

            if($l eq $lib) {

                $found=1;

                last;

            }

        }

        if($found == 0) {

            next;

        }

#print "$inset has dependency $lib\n";

        if(&contains($lib, @depend) == 0) {

#print "$inset  $lib not yet present in: \"";

#foreach $dslf (@depend) {

#    print  " $dslf";

#}

#print "\"\n";

            # before we add it, lets find the dependencies of that library

            foreach $l (&dependencies($level+1, $lib)) {

                if($l eq "ERROR") {

                    print " $target\n";

                    return "ERROR";

                }

                if(&contains($l, @depend) == 0) {

                    push @depend, $l;

                }

            }

            push @depend, $lib;

        }

    }

    if(&contains($target, @depend) == 0) {

        push @depend, $target;

    }

#foreach $dslf (@depend) {

#    print  "$inset  += '$dslf'\n";

#}

    return @depend;

}

## Returns 1 if the first arg is already present in the rest of the array, 0 otherwise

sub contains() {

    my $new=shift(@_);

    @array = @_;

    my $item;

    foreach $item (@array) {

        if($item eq $new) {

            return 1;

        }

    }

    return 0;

}

sub parseArguments() {

    @arguments=@_;

    for($i=0; $i<=$#arguments; $i++) {

        if($arguments[$i]=~/(-{1,2}\S+?)(=\S+|)$/) {

            $command=$1;

            $param=$2;

            if($command=~/^-\b(.)(.*)/) {

                my $char=$1;

                $param=$2;

                $command=$argMap{$char};

            }

            $command=~s/^--//;

            if(&contains($command, @options) == 0) {

                print "unrecognized option '$arguments[$i]'\n";

                print "Try `$COMMAND --help' for more information.\n";

                exit 1;

            }

            if($param eq "" && &contains($command, @argCommands) == 1) {

                $i++;

                if($arguments[$i]=~/^-/ || $#arguments < $i) {

                    print "Missing argument: $arguments[$i-1]\n";

                    exit 1;

                }

                $param = $arguments[$i];

            }

            if($param eq "") {

                $param =1;

            }

            $command=~s/\W/_/g;

            # print "setting param $command\n";

            $$command=$param;

        }

        else {

            push @userArgs, $arguments[$i];

        }

    }

}

sub checkTargetAvail() {

    my $target=shift(@_);

    open FILE, "Makefile";

    foreach $line (<FILE>) {

        if($line=~/^$target:/) {

            close FILE;

            return 1;

        }

    }

    close FILE;

    return 0;

}