├── .tag
├── .gitreview
├── util
    └── normalize
    │   ├── normalize.pro
    │   ├── README
    │   └── main.cpp
├── bin
    ├── qt5_tool.bat
    ├── git-qt-grafts.bat
    ├── qt6_tool.bat
    ├── git-reshape
    ├── git-sync-to
    ├── .git-gpush-aliases
    ├── git-pasteapply
    ├── git-edit-commit
    ├── git-gpull
    ├── git-rewrite-author
    ├── git-note-review
    ├── git-pastebin
    ├── git-qt-grafts
    ├── git-split-ws
    ├── git-qt-cherry-pick
    ├── git-ppush
    ├── git-qt-merge-mainlines
    ├── git-ggc
    ├── ibmake.bat
    └── qt6_tool
├── LICENSES
    ├── LicenseRef-Qt-Commercial.txt
    ├── LGPL-3.0-only.txt
    └── GPL-2.0-only.txt
└── git-hooks
    ├── gerrit-bot-cleanup
    ├── git_post_commit_hook
    ├── clang-format-pre-commit
    ├── qt-codereview-mirror
    ├── gerrit-bot-extras
    ├── gerrit_commit_msg_hook
    ├── gerrit-bot
    └── qdoc-bot


/.tag:
--------------------------------------------------------------------------------
1 | e2bf9392470a0efa6ca4e8c1799eaaef9fe03d5f
2 | 


--------------------------------------------------------------------------------
/.gitreview:
--------------------------------------------------------------------------------
1 | [gerrit]
2 | host=codereview.qt-project.org
3 | project=qt/qtrepotools
4 | defaultbranch=master
5 | 


--------------------------------------------------------------------------------
/util/normalize/normalize.pro:
--------------------------------------------------------------------------------
1 | QT = core
2 | CONFIG -= moc
3 | CONFIG += console
4 | mac:CONFIG -= app_bundle
5 | 
6 | SOURCES += main.cpp
7 | 


--------------------------------------------------------------------------------
/bin/qt5_tool.bat:
--------------------------------------------------------------------------------
1 | :: Copyright (C) 2016 The Qt Company Ltd.
2 | :: SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3 | 
4 | @rem ***** This assumes PERL is in the PATH *****
5 | @perl.exe %~dp0qt5_tool %*
6 | 


--------------------------------------------------------------------------------
/bin/git-qt-grafts.bat:
--------------------------------------------------------------------------------
1 | :: Copyright (C) 2016 The Qt Company Ltd.
2 | :: SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3 | 
4 | @rem ***** This assumes PERL is in the PATH *****
5 | @perl.exe %~dp0git-qt-grafts %*
6 | 


--------------------------------------------------------------------------------
/bin/qt6_tool.bat:
--------------------------------------------------------------------------------
1 | :: Copyright (C) 2020 The Qt Company Ltd.
2 | :: SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3 | 
4 | @rem ***** This assumes Python 3 is in the PATH *****
5 | @python.exe %~dp0qt6_tool %*
6 | 


--------------------------------------------------------------------------------
/bin/git-reshape:
--------------------------------------------------------------------------------
 1 | #! /bin/sh
 2 | # Copyright (C) 2019 Oswald Buddenhagen
 3 | # Contact: http://www.qt.io/licensing/
 4 | #
 5 | # You may use this file under the terms of the 3-clause BSD license.
 6 | # See the file LICENSE from this package for details.
 7 | 
 8 | # This script provides a convenient way to reshape the local branch
 9 | # without accidentally rebasing it even if the remote was fetched
10 | # meanwhile.
11 | 
12 | b=$(git merge-base @{u} HEAD) || exit
13 | exec git rebase -i $b "$@"
14 | 


--------------------------------------------------------------------------------
/LICENSES/LicenseRef-Qt-Commercial.txt:
--------------------------------------------------------------------------------
1 | Licensees holding valid commercial Qt licenses may use this software in
2 | accordance with the the terms contained in a written agreement between
3 | you and The Qt Company. Alternatively, the terms and conditions that were
4 | accepted by the licensee when buying and/or downloading the
5 | software do apply.
6 | 
7 | For the latest licensing terms and conditions, see https://www.qt.io/terms-conditions.
8 | For further information use the contact form at https://www.qt.io/contact-us.
9 | 


--------------------------------------------------------------------------------
/bin/git-sync-to:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | while [ ! -f cmake/QtSynchronizeRepo.cmake ]
 4 | do
 5 |     cd ..
 6 |     if [ $? -gt 0 ]
 7 |     then
 8 |         >&2 echo "This git command needs to be run within a Qt supermodule clone"
 9 |         exit 1
10 |     fi
11 | done
12 | 
13 | module="$1"
14 | shift
15 | revision="$1"
16 | shift
17 | 
18 | if [ ! -d $module ]
19 | then
20 |     >&2 echo "Can't find worktree for the reference module '$module'"
21 |     exit 2
22 | fi
23 | 
24 | cmake -DSYNC_TO_MODULE="$module" -DSYNC_TO_BRANCH="$revision" "$@" -P cmake/QtSynchronizeRepo.cmake
25 | 


--------------------------------------------------------------------------------
/util/normalize/README:
--------------------------------------------------------------------------------
 1 | This tool greps through files for SIGNAL() or SLOT() macros and pipes the signals/slots
 2 | through QMetaObject::normalizedSignature().
 3 | 
 4 | Rationale: In connect statements, you'll get a micro-speed update when passing in normalized
 5 | signatures for signals and slots.
 6 | 
 7 | Run it without any arguments to see the command line parameters.
 8 | 
 9 | Typical usage on Qt:
10 | 
11 | # find all files with non-normalized signal/slot connections
12 | normalize $QTDIR/src
13 | # replace all non-normalized signal/slots
14 | normalize --modify $QTDIR/src
15 | # "git diff" and/or "git gui" to see that everything is OK then submit :)
16 | cd $QTDIR/src
17 | git commit -a -m "Normalize signal/slot signatures"
18 | 


--------------------------------------------------------------------------------
/git-hooks/gerrit-bot-cleanup:
--------------------------------------------------------------------------------
 1 | #! /bin/sh
 2 | 
 3 | # Copyright (C) 2015 The Qt Company Ltd.
 4 | # Contact: http://www.qt.io/licensing/
 5 | #
 6 | # You may use this file under the terms of the 3-clause BSD license.
 7 | # See the file LICENSE from this package for details.
 8 | #
 9 | 
10 | # Run this once a day (from a cron job) to keep the sanity bot's
11 | # git clones performing well.
12 | 
13 | instance=sanitybot
14 | test -n "$1" && instance=$1
15 | 
16 | root=$(git config $instance.gitbasedir)
17 | if test -z "$root"; then
18 |     echo "Error: $instance.gitbasedir not set" >&2
19 |     exit 1
20 | fi
21 | cd "$root" || exit
22 | find -name '*.git' -type d -prune | while read dir; do (
23 |     # use "git config --global gc.packrefs notbare" to make sure this works
24 |     test -d $dir/refs/changes || exit
25 |     echo "Entering $dir ..."
26 |     cd "$dir" || exit
27 |     find refs/changes -mindepth 1 -mtime +10 -delete
28 |     git gc
29 | ); done
30 | 


--------------------------------------------------------------------------------
/git-hooks/git_post_commit_hook:
--------------------------------------------------------------------------------
 1 | #! /bin/sh
 2 | # Copyright (C) 2015 The Qt Company Ltd.
 3 | # Contact: http://www.qt.io/licensing/
 4 | #
 5 | # You may use this file under the terms of the 3-clause BSD license.
 6 | # See the file LICENSE from this package for details.
 7 | #
 8 | 
 9 | # Usage: in every repository you want to have checked:
10 | #    cd .git/hooks
11 | #    ln -s /path/to/git_post_commit_hook post-commit
12 | #
13 | 
14 | makeAbsolute() {
15 |     case $1 in
16 |         /*)
17 |             # already absolute, return it
18 |             echo "$1"
19 |             ;;
20 |         *)
21 |             # relative, prepend $2 made absolute
22 |             echo `makeAbsolute "$2" "$PWD"`/"$1" | sed 's,/\.$,,'
23 |             ;;
24 |     esac
25 | }
26 | 
27 | me=$0
28 | if test -L "$me"; then
29 |     # Try GNU readlink(1)
30 |     nme=`readlink -nf "$me" 2>/dev/null`
31 |     if test -n "$nme"; then
32 |         me=$nme
33 |     else
34 |         # No GNU readlink(1), so let's try ls -l
35 |         base=`dirname "$me"`
36 |         me=`ls -l "$me" | sed 's/^.*-> //'`
37 |         me=`makeAbsolute "$me" "$base"`
38 |     fi
39 | fi
40 | 
41 | sha1=${1-HEAD} # just for debugging
42 | exec `dirname "$me"`/sanitize-commit $sha1 strict >&2
43 | 


--------------------------------------------------------------------------------
/bin/.git-gpush-aliases:
--------------------------------------------------------------------------------
 1 | # Global configuration file for the 'git gpush' script.
 2 | 
 3 | # This section contains a mapping of #qt-labs et al. IRC nicks to Gerrit
 4 | # usernames, allowing for easy listing of reviewers.
 5 | [aliases]
 6 | aalpert=416365416c
 7 | alcroito=alexandru.croitor
 8 | andre=apoenitz
 9 | anshaw=andysh
10 | bhughes-mpd=bhughes
11 | bnilsen=bjnilsen
12 | bogdan=taipan
13 | carewolf=allan.jensen
14 | danimo=dmolkent
15 | ddenis=dzyubenk
16 | dfaure=dfaure_kdab
17 | eike=con
18 | fkleint=kleint
19 | fregl=frederik
20 | girishr=girish
21 | guruz=mgoetz2
22 | harryf=fernenge
23 | iieklund=iknd
24 | jaheikki3=janihe
25 | jasmacdon=macadder
26 | jbache=bachewii
27 | jbarron=jabarron
28 | jlind=jolind
29 | jobor=jbornema
30 | khansen=kenthans
31 | kkoehne=kkohne
32 | lars=laknoll
33 | lqi=liaqi
34 | mariusso,mstormo=stormols
35 | msorvig=sorvig
36 | ossi,ossi|tt=buddenha
37 | paulot=tvete
38 | rloehning=rlohning
39 | roberto__=raggi
40 | rohanpm=rohan@mcgovern.id.au
41 | shanek=shkearns
42 | sroedal=rodal
43 | steveire=stephen.kelly
44 | torarne=vestbo
45 | tronical=shausman
46 | 
47 | # Keys from this section will be mapped to gpush.<key> git config keys,
48 | # allowing for easy configuration of site-wide defaults.
49 | [config]
50 | addbase = no
51 | 


--------------------------------------------------------------------------------
/git-hooks/clang-format-pre-commit:
--------------------------------------------------------------------------------
 1 | #! /bin/sh
 2 | # Copyright (C) 2018 The Qt Company Ltd.
 3 | # Contact: http://www.qt.io/licensing/
 4 | #
 5 | # You may use this file under the terms of the 3-clause BSD license.
 6 | # See the file LICENSE from this package for details.
 7 | #
 8 | 
 9 | # Usage: in every repository you want to have checked:
10 | #    cd .git/hooks
11 | #    ln -s ../../../qtrepotools/git-hooks/clang-format-pre-commit pre-commit
12 | #    mklink pre-commit ..\..\..\qtrepotools\git-hooks\clang-format-pre-commit
13 | #
14 | 
15 | CLANG_FORMAT=$(which git-clang-format 2>/dev/null)
16 | if [ -z "$CLANG_FORMAT" -a -d "$LLVM_INSTALL_DIR" ]; then
17 |     export PATH=$PATH:$LLVM_INSTALL_DIR/bin
18 |     CLANG_FORMAT=$(which git-clang-format 2>/dev/null)
19 | fi
20 | 
21 | if test -z "$CLANG_FORMAT"; then
22 |     echo "Please install clang-format and make sure git-clang-format is in the path."
23 |     exit 0
24 | fi
25 | 
26 | CLANG_FORMAT_DIFF=`git clang-format -q --diff`
27 | if [ "$CLANG_FORMAT_DIFF" = "no modified files to format" ]; then
28 |     exit 0
29 | fi
30 | if test -n "$CLANG_FORMAT_DIFF"; then
31 |     echo "clang-format output:"
32 |     echo "$CLANG_FORMAT_DIFF"
33 |     echo "clang-format suggests changes in the format. You can run:"
34 |     echo "  git clang-format HEAD~1"
35 |     echo "and amend the commit with those changes that you agree with."
36 |     exit 0
37 | fi
38 | 


--------------------------------------------------------------------------------
/bin/git-pasteapply:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | # Copyright (C) 2015 The Qt Company Ltd.
 3 | # Contact: http://www.qt.io/licensing/
 4 | #
 5 | # You may use this file under the terms of the 3-clause BSD license.
 6 | # See the file LICENSE from this package for details.
 7 | #
 8 | 
 9 | use strict;
10 | use WWW::Mechanize;
11 | use Config;
12 | 
13 | unless (scalar @ARGV) {
14 |     print "Usage: git pasteapply [options] <number> [<number>...]\n" .
15 |         "Fetches the paste from pastebin.ca numbered <number> and applies\n" .
16 |         "Options are passed directly to git am\n" .
17 |         "\n" .
18 |         "Useful options:\n" .
19 |         " -s, --signoff         Add Signed-off-by: line to the commit message\n" .
20 |         " -3, --3way            When the patch does not apply cleanly, fall back on 3-way merge\n" .
21 |         " -p<n>                 Strip <n> elements of the paths (default 1)\n" .
22 |         " --whitespace=<nowarn,warn,fix,error,error-all>\n";
23 |     exit 0;
24 | }
25 | my @pastes;
26 | my @args;
27 | 
28 | for (@ARGV) {
29 |     if (m/^-/) {
30 |         push @args, $_;
31 |     } else {
32 |         push @pastes, $_;
33 |     }
34 | }
35 | 
36 | open GIT_AM, "|-", "git", "am", @args, "-"
37 |     or die "Cannot start git-am: $!";
38 | 
39 | my $www = WWW::Mechanize->new();
40 | foreach my $paste (@pastes) {
41 |     my $url = pastebin_url($paste);
42 |     print "Applying $url\n";
43 |     $www->get($url);
44 |     my $content = $www->content();
45 |     $content =~ s/\r\n/\n/g;
46 |     print GIT_AM $content;
47 | }
48 | 
49 | close GIT_AM;
50 | exit $?;
51 | 
52 | sub pastebin_url($) {
53 |     my $arg = $_[0];
54 |     return "http://pastebin.ca/raw/$3"
55 |         if ($arg =~ m,^(https?://)?(.*\.)?pastebin\.ca/([0-9]+),);
56 |     return "http://pastebin.com/download.php?i=$3"
57 |         if ($arg =~ m,^(https?://)?(.*\.)?pastebin.com/([a-zA-Z0-9]+)$,);
58 | 
59 |     return $arg if ($arg =~ m,^http://,); # Assume it's plain text...
60 | 
61 |     # No http:// prefix
62 |     return "http://pastebin.ca/raw/$arg" if ($ENV{PASTEBIN} =~ /pastebin\.ca/);
63 |     return "http://pastebin.com/download.php?i=$arg"; # Fallback, assume pastebin.com
64 | }
65 | 


--------------------------------------------------------------------------------
/git-hooks/qt-codereview-mirror:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | # Copyright (C) 2015 The Qt Company Ltd.
 3 | # Contact: http://www.qt.io/licensing/
 4 | #
 5 | # You may use this file under the terms of the 3-clause BSD license.
 6 | # See the file LICENSE from this package for details.
 7 | #
 8 | 
 9 | set -e # exit on any error
10 | 
11 | # FIXME: use git config for that
12 | MIRROR_ROOT=/data/repos
13 | GIT_BIN=/usr/bin/git
14 | UPDATE_LOCK=$HOME/.update_codereview_lock
15 | 
16 | # don't retry; pronounce 1h+ old locks as dead
17 | lockfile -r 0 -l 3600 $UPDATE_LOCK
18 | trap 'rm -f $UPDATE_LOCK' EXIT
19 | 
20 | cd $MIRROR_ROOT
21 | 
22 | # first mark all mirrors as deletable
23 | for i in `find -type d -name '*.git' -prune | cut -c3-`; do
24 |     touch $i/delete-me
25 | done
26 | 
27 | # then get a current list of projects
28 | rawproj=`ssh -p 29418 codereview.qt-project.org gerrit ls-projects`
29 | allproj=`echo "$rawproj" | grep -v '^\{graveyard\}/'`
30 | # this test ensures that the list is complete, identified by the trailing graveyard projects
31 | if test x"$allproj" = x"$rawproj"; then
32 |     echo "List of projects from gerrit is incomplete." >&2
33 |     exit 1
34 | fi
35 | 
36 | # then create the respective mirrors
37 | for i in `echo "$allproj" | grep -v '^All-'`; do (
38 |     mkdir -p $i.git
39 |     cd $i.git
40 |     rm -f delete-me
41 |     test -f config || $GIT_BIN init --bare
42 |     $GIT_BIN config remote.origin.fetch '+refs/heads/*:refs/heads/*' heads
43 |     $GIT_BIN config remote.origin.fetch '+refs/staging/*:refs/staging/*' staging
44 |     $GIT_BIN config remote.origin.url "ssh://codereview.qt-project.org:29418/$i.git"
45 | ); done
46 | 
47 | # then update all active mirrors and purge the orphaned ones
48 | for i in `find -type d -name '*.git' -prune | cut -c3-`; do (
49 |     if test -f $i/delete-me; then
50 |         rm -rf $i
51 |     else
52 |         cd $i
53 |         if ! test -s HEAD; then
54 |             echo "Note: HEAD of $i is bogus." >&2
55 |             echo "ref: refs/heads/master" > HEAD
56 |         fi
57 |         $GIT_BIN remote show origin | sed -n 's,^  HEAD branch: ,ref: refs/heads/,p' > new-HEAD
58 |         test -s new-HEAD && mv new-HEAD HEAD || echo "Cannot obtain HEAD for $i" >&2
59 |         $GIT_BIN fetch -p -q -u origin
60 | #        $GIT_BIN gc
61 |         chown -R --reference $MIRROR_ROOT .
62 |     fi
63 | ); done
64 | 


--------------------------------------------------------------------------------
/bin/git-edit-commit:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | # Copyright (C) 2015 The Qt Company Ltd.
 3 | # Contact: http://www.qt.io/licensing/
 4 | #
 5 | # You may use this file under the terms of the 3-clause BSD license.
 6 | # See the file LICENSE from this package for details.
 7 | #
 8 | 
 9 | if test "x$EDITOR" = "x$0" ; then
10 |     # The script was launched as an $EDITOR from git rebase -i.
11 |     # Modify the pick line to an edit line and just exit.
12 |     sed -e '1,$s/^pick '"$SHORT_SHA1 /edit $SHORT_SHA1 /" < "$1" >/tmp/editcommit$$
13 |     mv /tmp/editcommit$$ "$1"
14 |     exit 0
15 | fi
16 | 
17 | # Extract the SHA-1 from the command-line and validate it.
18 | MODE=message
19 | if test "x$1" = "x--source" ; then
20 |     MODE=source
21 |     shift
22 | fi
23 | if test -z "$1" ; then
24 |     echo "Usage: $0 [--source] sha-1"
25 |     echo ""
26 |     echo "git-edit-commit allows you to edit a git commit to change"
27 |     echo "the commit message, even if it is several hundred changes back."
28 |     echo "It is equivalent to 'git rebase -i', but slightly safer."
29 |     echo ""
30 |     echo "The --source option specifies that you want to edit the source"
31 |     echo "as well as the commit message.  This starts a 'git rebase -i'"
32 |     echo "which you will then have to perform manually."
33 |     exit 1
34 | fi
35 | SHA1="$1"
36 | if ! git merge-base "$SHA1" HEAD >/dev/null 2>/dev/null ; then
37 |     echo "$SHA1 does not appear to be in the current branch"
38 |     exit 1
39 | fi
40 | 
41 | # Get the current branch.
42 | CURRENTBRANCH=`git branch | grep '^\*' | awk '{print $2}' -`
43 | if test "$CURRENTBRANCH" = "(no" ; then
44 |     echo "Not on a valid branch - please check out the correct branch"
45 |     exit 1
46 | fi
47 | 
48 | if test -n "`git diff HEAD`" ; then
49 |     echo "You have uncommited changes. Please commit or stash them first." >&2
50 |     exit 1
51 | fi
52 | 
53 | # Replace aliases like HEAD and HEAD^ with the actual SHA-1.
54 | SHA1=`git rev-parse "$SHA1"`
55 | SHORT_SHA1=`git rev-parse --short "$SHA1"`
56 | 
57 | # Check that the change hasn't already been pushed.
58 | COMMON=`git merge-base "$SHA1" "origin/$CURRENTBRANCH" 2>/dev/null`
59 | if test "$COMMON" = "$SHA1" ; then
60 |     echo "$SHA1 has already been pushed - cannot edit it"
61 |     exit 1
62 | fi
63 | 
64 | EDITOR="$0"
65 | export EDITOR
66 | export SHORT_SHA1
67 | if ! git rebase --preserve-merges -i "${SHA1}^" ; then
68 |     exit 1
69 | fi
70 | unset EDITOR
71 | 
72 | # If doing a source rebase, then just start it up at the right point.
73 | if test "$MODE" = "source" ; then
74 |     echo "To make the source for your chosen commit editable, run:"
75 |     echo ""
76 |     echo "        git reset HEAD^"
77 |     echo ""
78 |     exit 0
79 | fi
80 | 
81 | git commit --amend
82 | 
83 | git rebase --continue
84 | 
85 | exit 0
86 | 


--------------------------------------------------------------------------------
/bin/git-gpull:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | # Copyright (C) 2018 The Qt Company Ltd.
 3 | # Copyright (C) 2019 Oswald Buddenhagen
 4 | # Contact: http://www.qt.io/licensing/
 5 | #
 6 | # You may use this file under the terms of the 3-clause BSD license.
 7 | # See the file LICENSE from this package for details.
 8 | #
 9 | 
10 | use v5.14;
11 | use strict;
12 | use warnings;
13 | no warnings qw(io);
14 | 
15 | our ($script, $script_path);
16 | BEGIN {
17 |     use Cwd qw(abs_path);
18 |     if ($^O eq "msys") {
19 |         $0 =~ s,\\,/,g;
20 |         $0 =~ s,^(.):/,/$1/,g;
21 |     }
22 |     $script_path = $script = abs_path($0);
23 |     $script_path =~ s,/[^/]+$,,;
24 |     unshift @INC, $script_path;
25 | }
26 | use git_gpush;
27 | 
28 | sub usage()
29 | {
30 |     print << "EOM";
31 | Usage:
32 |     git gpull [-- <git-pull options>]
33 | 
34 |     This command should be used instead of 'git pull --rebase'
35 |     when git-gpush is being used.
36 | 
37 |     In addition to updating the local branch with upstream, it
38 |     will also call git-ggc at regular intervals (default 30 days,
39 |     configurable with gpush.gcInterval).
40 | 
41 | Copyright:
42 |     Copyright (C) 2018 The Qt Company Ltd.
43 |     Copyright (C) 2019 Oswald Buddenhagen
44 |     Contact: http://www.qt.io/licensing/
45 | 
46 | License:
47 |     You may use this file under the terms of the 3-clause BSD license.
48 | EOM
49 | }
50 | 
51 | while (@ARGV) {
52 |     my $arg = $ARGV[0];
53 |     if ($arg eq "--debug") {
54 |         $debug = 1;
55 |         shift @ARGV;
56 |     } elsif ($arg eq "-n" || $arg eq "--dry-run") {
57 |         $dry_run = 1;
58 |         shift @ARGV;
59 |     } elsif ($arg eq "-?" || $arg eq "--?" || $arg eq "-h" || $arg eq "--help") {
60 |         usage();
61 |         exit;
62 |     } elsif ($arg eq "--") {
63 |         shift @ARGV;
64 |         last;
65 |     } else {
66 |         fail("Unrecognized command line argument '$arg'.\n");
67 |     }
68 | }
69 | 
70 | goto_gitdir();
71 | load_config();
72 | my $gc_interval = git_config('gpush.gcinterval', 30);
73 | if ($gc_interval != 0) {
74 |     load_state_file();  # No load_state(), and thus no load_refs().
75 |     my $next_gc = $last_gc + $gc_interval * 24 * 60 * 60;
76 |     if ($next_gc < time()) {
77 |         # It's seems backwards that we do this *before* pulling (which
78 |         # is likely to release more garbage), but chaining to the pull
79 |         # would be unreliable (the post-rewrite hook is not invoked when
80 |         # no local commits remain, and relying on the user to remember
81 |         # to use gpull instead of rebase with --continue is suboptimal).
82 |         # In the big picture the delay doesn't matter, as the gc interval
83 |         # is likely much bigger than the pull frequency anyway.
84 |         run_process(FWD_OUTPUT | DRY_RUN, $script_path."/git-ggc");
85 |     } else {
86 |         printf("Next gc date %d not reached yet (now is %d).\n", $next_gc, time())
87 |             if ($debug);
88 |     }
89 | } else {
90 |     print "gpull auto-gc is disabled.\n" if ($debug);
91 | }
92 | 
93 | exec("git", "pull", "--rebase", @ARGV) or fail("Cannot exec git: $!\n");
94 | 


--------------------------------------------------------------------------------
/git-hooks/gerrit-bot-extras:
--------------------------------------------------------------------------------
  1 | #! /usr/bin/perl
  2 | 
  3 | # Copyright (C) 2017 The Qt Company Ltd.
  4 | # Contact: http://www.qt.io/licensing/
  5 | #
  6 | # You may use this file under the terms of the 3-clause BSD license.
  7 | # See the file LICENSE from this package for details.
  8 | #
  9 | 
 10 | use strict;
 11 | use warnings;
 12 | use JSON;
 13 | 
 14 | # Usage: $0 <project> <SHA1> [instance]
 15 | # - default instance is 'sanitybot'
 16 | # - configure git: git config --global <instance>.<option> <value>
 17 | # Valid options are:
 18 | #   watches (optional)
 19 | #     Space-separated list of path watches. Each watch requires an own
 20 | #     section named watches.<name> with the following keys (note that
 21 | #     these sections are NOT namespaced with the instance):
 22 | #       projects (default ".*")
 23 | #         Regular expression specifying the projects to watch.
 24 | #       files
 25 | #         Regular expression specifying the filepaths to watch.
 26 | #       message (optional)
 27 | #         The message to post when this watch triggers.
 28 | #       invite (optional)
 29 | #         Space-separated list of reviewers to add when this watch triggers.
 30 | 
 31 | die "usage: $0 <project> <SHA1> [instance]\n" if ($#ARGV < 1);
 32 | my $project = shift @ARGV;
 33 | my $rev = shift @ARGV;
 34 | 
 35 | my $instance = 'sanitybot';
 36 | $instance = $ARGV[0] if ($#ARGV > -1);
 37 | 
 38 | # Doing this is less expensive than calling git repeatedly.
 39 | my %config = ();
 40 | for (`git config -l`) {
 41 |     /^([^=]+)=(.*$)/;
 42 |     $config{$1} = $2;
 43 | }
 44 | 
 45 | sub getcfg($;$)
 46 | {
 47 |     my ($key, $def) = @_;
 48 |     my $fkey = $instance.'.'.$key;
 49 |     if (defined $config{$fkey}) {
 50 |         return $config{$fkey};
 51 |     } elsif (@_ > 1) {
 52 |         return $def;
 53 |     } else {
 54 |         die $fkey." not set.\n";
 55 |     }
 56 | }
 57 | 
 58 | my @messages = ();
 59 | my %verdict = ();
 60 | my @invite = ();
 61 | 
 62 | my (@watches, %watch_files, %watch_messages, %watch_invites);
 63 | for my $w (split(/\s+/, getcfg('watches', ""))) {
 64 |     my $p = $config{'watches.'.$w.'.projects'};
 65 |     next if (defined($p) && $project !~ qr/^$p$/);
 66 |     my $f = $config{'watches.'.$w.'.files'};
 67 |     die "watches.$w.files not set.\n" if (!defined($f));
 68 |     $watch_files{$w} = qr/^$f$/m;
 69 |     $watch_messages{$w} = $config{'watches.'.$w.'.message'};
 70 |     my $i = $config{'watches.'.$w.'.invite'};
 71 |     $watch_invites{$w} = defined($i) ? [ split(/\s+/, $i) ] : [];
 72 |     push @watches, $w;
 73 | }
 74 | 
 75 | my ($subject, $files);
 76 | {
 77 |     local $/;
 78 |     my $output = `git show --pretty=\%s\%x00 --name-only --ignore-submodules -C $rev`;
 79 |     ($subject, $files) = split(/\x00/, $output);
 80 | }
 81 | 
 82 | for my $w (@watches) {
 83 |     if ($files =~ /$watch_files{$w}/) {
 84 |         push @messages, $watch_messages{$w} if (defined($watch_messages{$w}));
 85 |         push @invite, @{$watch_invites{$w}};
 86 |         last;
 87 |     }
 88 | }
 89 | 
 90 | my $cr = 0;
 91 | if ($subject =~ /^[<[]?[Ww]ip\b|\bWIP\b|\*{3}|^(.)\1*$/) {
 92 |     unshift @messages, "Apparently pushing a Work In Progress";
 93 |     $cr = -2;
 94 | } elsif ($subject =~ /^(?:squash|fixup)! /) {
 95 |     unshift @messages, "Commit was meant to be squashed";
 96 |     $cr = -2;
 97 | }
 98 | $verdict{labels}{'Code-Review'} = $cr;
 99 | 
100 | $verdict{message} = join("\n\n", @messages) if (@messages);
101 | $verdict{invite} = \@invite if (@invite);
102 | 
103 | print encode_json(\%verdict)."\n";
104 | 


--------------------------------------------------------------------------------
/git-hooks/gerrit_commit_msg_hook:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | # From Gerrit Code Review 3.10.0
  3 | #
  4 | # Part of Gerrit Code Review (https://www.gerritcodereview.com/)
  5 | #
  6 | # Copyright (C) 2009 The Android Open Source Project
  7 | #
  8 | # Licensed under the Apache License, Version 2.0 (the "License");
  9 | # you may not use this file except in compliance with the License.
 10 | # You may obtain a copy of the License at
 11 | #
 12 | # http://www.apache.org/licenses/LICENSE-2.0
 13 | #
 14 | # Unless required by applicable law or agreed to in writing, software
 15 | # distributed under the License is distributed on an "AS IS" BASIS,
 16 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 17 | # See the License for the specific language governing permissions and
 18 | # limitations under the License.
 19 | 
 20 | set -u
 21 | 
 22 | # avoid [[ which is not POSIX sh.
 23 | if test "$#" != 1 ; then
 24 |   echo "$0 requires an argument."
 25 |   exit 1
 26 | fi
 27 | 
 28 | if test ! -f "$1" ; then
 29 |   echo "file does not exist: $1"
 30 |   exit 1
 31 | fi
 32 | 
 33 | # Do not create a change id if requested
 34 | case "$(git config --get gerrit.createChangeId)" in
 35 |   false)
 36 |     exit 0
 37 |     ;;
 38 |   always)
 39 |     ;;
 40 |   *)
 41 |     # Do not create a change id for squash/fixup commits.
 42 |     if head -n1 "$1" | LC_ALL=C grep -q '^[a-z][a-z]*! '; then
 43 |       exit 0
 44 |     fi
 45 |     ;;
 46 | esac
 47 | 
 48 | 
 49 | if git rev-parse --verify HEAD >/dev/null 2>&1; then
 50 |   refhash="$(git rev-parse HEAD)"
 51 | else
 52 |   refhash="$(git hash-object -t tree /dev/null)"
 53 | fi
 54 | 
 55 | random=$({ git var GIT_COMMITTER_IDENT ; echo "$refhash" ; cat "$1"; } | git hash-object --stdin)
 56 | dest="$1.tmp.${random}"
 57 | 
 58 | trap 'rm -f "$dest" "$dest-2"' EXIT
 59 | 
 60 | if ! cat "$1" | sed -e '/>8/q' | git stripspace --strip-comments > "${dest}" ; then
 61 |    echo "cannot strip comments from $1"
 62 |    exit 1
 63 | fi
 64 | 
 65 | if test ! -s "${dest}" ; then
 66 |   echo "file is empty: $1"
 67 |   exit 1
 68 | fi
 69 | 
 70 | reviewurl="$(git config --get gerrit.reviewUrl)"
 71 | if test -n "${reviewurl}" ; then
 72 |   token="Link"
 73 |   value="${reviewurl%/}/id/I$random"
 74 |   pattern=".*/id/I[0-9a-f]\{40\}"
 75 | else
 76 |   token="Change-Id"
 77 |   value="I$random"
 78 |   pattern=".*"
 79 | fi
 80 | 
 81 | if git interpret-trailers --parse < "$1" | grep -q "^$token: $pattern$" ; then
 82 |   exit 0
 83 | fi
 84 | 
 85 | # There must be a Signed-off-by trailer for the code below to work. Insert a
 86 | # sentinel at the end to make sure there is one.
 87 | # Avoid the --in-place option which only appeared in Git 2.8
 88 | if ! git interpret-trailers \
 89 |          --trailer "Signed-off-by: SENTINEL" < "$1" > "$dest-2" ; then
 90 |   echo "cannot insert Signed-off-by sentinel line in $1"
 91 |   exit 1
 92 | fi
 93 | 
 94 | # Make sure the trailer appears before any Signed-off-by trailers by inserting
 95 | # it as if it was a Signed-off-by trailer and then use sed to remove the
 96 | # Signed-off-by prefix and the Signed-off-by sentinel line.
 97 | # Avoid the --in-place option which only appeared in Git 2.8
 98 | # Avoid the --where option which only appeared in Git 2.15
 99 | if ! git -c trailer.where=before interpret-trailers \
100 |          --trailer "Signed-off-by: $token: $value" < "$dest-2" |
101 |      sed -e "s/^Signed-off-by: \($token: \)/\1/" \
102 |          -e "/^Signed-off-by: SENTINEL/d" > "$dest" ; then
103 |   echo "cannot insert $token line in $1"
104 |   exit 1
105 | fi
106 | 
107 | if ! mv "${dest}" "$1" ; then
108 |   echo "cannot mv ${dest} to $1"
109 |   exit 1
110 | fi
111 | 


--------------------------------------------------------------------------------
/bin/git-rewrite-author:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | # Copyright (C) 2015 The Qt Company Ltd.
  3 | # Contact: http://www.qt.io/licensing/
  4 | #
  5 | # You may use this file under the terms of the 3-clause BSD license.
  6 | # See the file LICENSE from this package for details.
  7 | #
  8 | 
  9 | use strict;
 10 | use warnings;
 11 | 
 12 | use Getopt::Long;
 13 | 
 14 | sub usage {
 15 |     print STDERR
 16 | q{Usage: git rewrite-author --from <from> --to <to> [ -f | --force ]
 17 |     [--] [<rev-list options>...]
 18 | 
 19 |   Replace author and committer field in some commits.
 20 | 
 21 | 
 22 | EXAMPLE:
 23 | 
 24 |   You've accidentally made some commits like this:
 25 | 
 26 |     Author: bjones <bjones@localhost.localdomain>
 27 | 
 28 |   ... where it should have been:
 29 | 
 30 |     Author: Bob Jones <bob.jones@example.com>
 31 | 
 32 |   The first bad commit is a1b2c3d4...
 33 | 
 34 |   Fix it up by:
 35 | 
 36 |    $ git rewrite-author --from "bjones <bjones@localhost.localdomain>" \
 37 |       --to "Bob Jones <bob.jones@example.com>" a1b2c3d4^..HEAD
 38 | 
 39 |   If you omit a range of commits, this command will scan _all_ commits
 40 |   leading up to HEAD, which will take a long time for repositories with
 41 |   a large history.
 42 | 
 43 |   WARNING: this script will change the SHA1 of every commit including
 44 |   and following the first rewritten commit. You can't do this for commits
 45 |   you've already pushed unless you really know what you're doing!
 46 | };
 47 | }
 48 | 
 49 | sub parse_author
 50 | {
 51 |     my $author = shift;
 52 |     if ($author =~ /^(.*?) <([^>]+)>$/) {
 53 |         return ($1, $2);
 54 |     }
 55 |     else {
 56 |         die "Could not parse `$author'; expected something like \"Some Name <some.address\@example.com>\"";
 57 |     }
 58 | }
 59 | 
 60 | 
 61 | # Return a string single-quoted for use in shell
 62 | sub sh_squote
 63 | {
 64 |     my $out = shift;
 65 |     $out =~ s/'/'"'"'/g;
 66 |     return "'$out'";
 67 | }
 68 | 
 69 | # Return fragment of shell code to rewrite a specific env var
 70 | sub rewrite_env
 71 | {
 72 |     my %opts = @_;
 73 |     my $env = $opts{env};
 74 |     my $from = sh_squote($opts{from});
 75 |     my $to = sh_squote($opts{to});
 76 | 
 77 |     my $cmd = <<EOF
 78 | if [ "\$$env" = $from ]; then
 79 |     $env=$to;
 80 |     export $env;
 81 |     if [ \$REWROTE = 0 ]; then
 82 |         echo;
 83 |         echo Hit for \$GIT_COMMIT:;
 84 |         REWROTE=1;
 85 |     fi;
 86 |     echo "   $env:" $from '->' $to;
 87 | fi
 88 | EOF
 89 |     ;
 90 | 
 91 |     $cmd =~ s/\n */ /sg;
 92 | 
 93 |     return $cmd;
 94 | }
 95 | 
 96 | my $from;
 97 | my $to;
 98 | my $force;
 99 | if (!GetOptions(
100 |     "from=s"        => \$from,
101 |     "to=s"          => \$to,
102 |     "f|force"       => \$force,
103 | )) {
104 |     usage;
105 |     exit 2;
106 | }
107 | 
108 | if (!$from || !$to) {
109 |     print STDERR "Need `--from' and `--to' arguments\n";
110 |     usage;
111 |     exit 2;
112 | }
113 | 
114 | my ($from_name, $from_address) = parse_author($from);
115 | my ($to_name, $to_address)     = parse_author($to);
116 | 
117 | my $env_filter_command = "REWROTE=0; ".
118 |     rewrite_env(
119 |         env     =>  'GIT_AUTHOR_NAME',
120 |         from    =>  $from_name,
121 |         to      =>  $to_name,
122 |     )
123 |     . "; " .
124 |     rewrite_env(
125 |         env     =>  'GIT_COMMITTER_NAME',
126 |         from    =>  $from_name,
127 |         to      =>  $to_name,
128 |     )
129 |     . "; " .
130 |     rewrite_env(
131 |         env     =>  'GIT_AUTHOR_EMAIL',
132 |         from    =>  $from_address,
133 |         to      =>  $to_address,
134 |     )
135 |     . "; " .
136 |     rewrite_env(
137 |         env     =>  'GIT_COMMITTER_EMAIL',
138 |         from    =>  $from_address,
139 |         to      =>  $to_address,
140 |     )
141 | ;
142 | 
143 | my @git_filter_branch = ("git", "filter-branch", "--env-filter", $env_filter_command);
144 | if ($force) {
145 |     push @git_filter_branch, "--force";
146 | }
147 | push @git_filter_branch, @ARGV;
148 | 
149 | exec @git_filter_branch;
150 | 
151 | 


--------------------------------------------------------------------------------
/bin/git-note-review:
--------------------------------------------------------------------------------
  1 | #! /bin/sh
  2 | # Copyright (C) 2015 The Qt Company Ltd.
  3 | # Contact: http://www.qt.io/licensing/
  4 | #
  5 | # You may use this file under the terms of the 3-clause BSD license.
  6 | # See the file LICENSE from this package for details.
  7 | #
  8 | 
  9 | force=false
 10 | remove=false
 11 | while test $# != 0; do
 12 |     case $1 in
 13 |         -f) force=true;;
 14 |         -r) remove=true;;
 15 |         -*) echo "Unrecognized option $1." >&2; exit 1;;
 16 |         *) break;;
 17 |     esac
 18 |     shift
 19 | done
 20 | 
 21 | if test -z "$2"; then
 22 |     cat >&2 <<EOF
 23 | Usage: $0 [-f] [-r] <user> <sha-1>...
 24 | 
 25 | git-note-review adds Reviewed-by: lines to the log messages of the
 26 | named commits. Commits can be specified as either as a single sha1 or
 27 | as a sha1_excl..sha1_incl range (see git rev-list).
 28 | If any <whatever>-by: tag with the specified <user> is found to be
 29 | already present in a given commit, the commit is skipped.
 30 | If -f is specified, the check whether the commits were already pushed
 31 | is omitted. This only makes sense if you are planning to make a forced
 32 | push.
 33 | If -r is specified, the named user's reviews are removed from the commits.
 34 | EOF
 35 |     exit 1
 36 | fi
 37 | 
 38 | GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
 39 | if [ -z "$GIT_DIR" ]; then
 40 |     echo >&2 "Not a git repository."
 41 |     exit 1
 42 | fi
 43 | cd "$GIT_DIR/.."
 44 | 
 45 | REF=$(git symbolic-ref HEAD 2>/dev/null)
 46 | if [ -z "$REF" ]; then
 47 |     echo >&2 "Not on a branch."
 48 |     exit 1
 49 | fi
 50 | 
 51 | if test -n "`git diff HEAD`" ; then
 52 |     echo "You have uncommited changes. Please commit or stash them first." >&2
 53 |     exit 1
 54 | fi
 55 | 
 56 | who=$1
 57 | shift
 58 | SHA1s=
 59 | firstSHA1=
 60 | fail=false
 61 | for j in "$@"; do
 62 |     if test -z "${j##*..*}"; then
 63 |         if ! jj=`git rev-list $j 2> /dev/null`; then
 64 |             echo "Cannot parse commit range $j." >&2
 65 |             fail=true
 66 |             continue
 67 |         fi
 68 |         j=$jj
 69 |     fi
 70 |     for ii in $j; do
 71 |         if ! i=`git rev-parse --short $ii 2> /dev/null`; then
 72 |             echo "Cannot parse commit id $ii." >&2
 73 |             fail=true
 74 |             continue
 75 |         fi
 76 |         if test -n "`git rev-list -1 $i ^HEAD`"; then
 77 |             echo "Commit $i is not on current branch. Did you rebase it meanwhile?" >&2
 78 |             fail=true
 79 |             continue
 80 |         fi
 81 |         git log -1 --pretty=%b $i | egrep -q -i "^[-[:alpha:]]+-by: *$who\$" && hit=true || hit=false
 82 |         if $hit && ! $remove; then
 83 |             echo "Commit $i already noted as reviewed by $who."
 84 |         elif ! $hit && $remove; then
 85 |             echo "Commit $i not noted as reviewed by $who."
 86 |         else
 87 |             if test -z "$firstSHA1"; then
 88 |                 firstSHA1=`git rev-parse $i`
 89 |                 SHA1s=$i
 90 |             else
 91 |                 firstSHA1=`git merge-base $firstSHA1 $i`
 92 |                 SHA1s="$SHA1s|$i"
 93 |             fi
 94 |         fi
 95 |     done
 96 | done
 97 | if $fail; then
 98 |     echo "Exiting due to fatal errors." >&2
 99 |     exit 1
100 | fi
101 | if test -z "$SHA1s"; then
102 |     echo "No commits to change." >&2
103 |     exit 0
104 | fi
105 | 
106 | # This would be pretty much bullet-proof, but also a lot slower.
107 | #if test -z "$(git rev-list -1 $firstSHA1 --not $(git for-each-ref --format='%(objectname)' refs/remotes/))"; then
108 | #    echo "$firstSHA1 has already been pushed - cannot edit it." >&2
109 | #    exit 1
110 | #fi
111 | # This should be Good Enough (TM), and it is rather fast.
112 | if ! $force && test -n "$(git rev-list -1 $firstSHA1^..@{upstream})"; then
113 |     echo "Commit `git rev-parse --short $firstSHA1` has already been pushed - cannot edit it." >&2
114 |     exit 1
115 | fi
116 | 
117 | if ! $remove; then
118 |     script='s/^\\(Reviewed-by:\\) *\\(pending\\|tbd\\|TBD\\)\$/\\1 '"$who"'/;t nx
119 | \${
120 | /^[-[:alpha:]]\+:/!a\\
121 | 
122 | a\\
123 | Reviewed-by: '"$who"'
124 | }
125 | b
126 | :nx;n;b nx'
127 | else
128 |     script='/^[-[:alpha:]]\\+-by: *'"$who"'\$/d'
129 | fi
130 | 
131 | git filter-branch --force --original refs/note-review-backup --msg-filter '
132 |     if echo $GIT_COMMIT | egrep -q "^('"$SHA1s"')"; then
133 |         sed "'"$script"'"
134 |     else
135 |         cat
136 |     fi
137 | ' $firstSHA1^..$REF || exit 1
138 | rm -rf $GIT_DIR/refs/note-review-backup # we have the reflog, so what
139 | 


--------------------------------------------------------------------------------
/bin/git-pastebin:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | # Arguments are:
  3 | #  git pastebin [<commit>]
  4 | #
  5 | 
  6 | # Copyright (C) Thiago Macieira <thiago@kde.org>
  7 | # Additional fixes by Giuseppe D'Angelo <dangelog@gmail.com>
  8 | # This program is based on paste2pastebin.pl, that is
  9 | #   Copyright (C) Fred Blaise <chapeaurouge_at_madpenguin_dot_org>
 10 | #
 11 | # This program is free software; you can redistribute it and/or modify
 12 | # it under the terms of the GNU General Public License as published by
 13 | # the Free Software Foundation; either version 2 of the License, or
 14 | # (at your option) any later version.
 15 | #
 16 | # This program is distributed in the hope that it will be useful,
 17 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 | # GNU General Public License for more details.
 20 | #
 21 | # You should have received a copy of the GNU General Public License
 22 | # along with this program; if not, write to the Free Software
 23 | # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 24 | 
 25 | use strict;
 26 | use LWP::UserAgent;
 27 | use WWW::Mechanize;
 28 | 
 29 | my $description;
 30 | my $content;
 31 | my $squash = -1;
 32 | my @committish;
 33 | my @fpargs;
 34 | my @pathargs;
 35 | my $dashdash = 0;
 36 | 
 37 | while (scalar @ARGV) {
 38 |     my $arg = shift @ARGV;
 39 | 
 40 |     if ($arg eq "-d" || $arg eq "--description") {
 41 |         die "Option $arg requires an argument" unless scalar @ARGV;
 42 |         $description = shift @ARGV;
 43 |     } elsif ($arg eq "-s" || $arg eq "--squash") {
 44 |         $squash = 1;
 45 |     } elsif ($arg eq "--no-squash") {
 46 |         $squash = 0;
 47 |     } elsif ($arg eq "--") {
 48 |         $dashdash = 1;
 49 |     } elsif ($arg =~ m/^-/) {
 50 |         push @fpargs, $arg;
 51 |     } elsif ($dashdash) {
 52 |         push @pathargs, $arg;
 53 |     } else {
 54 |         push @committish, $arg;
 55 |     }
 56 | }
 57 | 
 58 | # Squash by default if description was given
 59 | $squash = $description if ($squash == -1);
 60 | 
 61 | # Default revision is HEAD
 62 | push @committish, "HEAD" unless (scalar @committish);
 63 | 
 64 | # Prepend -- if pathargs isn't empty
 65 | unshift @pathargs, "--" if (scalar @pathargs);
 66 | 
 67 | # Try to parse this commit
 68 | my @revlist;
 69 | my $needsrevlist = 0;
 70 | open REVPARSE, "-|", "git", "rev-parse", @committish;
 71 | while (<REVPARSE>) {
 72 |     chomp;
 73 |     push @revlist, $_;
 74 |     $needsrevlist = 1 if (m/^\^/);
 75 | }
 76 | close REVPARSE;
 77 | 
 78 | if ($needsrevlist) {
 79 |     # Get the revision list then
 80 |     open REVLIST, "-|", "git", "rev-list", "--reverse", @revlist
 81 |         or die "Cannot run git-rev-list: $!";
 82 |     @revlist = ();
 83 |     while (<REVLIST>) {
 84 |         chomp;
 85 |         push @revlist, $_;
 86 |     }
 87 |     close REVLIST;
 88 | }
 89 | 
 90 | # Are we squashing?
 91 | if (scalar @revlist > 1 && $squash) {
 92 |     # Yes, this one is easy
 93 |     open FORMATPATCH, "-|", "git", "format-patch", "--stdout", @fpargs, @committish, @pathargs
 94 |         or die "Cannot run git format-patch: $!";
 95 | 
 96 |     while (<FORMATPATCH>) {
 97 |         $content .= $_;
 98 |     }
 99 |     close FORMATPATCH;
100 | 
101 |     submit($description, $content);
102 |     exit(0);
103 | }
104 | 
105 | # No, we're not squashing
106 | # Iterate over the commits
107 | for my $rev (@revlist) {
108 |     $content = "";
109 |     $description = "";
110 | 
111 |     # Get description
112 |     open PRETTY, "-|", "git", "log", "--pretty=format:%s%n%b", "$rev^!"
113 |         or die "Cannot get description for $rev: $!";
114 |     while (<PRETTY>) {
115 |         $description .= $_;
116 |     }
117 |     close PRETTY;
118 | 
119 |     # Get patch
120 |     open FORMATPATCH, "-|", "git", "format-patch", "--stdout", @fpargs, "$rev^!", @pathargs
121 |         or die "Cannot get patch for $rev: $!";
122 |     while (<FORMATPATCH>) {
123 |         $content .= $_;
124 |     }
125 |     close FORMATPATCH;
126 | 
127 |     submit($description, $content);
128 | }
129 | 
130 | sub submit($$) {
131 |     if ($ENV{PASTEBIN} =~ /pastebin\.ca/) {
132 |         submit_pastebinca(@_);
133 |     } elsif ($ENV{PASTEBIN} =~ /pastebin.com/) {
134 |         submit_pastebincom(@_);
135 |     } elsif (!$ENV{PASTEBIN}) {
136 |         submit_default(@_);
137 |     } else {
138 |         die "Sorry, I don't know how to talk to $ENV{PASTEBIN}."
139 |     }
140 | }
141 | 
142 | sub submit_default($$) {
143 |     submit_pastebincom(@_);
144 | }
145 | 
146 | sub submit_pastebincom($$) {
147 |     my ($description, $content) = @_;
148 |     my $paste_subdomain;
149 |     $paste_subdomain = $2 if ($ENV{PASTEBIN} =~ m,(https?://)?(.*)\.pastebin\.com,);
150 | 
151 |     my %fields = (
152 |         paste_code      =>       $content,
153 |         paste_subdomain =>       $paste_subdomain,
154 |         paste_format    =>       'diff',
155 |         paste_name      =>       $ENV{PASTEBIN_NAME}
156 |     );
157 | 
158 |     my $agent = LWP::UserAgent->new();
159 |     my $api = 'http://pastebin.com/api_public.php';
160 | 
161 |     my $reply = $agent->post($api, \%fields);
162 | 
163 |     die "Could not send paste: $!" unless ($reply->is_success);
164 | 
165 |     my $reply_content = $reply->decoded_content;
166 | 
167 |     # actually, pastebin.com is so dumb that it returns
168 |     # HTTP 200 OK even in case of error; the content then contains an error message...
169 |     die "Could not send paste: $reply_content" if ($reply_content =~ /^ERROR/);
170 | 
171 |     print $reply_content, "\n";
172 | }
173 | 
174 | sub submit_pastebinca($$) {
175 |     my ($description, $content) = @_;
176 |     my %fields = (
177 |         content         =>      $content,
178 |         description     =>      $description,
179 |         type            =>      '34', # Unfortunately, "Diff/Patch" is missing in the quiet interface
180 |         expiry          =>      '1 month',
181 |         name            =>      '',
182 |     );
183 |     my $www = WWW::Mechanize->new();
184 | 
185 |     my $api_key       = "1OIIB1/PYzkNe/azsjOFkm4iBe0414V0";
186 |     my $pastebin_url  = "http://pastebin.ca/quiet-paste.php?api=$api_key";
187 |     my $pastebin_root = "http://pastebin.ca";
188 | 
189 |     $www->get($pastebin_url);
190 |     die "Cannot get the pastebin form: $!" unless ($www->success());
191 | 
192 |     $www->form_name('pasteform');
193 |     $www->set_fields(%fields);
194 |     $www->submit_form(button => 's');
195 | 
196 |     die "Could not send paste: $!" unless ($www->success());
197 | 
198 |     $content = $www->content();
199 |     if($content =~ m/^SUCCESS:(.*)/) {
200 |         print "$pastebin_root/$1\n";
201 |     } else {
202 |         print $content;
203 |     }
204 | }
205 | 


--------------------------------------------------------------------------------
/bin/git-qt-grafts:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl -w
  2 | ####################################################################################################
  3 | #
  4 | # git-qt-grafts
  5 | #
  6 | # Sets up the proper grafts for a Qt repository
  7 | #
  8 | # Copyright (C) 2015 The Qt Company Ltd.
  9 | # Contact: http://www.qt.io/licensing/
 10 | #
 11 | ####################################################################################################
 12 | 
 13 | use File::Basename;
 14 | use Cwd 'abs_path';
 15 | use strict;
 16 | 
 17 | my $history_location;
 18 | 
 19 | # Syntax:  fileContents(filename)
 20 | # Returns: String with contents of the file, or empty string if file
 21 | #          doens't exist.
 22 | sub fileContents {
 23 |     my ($filename) = @_;
 24 |     my $filecontents = "";
 25 |     if (-e $filename) {
 26 |         my $FD;
 27 |         open($FD, "< $filename") || die "Could not open $filename for reading, read block?";
 28 |         local $/;
 29 |         binmode $FD;
 30 |         $filecontents = <$FD>;
 31 |         close $FD;
 32 |     }
 33 |     return $filecontents;
 34 | }
 35 | 
 36 | sub fileContains {
 37 |     my ($filename, $text) = @_;
 38 |     # purposely not using perl grep here
 39 |     foreach my $line (split /\n/, fileContents("$filename")) {
 40 |         return 1 if ("$line" eq "$text");
 41 |     }
 42 |     return 0;
 43 | }
 44 | 
 45 | sub showUsage {
 46 |     my $prg = basename($0);
 47 |     print "Usage: $prg <path to Qt history>:\n";
 48 | }
 49 | 
 50 | while ( @ARGV ) {
 51 |     my $arg = shift @ARGV;
 52 |     if ($arg eq "-?" || $arg eq "-h" || $arg eq "-help" || $arg eq "?") {
 53 |         showUsage();
 54 |         exit 0;
 55 |     } elsif (!$history_location) {
 56 |         $history_location = $arg;
 57 |     } else {
 58 |         print "Unknown option: $arg\n\n";
 59 |         showUsage();
 60 |         exit 1;
 61 |     }
 62 | }
 63 | 
 64 | # Get current git-dir
 65 | my $git_dir = `git rev-parse --git-dir`;
 66 | chomp $git_dir;
 67 | if (!$git_dir) {
 68 |     print "Cannot find any Git dir!\n";
 69 |     exit 1;
 70 | }
 71 | 
 72 | # validate path for history repo
 73 | if (!$history_location || !-e $history_location) {
 74 |     print "You need to provide a path to the monolithic Qt repo!\n";
 75 |     exit 1;
 76 | }
 77 | my $history_git_dir = `cd $history_location && git rev-parse --git-dir`;
 78 | chomp $history_git_dir;
 79 | if (!$history_git_dir  || !-e "$history_location/$history_git_dir/objects") {
 80 |     print "Monolithic Qt repo path is not a valid Git repo!\n";
 81 |     exit 1;
 82 | }
 83 | $history_git_dir = abs_path("$history_location/$history_git_dir");
 84 | my $history_alternates_objects = "$history_git_dir/objects";
 85 | 
 86 | # check if we already point to this alternate object store
 87 | my $git_alternates_file = "$git_dir/objects/info/alternates";
 88 | my $found_alternate = fileContains($git_alternates_file, $history_alternates_objects);
 89 | 
 90 | # get first commit SHA1 of this repo which mentions branching from a commit
 91 | my $GIT_REVLIST;
 92 | my $git_pid = open($GIT_REVLIST, "git rev-list --reverse --grep='Branched from .*at commit' HEAD |")
 93 |     or die ("Failed to launch Git");
 94 | my @commits;
 95 | while (<$GIT_REVLIST>) {
 96 |     chomp;
 97 |     push(@commits, $_);
 98 | }
 99 | close($GIT_REVLIST);
100 | 
101 | my $found_any_grafts = 0;
102 | mkdir("$git_dir/info");
103 | my $graft_file = "$git_dir/info/grafts";
104 | my @graft_lines;
105 | 
106 | foreach my $commit (@commits) {
107 |     # find the graft point which the commit mentions
108 |     my $commit_msg = `git show -s --format=%b $commit`;
109 |     my $graft_to_commit = $commit_msg;
110 |     $graft_to_commit =~ s/^.+Branched from .+at commit\n([a-f0-9]+)\n.*/$1/s;
111 |     next if (!$graft_to_commit || $graft_to_commit eq $commit_msg);
112 | 
113 |     # Preserve any existing parents of the commit.
114 |     my @existing_parents;
115 |     my $GIT_CAT_FILE;
116 |     open($GIT_CAT_FILE, "git cat-file commit $commit |") or die ("Failed to launch Git");
117 |     while (<$GIT_CAT_FILE>) {
118 |         if (/^parent ([0-9a-z]{40})/i) {
119 |             push(@existing_parents, $1);
120 |         }
121 |     }
122 |     close($GIT_CAT_FILE);
123 | 
124 |     # check that we don't already have this graft already setup
125 |     my $graft_line = "$commit $graft_to_commit";
126 |     $graft_line .= " " . join(" ", @existing_parents) if (@existing_parents);
127 |     my $found_graft = fileContains($graft_file, $graft_line);
128 |     if ($found_graft) {
129 |         print "Graft for $commit already exists. Skipping...\n";
130 |         $found_any_grafts = 1;
131 |         next;
132 |     }
133 | 
134 |     # verify that alternate object store contains the commit we want to graft to
135 |     if (system("cd $history_location && git cat-file -e $graft_to_commit") != 0) {
136 |         print "History repo ($history_location) does not contain commit $graft_to_commit!\n";
137 |         print "Skipping this graft...\n";
138 |         next;
139 |     }
140 | 
141 |     print "Grafted $commit -> $graft_to_commit\n";
142 |     push(@graft_lines, $graft_line);
143 |     $found_any_grafts = 1;
144 | }
145 | if (!$found_any_grafts) {
146 |     print "This repo does not refer to a graft point, so no grafts added!\n";
147 |     exit 0;
148 | }
149 | 
150 | # if our alternates file didn't contain the "history repo" path already
151 | # add its path now
152 | if (!$found_alternate) {
153 |     my $ALTERNATES_FILE;
154 |     open($ALTERNATES_FILE, ">> $git_alternates_file") || die "Could not open $git_alternates_file for writing, wrong permissions?";
155 |     print $ALTERNATES_FILE "$history_alternates_objects\n";
156 |     # Add alternates from alternates file in the history repo, in case it has additional alternates.
157 |     my $HISTORY_ALTERNATES_FILE;
158 |     if (open($HISTORY_ALTERNATES_FILE, "< $history_git_dir/objects/info/alternates")) {
159 |         print("Reusing existing alternates in history repository\n");
160 |         while (<$HISTORY_ALTERNATES_FILE>) {
161 |             chomp;
162 |             print $ALTERNATES_FILE $_ if (!fileContains($git_alternates_file, $_));
163 |         }
164 |         close($HISTORY_ALTERNATES_FILE);
165 |     }
166 |     close($ALTERNATES_FILE);
167 | }
168 | 
169 | # Add graft lines from graft file in the history repo, in case it has additional grafts.
170 | my $HISTORY_GRAFT_FILE;
171 | if (open($HISTORY_GRAFT_FILE, "< $history_git_dir/info/grafts")) {
172 |     print("Reusing existing grafts in history repository\n");
173 |     while (<$HISTORY_GRAFT_FILE>) {
174 |         chomp;
175 |         push(@graft_lines, $_) if (!fileContains($graft_file, $_));
176 |     }
177 |     close($HISTORY_GRAFT_FILE);
178 | }
179 | 
180 | # add graft
181 | if (@graft_lines) {
182 |     my $GRAFT_FILE;
183 |     open($GRAFT_FILE, ">> $graft_file") || die "Could not open $graft_file for writing, wrong permissions?";
184 |     print $GRAFT_FILE join("\n", @graft_lines) . "\n";
185 |     close($GRAFT_FILE);
186 | }
187 | 


--------------------------------------------------------------------------------
/util/normalize/main.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2016 The Qt Company Ltd.
  2 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
  3 | 
  4 | #include <qcoreapplication.h>
  5 | #include <qdiriterator.h>
  6 | #include <qfile.h>
  7 | #include <qmetaobject.h>
  8 | #include <qstring.h>
  9 | #include <qtextstream.h>
 10 | #include <qcommandlineparser.h>
 11 | 
 12 | #include <qdebug.h>
 13 | 
 14 | #include <limits.h>
 15 | #include <stdio.h>
 16 | 
 17 | static bool printFilename = true;
 18 | static bool modify = false;
 19 | 
 20 | static QByteArray signature(const QByteArray &line, int pos)
 21 | {
 22 |     int start = pos;
 23 |     // find first open parentheses
 24 |     while (start < line.length() && line.at(start) != '(')
 25 |         ++start;
 26 |     int i = ++start;
 27 |     int par = 1;
 28 |     // find matching closing parentheses
 29 |     while (i < line.length() && par > 0) {
 30 |         if (line.at(i) == '(')
 31 |             ++par;
 32 |         else if (line.at(i) == ')')
 33 |             --par;
 34 |         ++i;
 35 |     }
 36 |     if (par == 0)
 37 |         return line.mid(start, i - start - 1);
 38 |     return QByteArray();
 39 | }
 40 | 
 41 | static bool isValidIdentifierChar(char c)
 42 | {
 43 |     return c == '_' || QChar::isLetterOrNumber(uchar(c));
 44 | }
 45 | 
 46 | static bool checkSignature(const QString &fileName, QByteArray &line, const char *sig)
 47 | {
 48 |     static QStringList fileList;
 49 | 
 50 |     const int siglen = strlen(sig);
 51 |     int idx = -1;
 52 |     bool found = false;
 53 |     while ((idx = line.indexOf(sig, ++idx)) != -1) {
 54 |         if (idx > 0 && isValidIdentifierChar(line.at(idx - 1)))
 55 |             continue;
 56 |         int endIdx = idx + siglen;
 57 |         if (endIdx < line.length() && isValidIdentifierChar(line.at(endIdx)))
 58 |             continue;
 59 |         const QByteArray sl = signature(line, idx);
 60 |         QByteArray nsl(QMetaObject::normalizedSignature(sl.constData()));
 61 |         if (sl != nsl) {
 62 |             found = true;
 63 |             if (printFilename && !fileList.contains(fileName)) {
 64 |                 fileList.prepend(fileName);
 65 |                 printf("%s\n", fileName.toLocal8Bit().constData());
 66 |             }
 67 |             if (modify)
 68 |                 line.replace(sl, nsl);
 69 |             //qDebug("expected '%s', got '%s'", nsl.data(), sl.data());
 70 |         }
 71 |     }
 72 |     return found;
 73 | }
 74 | 
 75 | void writeChanges(const QString &fileName, const QStringList &lines)
 76 | {
 77 |     QFile file(fileName);
 78 |     if (!file.open(QIODevice::WriteOnly)) {
 79 |         qDebug("unable to open file '%s' for writing (%s)", fileName.toLocal8Bit().constData(), file.errorString().toLocal8Bit().constData());
 80 |         return;
 81 |     }
 82 |     QTextStream stream(&file);
 83 |     for (int i = 0; i < lines.count(); ++i)
 84 |         stream << lines.at(i);
 85 |     file.close();
 86 | }
 87 | 
 88 | void check(const QString &fileName)
 89 | {
 90 |     QFile file(fileName);
 91 |     if (!file.open(QIODevice::ReadOnly)) {
 92 |         qDebug("unable to open file: '%s' (%s)", fileName.toLocal8Bit().constData(), file.errorString().toLocal8Bit().constData());
 93 |         return;
 94 |     }
 95 |     QStringList lines;
 96 |     bool found = false;
 97 |     while (true) {
 98 |         QByteArray line = file.readLine();
 99 |         if (line.isEmpty())
100 |             break;
101 |         found |= checkSignature(fileName, line, "SLOT");
102 |         found |= checkSignature(fileName, line, "SIGNAL");
103 |         if (modify)
104 |             lines << line;
105 |     }
106 |     file.close();
107 | 
108 |     if (found && modify) {
109 |         printf("Modifying file: '%s'\n", fileName.toLocal8Bit().constData());
110 |         writeChanges(fileName, lines);
111 |     }
112 | }
113 | 
114 | void traverse(const QString &path)
115 | {
116 |     auto needsChecking = [] (QStringView path) {
117 |         // list of file extensions that
118 |         constexpr char extensions[][5] = {
119 |             // C++ impl files:
120 |             "C", // will also match .c (because we're matching case-insensitively, but ¯\_(ツ)_/¯
121 |             "cpp",
122 |             "cxx",
123 |             "c++",
124 |             // header files:
125 |             "h",
126 |             "hpp",
127 |             "hxx",
128 |             // Obj-C++ impl:
129 |             "mm",
130 |             // Parser generators:
131 |             "g",
132 |             // documentation may also include SIGNAL/SLOT macros:
133 |             "qdoc",
134 |         };
135 | 
136 |         // treat .in files like the underlying file
137 |         if (path.endsWith(QLatin1StringView{".in"}, Qt::CaseInsensitive))
138 |             path = path.chopped(3);
139 | 
140 |         for (const char *extension : extensions) {
141 |             const QLatin1StringView ext{extension};
142 |             if (path.endsWith(ext, Qt::CaseInsensitive) &&
143 |                 path.chopped(ext.size()).endsWith(u'.'))
144 |             {
145 |                 return true;
146 |             }
147 |         }
148 |         return false;
149 |     };
150 | 
151 |     QDirIterator dirIterator(path, QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::NoSymLinks);
152 | 
153 |     while (dirIterator.hasNext()) {
154 |         QString filePath = dirIterator.next();
155 |         if (needsChecking(filePath))
156 |             check(filePath);
157 |         else if (QFileInfo(filePath).isDir())
158 |             traverse(filePath); // recurse
159 |     }
160 | }
161 | 
162 | int main(int argc, char *argv[])
163 | {
164 |     QCoreApplication app(argc, argv);
165 | 
166 |     QCommandLineParser parser;
167 |     parser.setApplicationDescription(
168 |             QStringLiteral("Qt Normalize tool (Qt %1)\nOutputs all filenames that contain non-normalized SIGNALs and SLOTs")
169 |             .arg(QString::fromLatin1(QT_VERSION_STR)));
170 |     parser.addHelpOption();
171 |     parser.addVersionOption();
172 | 
173 |     QCommandLineOption modifyOption(QStringLiteral("modify"),
174 |                                     QStringLiteral("Fix all occurrences of non-normalized SIGNALs and SLOTs."));
175 |     parser.addOption(modifyOption);
176 | 
177 |     parser.addPositionalArgument(QStringLiteral("path"),
178 |                                  QStringLiteral("can be a single file or a directory (in which case, look for file types that may contain SIGNALs and SLOTs recursively)"));
179 | 
180 |     parser.process(app);
181 | 
182 |     if (parser.positionalArguments().count() != 1)
183 |         parser.showHelp(1);
184 |     QString path = parser.positionalArguments().first();
185 |     if (path == "-")
186 |         parser.showHelp(1);
187 | 
188 |     if (parser.isSet(modifyOption)) {
189 |         printFilename = false;
190 |         modify = true;
191 |     }
192 | 
193 |     QFileInfo fi(path);
194 |     if (fi.isFile()) {
195 |         check(path);
196 |     } else if (fi.isDir()) {
197 |         if (!path.endsWith("/"))
198 |             path.append("/");
199 |         traverse(path);
200 |     } else {
201 |         qWarning("Don't know what to do with '%s'", path.toLocal8Bit().constData());
202 |         return 1;
203 |     }
204 | 
205 |     return 0;
206 | }
207 | 


--------------------------------------------------------------------------------
/bin/git-split-ws:
--------------------------------------------------------------------------------
  1 | #! /usr/bin/perl
  2 | # Copyright (C) 2015 The Qt Company Ltd.
  3 | # Contact: http://www.qt.io/licensing/
  4 | #
  5 | # You may use this file under the terms of the 3-clause BSD license.
  6 | # See the file LICENSE from this package for details.
  7 | #
  8 | 
  9 | use warnings;
 10 | use strict;
 11 | 
 12 | my $invocationCommand = '';
 13 | if ($#ARGV >= 0) {
 14 |     $invocationCommand = $ARGV[0];
 15 | }
 16 | 
 17 | if ($invocationCommand ne 'commit' and $invocationCommand ne 'stash' and $invocationCommand ne '') {
 18 |     print STDERR <<EOF ;
 19 | Usage: $0 [commit | stash]
 20 | Removes white space only change chunks from the HEAD commit.
 21 | If invoked with commit, WS changes are committed as a separate commit on top.
 22 | If invoked with stash, WS changes are stashed.
 23 | Otherwise it will merely reapply the WS changes to the working tree.
 24 | EOF
 25 |     exit 2;
 26 | }
 27 | 
 28 | sub printerr()
 29 | {
 30 |     die "cannot run git: ".$! if ($? < 0);
 31 |     die "git crashed with signal ".$? if ($? & 127);
 32 |     die "git exited with status ".($? >> 8) if ($?);
 33 | }
 34 | 
 35 | open STATUS, "git status --porcelain |" or printerr;
 36 | while (<STATUS>) {
 37 |     if (/^[^ ?!]/) {
 38 |         print STDERR "Index is not clean. Aborting.\n";
 39 |         exit 1;
 40 |     }
 41 | }
 42 | close STATUS or printerr;
 43 | 
 44 | my $patch = "";
 45 | 
 46 | my $file = "";
 47 | my @filehdr = ("", "");
 48 | my $fileHdrShown = 0;
 49 | 
 50 | my $chunk = 0;
 51 | my @addi = ();
 52 | my @deli = ();
 53 | my $nonws;
 54 | my $ws;
 55 | my $mixws_check = 0;
 56 | my $lineno = 0;
 57 | my $lineno2 = 0;
 58 | my @ws_files = ();
 59 | my %ws_lines = (); # hash of lists
 60 | my $braces = 0;
 61 | my $open_key = qr/\s*#\s*if|.*{/;
 62 | my $close_key = qr/\s*#\s*endif|.*}/;
 63 | my $kill_all_ws = qr/\s+((?:\"(?:\\.|[^\"])*\"|\S)+)/; # Collapse all whitespace not inside strings.
 64 | my $kill_nl_ws = qr/((?:\"(?:\\.|[^\"])*\"|\S)+)\s+/; # Collapse all non-leading whitespace not inside strings.
 65 | 
 66 | sub flushChunk()
 67 | {
 68 |     my $loc_nonws = 0;
 69 |     my $nlonly = 1;
 70 |     my ($ai, $di) = (0, 0);
 71 |     while (!$loc_nonws) {
 72 |         my ($a, $d) = ("", "");
 73 |         while ($ai < @addi) {
 74 |             $a = $addi[$ai++];
 75 |             $a =~ s/\s+$//;
 76 |             if (length($a)) {
 77 |                 $nlonly = 0;
 78 |                 last;
 79 |             }
 80 |         }
 81 |         while ($di < @deli) {
 82 |             $d = $deli[$di++];
 83 |             $d =~ s/\s+$//;
 84 |             if (length($d)) {
 85 |                 $nlonly = 0;
 86 |                 last;
 87 |             }
 88 |         }
 89 |         last if (!length($a) && !length($d));
 90 | 
 91 |         $a =~ /^$close_key/o and $braces--;
 92 |         $d =~ /^$close_key/o and $braces++;
 93 |         if ($braces) {
 94 |             $a =~ s/$kill_nl_ws/$1/go;
 95 |             $d =~ s/$kill_nl_ws/$1/go;
 96 |         } else {
 97 |             $a =~ s/$kill_all_ws/$1/go;
 98 |             $d =~ s/$kill_all_ws/$1/go;
 99 |         }
100 |         $loc_nonws = 1 if ($a ne $d);
101 |         $a =~ /^$open_key/o and $braces++;
102 |         $d =~ /^$open_key/o and $braces--;
103 |     }
104 |     while ($ai < @addi) {
105 |         my $a = $addi[$ai++];
106 |         $a =~ /^$close_key/o and $braces--;
107 |         $a =~ /^$open_key/o and $braces++;
108 |     }
109 |     while ($di < @deli) {
110 |         my $d = $deli[$di++];
111 |         $d =~ /^$close_key/o and $braces++;
112 |         $d =~ /^$open_key/o and $braces--;
113 |     }
114 |     if ($loc_nonws) {
115 |         $nonws = 1;
116 |     } elsif (!$nlonly) {
117 |         $ws = 1;
118 |         my $chunkhdr = "@@ -".($lineno2 - $#deli).",".($#deli + 1)." +".($lineno - $#addi).",".($#addi + 1)." @@\n";
119 |         if (!$fileHdrShown) {
120 |             $fileHdrShown = 1;
121 |             $patch .= join("", @filehdr);
122 |         }
123 |         $patch .= $chunkhdr."-".join("-", @deli)."+".join("+", @addi);
124 |         push @ws_files, $file if (!defined($ws_lines{$file}));
125 |         push @{$ws_lines{$file}}, $lineno - $#addi;
126 |     }
127 |     @addi = @deli = ();
128 |     $chunk = 0;
129 | }
130 | 
131 | open DIFF, "git diff-tree --no-commit-id --diff-filter=ACMR --src-prefix=\@old\@/ --dst-prefix=\@new\@/ --full-index -r -U100000 --cc -M --root HEAD |" or printerr;
132 | while (<DIFF>) {
133 |     if (/^-/) {
134 |         if ($mixws_check) {
135 |             if (/^--- /) {
136 |                 $filehdr[0] = $_;
137 |                 next;
138 |             }
139 |             push @deli, substr($_, 1);
140 |             $chunk = 1;
141 |         }
142 |         $lineno2++;
143 |         next;
144 |     }
145 |     if (/^\+/) {
146 |         if (/^\+\+\+ /) {
147 |             $filehdr[1] = $_;
148 |             next;
149 |         }
150 |         $lineno++;
151 |         $_ = substr($_, 1);
152 |         if ($mixws_check) {
153 |             push @addi, $_;
154 |             $chunk = 1;
155 |         }
156 |     } else {
157 |         flushChunk() if ($chunk);
158 |         if (/^ /) {
159 |             $lineno++;
160 |             $lineno2++;
161 |             next;
162 |         }
163 |         if (/^\@\@ -(\d+),\d+ \+(\d+)/) {
164 |             $lineno2 = $1 - 1;
165 |             $lineno = $2 - 1;
166 |             next;
167 |         }
168 |         if (/^diff /) {
169 |             if (/^diff --git \@old\@\/.+ \@new\@\/(.+)$/) {
170 |             } elsif (/^diff --cc (.+)$/) {
171 |                 print STDERR "Cannot operate on merge commits.\n";
172 |                 exit 1;
173 |             } else {
174 |                 print STDERR "Warning: cannot parse diff header '".$_."'\n";
175 |                 next;
176 |             }
177 |             $fileHdrShown = 0;
178 |             $file = $1;
179 |             #print "*** got file ".$file.".\n";
180 |             my $clike = ($file =~ /\.(c|cc|cpp|c\+\+|cxx|qdoc|m|mm|h|hpp|hxx|cs|java|js|qs|qml|g|y|ypp|pl|glsl)$/i);
181 |             my $foreign = ($file =~ /\/3rdparty\//);
182 |             $mixws_check = !$foreign && $clike;
183 |             $braces = 0;
184 |             next;
185 |         }
186 |     }
187 | }
188 | close DIFF or printerr;
189 | flushChunk() if ($chunk);
190 | if (!$ws) {
191 |     print STDERR "No WS only changes, not touching this.\n";
192 |     exit 1;
193 | }
194 | if (!$nonws and $ws) {
195 |     print STDERR "Entirely WS changes, not touching this.\n";
196 |     exit 1;
197 | }
198 | # $patch contains the patch for appling the WS changes (-R to remove them). Now apply git-foo.
199 | system "git reset --soft HEAD^" or printerr;
200 | open PATCH_A, "| git apply --unidiff-zero -R --index -" or printerr;
201 | print PATCH_A $patch;
202 | close PATCH_A or printerr;
203 | system "git commit -C ORIG_HEAD" or printerr;
204 | if ($invocationCommand ne '') {
205 |     open PATCH_B, "| git apply --unidiff-zero --index -" or printerr;
206 |     print PATCH_B $patch;
207 |     close PATCH_B or printerr;
208 |     if ($invocationCommand eq 'commit') {
209 |         system "git commit -m \"Whitespace Changes\"" or printerr;
210 |     } else {
211 |         system "git stash save \"Whitespace Changes\"" or printerr;
212 |     }
213 | } else {
214 |     open PATCH_C, "| git apply --unidiff-zero -" or printerr;
215 |     print PATCH_C $patch;
216 |     close PATCH_C or printerr;
217 | }
218 | exit 0;
219 | 


--------------------------------------------------------------------------------
/LICENSES/LGPL-3.0-only.txt:
--------------------------------------------------------------------------------
  1 |                    GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 | 
  9 |   This version of the GNU Lesser General Public License incorporates
 10 | the terms and conditions of version 3 of the GNU General Public
 11 | License, supplemented by the additional permissions listed below.
 12 | 
 13 |   0. Additional Definitions.
 14 | 
 15 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 17 | General Public License.
 18 | 
 19 |   "The Library" refers to a covered work governed by this License,
 20 | other than an Application or a Combined Work as defined below.
 21 | 
 22 |   An "Application" is any work that makes use of an interface provided
 23 | by the Library, but which is not otherwise based on the Library.
 24 | Defining a subclass of a class defined by the Library is deemed a mode
 25 | of using an interface provided by the Library.
 26 | 
 27 |   A "Combined Work" is a work produced by combining or linking an
 28 | Application with the Library.  The particular version of the Library
 29 | with which the Combined Work was made is also called the "Linked
 30 | Version".
 31 | 
 32 |   The "Minimal Corresponding Source" for a Combined Work means the
 33 | Corresponding Source for the Combined Work, excluding any source code
 34 | for portions of the Combined Work that, considered in isolation, are
 35 | based on the Application, and not on the Linked Version.
 36 | 
 37 |   The "Corresponding Application Code" for a Combined Work means the
 38 | object code and/or source code for the Application, including any data
 39 | and utility programs needed for reproducing the Combined Work from the
 40 | Application, but excluding the System Libraries of the Combined Work.
 41 | 
 42 |   1. Exception to Section 3 of the GNU GPL.
 43 | 
 44 |   You may convey a covered work under sections 3 and 4 of this License
 45 | without being bound by section 3 of the GNU GPL.
 46 | 
 47 |   2. Conveying Modified Versions.
 48 | 
 49 |   If you modify a copy of the Library, and, in your modifications, a
 50 | facility refers to a function or data to be supplied by an Application
 51 | that uses the facility (other than as an argument passed when the
 52 | facility is invoked), then you may convey a copy of the modified
 53 | version:
 54 | 
 55 |    a) under this License, provided that you make a good faith effort to
 56 |    ensure that, in the event an Application does not supply the
 57 |    function or data, the facility still operates, and performs
 58 |    whatever part of its purpose remains meaningful, or
 59 | 
 60 |    b) under the GNU GPL, with none of the additional permissions of
 61 |    this License applicable to that copy.
 62 | 
 63 |   3. Object Code Incorporating Material from Library Header Files.
 64 | 
 65 |   The object code form of an Application may incorporate material from
 66 | a header file that is part of the Library.  You may convey such object
 67 | code under terms of your choice, provided that, if the incorporated
 68 | material is not limited to numerical parameters, data structure
 69 | layouts and accessors, or small macros, inline functions and templates
 70 | (ten or fewer lines in length), you do both of the following:
 71 | 
 72 |    a) Give prominent notice with each copy of the object code that the
 73 |    Library is used in it and that the Library and its use are
 74 |    covered by this License.
 75 | 
 76 |    b) Accompany the object code with a copy of the GNU GPL and this license
 77 |    document.
 78 | 
 79 |   4. Combined Works.
 80 | 
 81 |   You may convey a Combined Work under terms of your choice that,
 82 | taken together, effectively do not restrict modification of the
 83 | portions of the Library contained in the Combined Work and reverse
 84 | engineering for debugging such modifications, if you also do each of
 85 | the following:
 86 | 
 87 |    a) Give prominent notice with each copy of the Combined Work that
 88 |    the Library is used in it and that the Library and its use are
 89 |    covered by this License.
 90 | 
 91 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
 92 |    document.
 93 | 
 94 |    c) For a Combined Work that displays copyright notices during
 95 |    execution, include the copyright notice for the Library among
 96 |    these notices, as well as a reference directing the user to the
 97 |    copies of the GNU GPL and this license document.
 98 | 
 99 |    d) Do one of the following:
100 | 
101 |        0) Convey the Minimal Corresponding Source under the terms of this
102 |        License, and the Corresponding Application Code in a form
103 |        suitable for, and under terms that permit, the user to
104 |        recombine or relink the Application with a modified version of
105 |        the Linked Version to produce a modified Combined Work, in the
106 |        manner specified by section 6 of the GNU GPL for conveying
107 |        Corresponding Source.
108 | 
109 |        1) Use a suitable shared library mechanism for linking with the
110 |        Library.  A suitable mechanism is one that (a) uses at run time
111 |        a copy of the Library already present on the user's computer
112 |        system, and (b) will operate properly with a modified version
113 |        of the Library that is interface-compatible with the Linked
114 |        Version.
115 | 
116 |    e) Provide Installation Information, but only if you would otherwise
117 |    be required to provide such information under section 6 of the
118 |    GNU GPL, and only to the extent that such information is
119 |    necessary to install and execute a modified version of the
120 |    Combined Work produced by recombining or relinking the
121 |    Application with a modified version of the Linked Version. (If
122 |    you use option 4d0, the Installation Information must accompany
123 |    the Minimal Corresponding Source and Corresponding Application
124 |    Code. If you use option 4d1, you must provide the Installation
125 |    Information in the manner specified by section 6 of the GNU GPL
126 |    for conveying Corresponding Source.)
127 | 
128 |   5. Combined Libraries.
129 | 
130 |   You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 | 
136 |    a) Accompany the combined library with a copy of the same work based
137 |    on the Library, uncombined with any other library facilities,
138 |    conveyed under the terms of this License.
139 | 
140 |    b) Give prominent notice with the combined library that part of it
141 |    is a work based on the Library, and explaining where to find the
142 |    accompanying uncombined form of the same work.
143 | 
144 |   6. Revised Versions of the GNU Lesser General Public License.
145 | 
146 |   The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 | 
151 |   Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 | 
161 |   If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.
166 | 


--------------------------------------------------------------------------------
/bin/git-qt-cherry-pick:
--------------------------------------------------------------------------------
  1 | #! /usr/bin/perl
  2 | # Copyright (C) 2015 The Qt Company Ltd.
  3 | # Contact: http://www.qt.io/licensing/
  4 | #
  5 | # You may use this file under the terms of the 3-clause BSD license.
  6 | # See the file LICENSE from this package for details.
  7 | #
  8 | 
  9 | use warnings;
 10 | use strict;
 11 | 
 12 | my @repos = (
 13 |     [ "projects.pro", "qt" ],
 14 |     [ "qlalr.pro", "qt5/qlalr" ],
 15 |     [ "qtactiveqt.pro", "qt5/qtactiveqt" ],
 16 |     [ "qtbase.pro", "qt5/qtbase" ],
 17 |     [ "qtdeclarative.pro", "qt5/qtdeclarative" ],
 18 |     [ "qtdoc.pro", "qt5/qtdoc" ],
 19 |     [ "qtphonon.pro", "qt5/qtphonon" ],
 20 |     [ "qtquick1.pro", "qt5/qtquick1" ],
 21 |     [ "qtscript.pro", "qt5/qtscript" ],
 22 |     [ "qtsvg.pro", "qt5/qtsvg" ],
 23 |     [ "qttools.pro", "qt5/qttools" ],
 24 |     [ "qttranslations.pro", "qt5/qttranslations" ],
 25 |     [ "qtxmlpatterns.pro", "qt5/qtxmlpatterns" ],
 26 |     [ "qtcreator.pro", "qtcreator" ],
 27 | 
 28 |     [ "git-hooks/sanitize-commit", "qt5/qtrepotools" ],
 29 |     [ "shell/sanitize-commit", "devtools" ],
 30 | );
 31 | 
 32 | my @mappings = (
 33 |     [ [ "qt", "qt5/qlalr" ], [
 34 |         [ 'util/qlalr//[^/]+$', 'src//[^/]+$' ],
 35 |         [ 'util/qlalr', '' ]
 36 |     ] ],
 37 |     [ [ "qt", "qt5/qtactiveqt" ], [
 38 |         [ 'tools/activeqt', 'tools' ],
 39 |         [ 'doc/src/examples/activeqt', 'doc/src/examples' ],
 40 |         [ 'doc/src/development//[^/]+$', 'doc/src//[^/]+$' ]
 41 |     ] ],
 42 |     [ [ "qt", "qt5/qtbase" ], [
 43 |         [ 'doc/src/development', 'qmake/doc/src' ],
 44 |     ] ],
 45 |     [ [ "qt", "qt5/qtdeclarative" ], [
 46 |         [ 'tools/qml', 'tools/qmlviewer' ]
 47 |     ] ],
 48 |     [ [ "qt", "qt5/qtdoc" ], [
 49 |         [ 'tools/qdoc3/test', 'doc/config' ]
 50 |     ] ],
 51 |     [ [ "qt", "qt5/qtphonon" ], [
 52 |     ] ],
 53 |     [ [ "qt", "qt5/qtquick1" ], [
 54 |     ] ],
 55 |     [ [ "qt", "qt5/qtscript" ], [
 56 |     ] ],
 57 |     [ [ "qt", "qt5/qtsvg" ], [
 58 |     ] ],
 59 |     [ [ "qt", "qt5/qttools" ], [
 60 |         [ 'tools', 'src' ]
 61 |     ] ],
 62 |     [ [ "qt", "qt5/qttranslations" ], [
 63 |     ] ],
 64 |     [ [ "qt", "qt5/qtxmlpatterns" ], [
 65 |     ] ],
 66 |     [ [ "devtools", "qt5/qtrepotools" ], [
 67 |         [ 'shell/git-', 'bin/git-' ],
 68 |         [ 'shell/git_post_commit_hook', 'git-hooks/git_post_commit_hook' ],
 69 |         [ 'shell/sanitize-commit', 'git-hooks/sanitize-commit' ]
 70 |     ] ],
 71 |     [ [ "qtcreator", "qt5/qttools" ], [
 72 |         [ 'src/shared/proparser', 'src/linguist/shared' ],
 73 |     ], 1 ],
 74 |     [ [ "qtcreator", "qt5/qtbase" ], [
 75 |         [ 'src/shared/proparser', 'qmake/library' ],
 76 |     ], 1 ],
 77 |     [ [ "qt5/qtbase", "qt5/qttools" ], [
 78 |         [ 'qmake/library', 'src/linguist/shared' ],
 79 |     ], 1 ],
 80 |     [ [ "qt5/qtbase", "qt5/qtdoc" ], [
 81 |         [ 'qmake/doc/src/snippets', 'doc/src/snippets' ],
 82 |         [ 'qmake/doc/src', 'doc/src/development' ],
 83 |     ], 1 ]
 84 | );
 85 | 
 86 | my ($cand, $inv);
 87 | sub map_name($)
 88 | {
 89 |     my ($fn) = @_;
 90 |     for my $ptha (@{$$cand[1]}) {
 91 |         my ($pthi, $ptho) = ($$ptha[$inv], $$ptha[1 - $inv]);
 92 |         $pthi .= "(.*)" if (!($pthi =~ s,//(.*),/($1),));
 93 |         $ptho =~ s,//.*,/,;
 94 |         last if ($fn =~ s/^$pthi/$ptho$1/);
 95 |     }
 96 |     return $fn;
 97 | }
 98 | 
 99 | sub get_arg()
100 | {
101 |     if (@ARGV < 2) {
102 |         die $ARGV[0]." requires an argument.\n";
103 |     }
104 |     shift @ARGV;
105 |     return $ARGV[0];
106 | }
107 | 
108 | sub get_repo_arg()
109 | {
110 |     my $arg = $ARGV[0];
111 |     my $val = get_arg();
112 |     for my $rp (@repos) {
113 |         if ($$rp[1] eq $val) {
114 |             return $val;
115 |         }
116 |         if ($$rp[1] =~ /\/\Q$val\E$/) {
117 |             return $$rp[1];
118 |         }
119 |     }
120 |     die "Fatal: Unknown repository passed to $arg.\n";
121 | }
122 | 
123 | my ($src_repo, $dst_repo, $other_path) = ("", "", "");
124 | my @commits = ();
125 | my $push = 0;
126 | my $noop = 0;
127 | while (@ARGV) {
128 |     my $arg = $ARGV[0];
129 |     if ($arg eq '-h' or $arg eq '-help' or $arg eq '--help') {
130 |         print <<EOF ;
131 | Usage: $0 [options] [SHA1/-range]
132 | 
133 | Options:
134 |   -l, --pull <repo>   Specify repo to pull from instead of guessing it.
135 |   -s, --push [<repo>] Push [to specified repo] instead of pulling.
136 |   -p, --path <path>   Specify path of other repo instead of guessing it.
137 |   -n, --dry-run       Dump patch to stdout instead of applying it.
138 |   --                  Only SHA1s follow this option (use with -s without repo).
139 | 
140 | By default, the HEAD commit of the source repo is cherry-picked.
141 | EOF
142 |         exit 0;
143 |     } elsif ($arg eq '-l' or $arg eq '--pull') {
144 |         $src_repo = get_repo_arg();
145 |     } elsif ($arg eq '-s' or $arg eq '--push') {
146 |         $dst_repo = get_repo_arg() if (@ARGV >= 2 && $ARGV[1] !~ /^-/);
147 |         $push = 1;
148 |     } elsif ($arg eq '-p' or $arg eq '--path') {
149 |         $other_path = get_arg();
150 |     } elsif ($arg eq '-n' or $arg eq '--dry-run') {
151 |         $noop = 1;
152 |     } elsif ($arg eq "--") {
153 |         shift @ARGV;
154 |         push @commits, @ARGV;
155 |         last;
156 |     } elsif ($arg =~ /^-/) {
157 |         die "Unrecognized option $arg.\n";
158 |     } else {
159 |         push @commits, $arg;
160 |     }
161 |     shift @ARGV;
162 | }
163 | 
164 | die "-s and -l are mutually exclusive.\n" if ($src_repo ne "" and $dst_repo ne "");
165 | 
166 | push @commits, "HEAD" if (!@commits);
167 | 
168 | my $cdup = `git rev-parse --show-cdup` or exit 1;
169 | chomp $cdup;
170 | if (length($cdup)) {
171 |     chdir $cdup or die "Cannot enter $cdup: $!\n";
172 | }
173 | 
174 | my $this_repo = "";
175 | for my $rp (@repos) {
176 |     if (-f $$rp[0]) {
177 |         $this_repo = $$rp[1];
178 |         last;
179 |     }
180 | }
181 | die "Fatal: This Git repository is not known to this script.\n" if ($this_repo eq "");
182 | 
183 | if (!$push) {
184 |     $dst_repo = $this_repo;
185 | } else {
186 |     $src_repo = $this_repo;
187 | }
188 | 
189 | die "Fatal: source and target repository are the same.\n" if ($src_repo eq $dst_repo);
190 | 
191 | my @candidates = ();
192 | my $mincand = 10;
193 | for my $cand (@mappings) {
194 |     my $mcand = $$cand[2] // 0;
195 |     if ($mcand <= $mincand) {
196 |         for my $inv (0, 1) {
197 |             if (("" eq $src_repo or $$cand[0][$inv] eq $src_repo) and
198 |                 ("" eq $dst_repo or $$cand[0][1 - $inv] eq $dst_repo)) {
199 |                 if ($mcand < $mincand) {
200 |                     $mincand = $mcand;
201 |                     @candidates = ();
202 |                 }
203 |                 push @candidates, [ $cand, $inv ];
204 |                 last;
205 |             }
206 |         }
207 |     }
208 | }
209 | if (@candidates == 0) {
210 |     die "Fatal: found no mapping between source and target repository.\n";
211 | } elsif (@candidates > 1) {
212 |     die "Fatal: found multiple mappings between source and target repository. Try -l/-p.\n";
213 | }
214 | ($cand, $inv) = @{$candidates[0]};
215 | print "Porting from ".$$cand[0][$inv]." to ".$$cand[0][1 - $inv]."\n";
216 | if ($other_path eq "") {
217 |     my $this_path = $$cand[0][1 - ($push ^ $inv)];
218 |     my $cnt = 1;
219 |     while ($this_path =~ /\//g) { $cnt++ }
220 |     $other_path = "../"x$cnt . $$cand[0][$push ^ $inv];
221 | }
222 | print "Other path is ".$other_path."\n";
223 | my $cd_other = "cd \"".$other_path."\" && ";
224 | my ($src_cd, $dst_cd) = ("", "");
225 | if (!$push) {
226 |     $src_cd = $cd_other;
227 | } else {
228 |     $dst_cd = $cd_other;
229 | }
230 | 
231 | my $short_src = $$cand[0][$inv];
232 | $short_src =~ s,^.*/,,;
233 | my $needid = -1;
234 | for my $commit (@commits) {
235 |     my @revs;
236 |     if ($commit =~ /\.\./) {
237 |         @revs = `${src_cd}git rev-list --reverse $commit`;
238 |     } else {
239 |         @revs = ($commit);
240 |     }
241 |     for my $rev (@revs) {
242 |         my ($first, $empty, $sha1, $patch, $haveid) = (1, 0, "", "", 0);
243 |         open DIFF, $src_cd."git format-patch --stdout -1 --src-prefix=\@old\@/ --dst-prefix=\@new\@/ ".$rev." |" or die "cannot run git: $!";
244 |         while (<DIFF>) {
245 |             if ($first) {
246 |                 $first = 0;
247 |                 /^From (.{40}) / and $sha1 = $1;
248 |             } elsif ($_ eq "\n" || /^[-\w]+: /) {
249 |                 $haveid = 1 if (/^Change-Id:/);
250 |                 $empty = 1;
251 |             } else {
252 |                 if (s/^(diff --git \@old\@\/)(.*)( \@new\@\/)(.*)\n/$1.map_name($2).$3.map_name($4)."\n"/e) {
253 |                 } elsif (s/^(--- \@old\@|\+\+\+ \@new\@)\/([^\n]+)/$1."\/".map_name($2)/e) {
254 |                 } elsif ($_ eq "---\n") {
255 |                     $patch .= "\n" if (!$empty);
256 |                     $patch .= "(cherry picked from ".$short_src."/".$sha1.")\n";
257 |                     if (!$haveid) {
258 |                         $needid = int(grep /codereview/, `${dst_cd}git remote -v`) if ($needid < 0);
259 |                         $patch .= "Change-Id: I".$sha1."\n" if ($needid);
260 |                     }
261 |                 }
262 |                 $empty = 0;
263 |             }
264 |             $patch .= $_;
265 |         }
266 |         close DIFF or die "Aborting at ".$rev."\n";
267 |         if ($noop) {
268 |             print $patch;
269 |         } else {
270 |             open PATCH, "| ".$dst_cd."git am -3" or die "cannot run git: $!";
271 |             print PATCH $patch;
272 |             close PATCH or die "Aborting at ".$rev."\n";
273 |         }
274 |     }
275 | }
276 | exit 0;
277 | 


--------------------------------------------------------------------------------
/bin/git-ppush:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | # Copyright (C) 2015 The Qt Company Ltd.
  3 | # Contact: http://www.qt.io/licensing/
  4 | #
  5 | # You may use this file under the terms of the 3-clause BSD license.
  6 | # See the file LICENSE from this package for details.
  7 | #
  8 | 
  9 | package Git::PPush;
 10 | 
 11 | use strict;
 12 | use warnings;
 13 | 
 14 | # Cannot use Pod::Usage for this file, since git on Windows will invoke its own perl version, which
 15 | # may not (msysgit for example) support this module, even if it's considered a Core module.
 16 | sub usage
 17 | {
 18 |     print <<'EOM';
 19 | Usage:
 20 |     git ppush [options] [<refspec>...]
 21 | 
 22 |     Pushes local branches to a personal namespace on a git server.
 23 | 
 24 |     A git repository has two standard namespaces: heads and tags, which
 25 |     are automatically added when setting up remotes.
 26 |     But it is possible to put refs into non-standard namespaces as well.
 27 |     These namespaces can be used to make backups or share work somewhat
 28 |     silently.
 29 | 
 30 | Options:
 31 |     <refspec>...
 32 |         The format is the same as for a regular git push.
 33 |         However, the destination ref is automatically prefixed with the
 34 |         personal namespace.
 35 | 
 36 |     -a, --all
 37 |         Push all local branches instead of the current one.
 38 | 
 39 |     -r, --remote=<remote>
 40 |         Use specified remote instead of 'personal'.
 41 | 
 42 |     --prune
 43 |         Remove remote branches that do not have a local counterpart.
 44 | 
 45 |     --delete
 46 |         All listed refs are deleted from the remote repository.
 47 |         This is the same as prefixing all refs with a colon.
 48 | 
 49 |     -f, --force
 50 |         Force push even if remote commits will be lost.
 51 | 
 52 |     -n, --dry-run
 53 |         Do everything except actually send the updates.
 54 | 
 55 |     -v, --verbose
 56 |         Shows the final 'git push' command as a comma-separated list of
 57 |         arguments.
 58 | 
 59 |     --setup
 60 |         Instead of pushing, create the personal remote.
 61 | 
 62 |     -b, --base=<remote>
 63 |         In setup mode, use the specified remote as an information source.
 64 |         By default, the current branch's upstream is used.
 65 | 
 66 |     -u, --url=<url>
 67 |         In setup mode, use the specified git URL instead of trying to
 68 |         derive it from the base remote.
 69 | 
 70 |     -p, --user=<user>
 71 |         In setup mode, use the specified user (subdirectory) instead of
 72 |         trying to derive it from the username in the URL.
 73 | 
 74 |     -s, --namespace=<namespace>
 75 |         In setup mode, use the specified namespace instead of 'personal'.
 76 | 
 77 | Examples:
 78 | 
 79 |     Backup local branches:
 80 | 
 81 |         $ git ppush --setup --base=gerrit    # Needed only once
 82 |         $ git ppush -f                       # Backup current branch
 83 |         $ git ppush --force --all --prune    # Synchronize everything
 84 | 
 85 |     Get a colleague's work:
 86 | 
 87 |         $ git ppush --setup --base=gerrit --remote=ossis --user=buddenha
 88 |         $ git fetch ossis
 89 |         $ git log -p ossis/master
 90 | 
 91 | Copyright:
 92 |     Copyright (C) 2015 The Qt Company Ltd.
 93 |     Contact: http://www.qt.io/licensing/
 94 | 
 95 | License:
 96 |     You may use this file under the terms of the 3-clause BSD license.
 97 | EOM
 98 | }
 99 | 
100 | sub parse_arguments
101 | {
102 |     my ($self, @arguments) = @_;
103 | 
104 |     while (scalar @arguments) {
105 |         my $arg = shift @arguments;
106 | 
107 |         if ($arg eq "-?" || $arg eq "--?" || $arg eq "-h" || $arg eq "--help") {
108 |             $self->usage();
109 |             exit 0;
110 |         } elsif ($arg eq "-v" || $arg eq "--verbose") {
111 |             $self->{'verbose'} = 1;
112 |             push @{$self->{'arguments'}}, $arg;
113 |         } elsif ($arg eq "-n" || $arg eq "--dry-run") {
114 |             $self->{'dry-run'} = 1;
115 |             push @{$self->{'arguments'}}, $arg;
116 |         } elsif ($arg eq "-r") {
117 |             $self->{'remote'} = shift @arguments;
118 |         } elsif ($arg =~ /^--remote=(.*)/) {
119 |             $self->{'remote'} = $1;
120 |         } elsif ($arg eq "-a" || $arg eq "--all") {
121 |             $self->{'refs'} = [ "refs/heads/*" ];
122 |         } elsif ($arg eq "--prune") {
123 |             $self->{'prune'} = 1;
124 |             push @{$self->{'arguments'}}, $arg;
125 |         } elsif ($arg eq "--delete") {
126 |             $self->{'delete'} = 1;
127 |         } elsif ($arg eq "-f" || $arg eq "--force") {
128 |             $self->{'force'} = 1;
129 |         } elsif ($arg eq "--setup") {
130 |             $self->{'setup'} = 1;
131 |         } elsif ($arg eq "-b") {
132 |             $self->{'base'} = shift @arguments;
133 |         } elsif ($arg =~ /^--base=(.*)/) {
134 |             $self->{'base'} = $1;
135 |         } elsif ($arg eq "-u") {
136 |             $self->{'url'} = shift @arguments;
137 |         } elsif ($arg =~ /^--url=(.*)/) {
138 |             $self->{'url'} = $1;
139 |         } elsif ($arg eq "-s") {
140 |             $self->{'namespace'} = shift @arguments;
141 |         } elsif ($arg =~ /^--namespace=(.*)/) {
142 |             $self->{'namespace'} = $1;
143 |         } elsif ($arg eq "-p") {
144 |             $self->{'user'} = shift @arguments;
145 |         } elsif ($arg =~ /^--user=(.*)/) {
146 |             $self->{'user'} = $1;
147 |         } elsif ($arg =~ /^-/) {
148 |             die "Unrecognized option ".$arg."\n";
149 |         } else {
150 |             push @{$self->{'refs'}}, $arg;
151 |         }
152 |     }
153 | 
154 |     if ($self->{'setup'}) {
155 |         die "Naming refspecs is incompatible with --setup.\n" if (@{$self->{'refs'}});
156 |         die "--prune is incompatible with --setup\n" if ($self->{'prune'});
157 |         die "--delete is incompatible with --setup\n" if ($self->{'delete'});
158 |         die "--force is incompatible with --setup\n" if ($self->{'force'});
159 |     } else {
160 |         die "--base is valid only in --setup mode.\n" if ($self->{'base'});
161 |         die "--url is valid only in --setup mode.\n" if ($self->{'url'});
162 |         die "--namespace is valid only in --setup mode.\n" if ($self->{'namespace'});
163 |         die "--user is valid only in --setup mode.\n" if ($self->{'user'});
164 |     }
165 | }
166 | 
167 | sub spawn_cmd
168 | {
169 |     my ($self, @cmd) = @_;
170 | 
171 |     print '+'.join(',', @cmd)."\n" if ($self->{'verbose'});
172 |     system(@cmd) and exit $? if (!$self->{'dry-run'});
173 | }
174 | 
175 | sub run_setup
176 | {
177 |     my ($self) = @_;
178 | 
179 |     my $url = $self->{'url'};
180 |     my $user = $self->{'user'};
181 |     if (!$url) {
182 |         my $base = $self->{'base'};
183 |         if (!$base) {
184 |             my $ref = `git symbolic-ref -q HEAD`;
185 |             die "Not on a branch. Cannot determine base remote.\n" if (!$ref);
186 |             chomp $ref;
187 |             $ref =~ s,^refs/heads/,,;
188 |             $base = `git config branch.$ref.remote`;
189 |             die "Have no upstream. Cannot determine base remote.\n" if (!$base);
190 |             chomp $base;
191 |         }
192 |         # Personal repos can only be in Gerrit, but the base repo might be using
193 |         # a mirror. Try the pushurl first, if that has been set up, it most likely
194 |         # will point to Gerrit. It will be set as .url, so both push and fetch work.
195 |         $url = `git config remote.$base.pushurl`;
196 |         $url = `git config remote.$base.url` if (!$url);
197 |         die "Cannot determine URL of base remote. Try --url.\n" if (!$url);
198 |         chomp $url;
199 |     }
200 |     if (!$user) {
201 |         $url =~ m,(?:[^:]+://)?([^\@]+)\@.*, or
202 |             # FIXME: could try to query ssh config here.
203 |             die "Cannot determine user from URL. Try --user.\n";
204 |         $user = $1;
205 |     }
206 |     my $remote = $self->{'remote'};
207 |     my $namespace = $self->{'namespace'};
208 |     $namespace = "personal" if (!$namespace);
209 |     $self->spawn_cmd("git", "config", "remote.$remote.url", $url);
210 |     $self->spawn_cmd("git", "config", "remote.$remote.fetch",
211 |                                       "+refs/$namespace/$user/*:refs/remotes/$remote/*");
212 | }
213 | 
214 | sub push_commits
215 | {
216 |     my ($self) = @_;
217 | 
218 |     my $force = $self->{'force'};
219 |     my $remote = $self->{'remote'};
220 |     my $refspec = `git config remote.$remote.fetch`;
221 |     die "Invalid remote specified.\n" if (!$refspec);
222 |     chomp $refspec;
223 |     $refspec =~ s,^\+?([^*]+).*,$1,;
224 |     my @refs = @{$self->{'refs'}};
225 |     if (!@refs) {
226 |         my $ref = `git symbolic-ref -q HEAD`;
227 |         die "No refspecs given and not on a branch.\n" if (!$ref);
228 |         chomp $ref;
229 |         $ref =~ s,^refs/heads/,,;
230 |         push @refs, $ref;
231 |     }
232 | 
233 |     my @gitcmd = ("git", "push");
234 |     push @gitcmd, @{$self->{'arguments'}};
235 |     push @gitcmd, $remote;
236 |     foreach my $ref (@refs) {
237 |         my ($pfx, $src, $dst) = ("", "", "");
238 |         $ref =~ s,^(\+?)(.*),$2,;
239 |         $pfx = $1;
240 |         $pfx = '+' if ($force);
241 |         if ($ref =~ /(.*):(.*)/) {
242 |             $src = $1;
243 |             $dst = $2;
244 |         } else {
245 |             $src = $ref if (!$self->{'delete'});
246 |             $dst = $ref;
247 |         }
248 |         $dst =~ s,^refs/heads/,,;
249 |         push @gitcmd, $pfx.$src.':'.$refspec.$dst;
250 |     }
251 | 
252 |     $self->{'dry-run'} = 0;  # we already have it in git's command line
253 |     $self->spawn_cmd(@gitcmd);
254 |     exit 0;
255 | }
256 | 
257 | sub new
258 | {
259 |     my ($class, @arguments) = @_;
260 | 
261 |     my $self = {};
262 |     bless $self, $class;
263 | 
264 |     $self->{'verbose'} = 0;
265 |     $self->{'dry-run'} = 0;
266 | 
267 |     $self->{'setup'} = 0;
268 |     $self->{'remote'} = "personal";
269 | 
270 |     # push mode
271 |     $self->{'refs'} = [];
272 |     $self->{'prune'} = 0;
273 |     $self->{'delete'} = 0;
274 |     $self->{'force'} = 0;
275 | 
276 |     # setup mode
277 |     $self->{'base'} = "";
278 |     $self->{'url'} = "";
279 |     $self->{'namespace'} = "";
280 |     $self->{'user'} = "";
281 | 
282 |     $self->{'arguments'} = [];
283 | 
284 |     $self->parse_arguments(@arguments);
285 |     return $self;
286 | }
287 | 
288 | sub run
289 | {
290 |     my ($self) = @_;
291 |     if ($self->{'setup'}) {
292 |         $self->run_setup;
293 |     } else {
294 |         $self->push_commits;
295 |     }
296 | }
297 | 
298 | #==============================================================================
299 | 
300 | Git::PPush->new(@ARGV)->run if (!caller);
301 | 1;
302 | 


--------------------------------------------------------------------------------
/git-hooks/gerrit-bot:
--------------------------------------------------------------------------------
  1 | #! /usr/bin/perl
  2 | 
  3 | # Copyright (C) 2015 The Qt Company Ltd.
  4 | # Contact: http://www.qt.io/licensing/
  5 | #
  6 | # You may use this file under the terms of the 3-clause BSD license.
  7 | # See the file LICENSE from this package for details.
  8 | #
  9 | 
 10 | use strict;
 11 | use warnings;
 12 | use POSIX;
 13 | use JSON;
 14 | use File::Path;
 15 | use Gerrit::REST;
 16 | 
 17 | # Usage: $0 [instance]
 18 | # - default instance is 'sanitybot'
 19 | # - configure ssh: Host, Port, User, IdentityFile
 20 | # - configure git: git config --global <instance>}.<option> <value>
 21 | # Valid options are:
 22 | #   gerrithost (mandatory)
 23 | #     Target host. The identification is done via SSH.
 24 | #   gerritactorhost
 25 | #     Target host for inviting reviewers. Falls back go gerrithost.
 26 | #   resthost (mandatory)
 27 | #     The REST base URL of the target host.
 28 | #   restuser
 29 | #     The user name for resthost. If omitted, credentials are expected in .netrc.
 30 | #   restpass
 31 | #     The password for resthost. If omitted, credentials are expected in .netrc.
 32 | #   useremail (mandatory)
 33 | #     Bot's email address. Used to identify invitations and own actions.
 34 | #   inviteonly (default 0)
 35 | #     If this flag is set, the bot will only become active if it is a
 36 | #     requested reviewer. DON'T USE (see TODO).
 37 | #   gitbasedir (mandatory)
 38 | #     Base dir for local GIT clones of the projects.
 39 | #   gitdofetch
 40 | #     Need to fetch the repos or are they local?
 41 | #   workers
 42 | #     A space-separated list of workers.
 43 | #     They are run in a local bare clone of the inspected repository.
 44 | #     There must be a workers.<worker> config entry for each worker
 45 | #     (note that these entries are NOT namespaced with the instance).
 46 | #     The magic string @SHA1@ is replaced by the commit to be checked;
 47 | #     @PROJ@ by the gerrit project the worker is run for.
 48 | #     @BRANCH@ is the branch the change was submitted to.
 49 | #     It is expected to dump a Gerrit ReviewInput JSON entity to stdout.
 50 | #     The output from all workers is merged.
 51 | #   excluded (optional)
 52 | #     Space-separated list of exclusions of the form <project>[:<branch>].
 53 | #     To globally exclude a branch, use *:<branch>.
 54 | #   maintainers (optional)
 55 | #     Space-separated list of reviewers to add on "special occasions".
 56 | #   verbose (default 0)
 57 | #     Print progress/result messages.
 58 | 
 59 | # TODO
 60 | # - Implement some retry mechanism to deal with network failures
 61 | # - Make inviteonly actually work beyond the initial startup.
 62 | #   See http://code.google.com/p/gerrit/issues/detail?id=1200
 63 | 
 64 | my $instance = 'sanitybot';
 65 | $instance = $ARGV[0] if ($#ARGV > -1);
 66 | 
 67 | # Doing this is less expensive than calling git repeatedly.
 68 | my %config = ();
 69 | for (`git config -l`) {
 70 |   /^([^=]+)=(.*$)/;
 71 |   $config{$1} = $2;
 72 | }
 73 | 
 74 | sub getcfg($;$)
 75 | {
 76 |   my ($key, $def) = @_;
 77 |   my $fkey = $instance.'.'.$key;
 78 |   if (defined $config{$fkey}) {
 79 |     return $config{$fkey};
 80 |   } elsif (@_ > 1) {
 81 |     return $def;
 82 |   } else {
 83 |     die $fkey." not set.\n";
 84 |   }
 85 | }
 86 | 
 87 | my $GERRIT_HOST = getcfg 'gerrithost';
 88 | my $GERRIT_ACTOR_HOST = getcfg 'gerritactorhost', $GERRIT_HOST;
 89 | my $USER_EMAIL = getcfg 'useremail';
 90 | my $INVITE_ONLY = getcfg 'inviteonly', 0;
 91 | my $REST_HOST = getcfg 'resthost';
 92 | my $REST_USER = getcfg 'restuser', undef;
 93 | my $REST_PASS = getcfg 'restpass', undef;
 94 | my $GIT_BASEDIR = getcfg 'gitbasedir';
 95 | my $GIT_DO_FETCH = getcfg 'gitdofetch';
 96 | my $WORKERS = getcfg 'workers';
 97 | my %EXCLUDED_PROJECTS = map { $_ => 1 } split(/\s+/, getcfg('excluded', ""));
 98 | my @MAINTAINERS = split(/\s+/, getcfg('maintainers', ""));
 99 | my $verbose = getcfg 'verbose', 0;
100 | 
101 | my @gerrit = ("ssh", $GERRIT_HOST, "gerrit");
102 | my @gerrit_actor = ("ssh", $GERRIT_ACTOR_HOST, "gerrit");
103 | my $gerrit_rest = Gerrit::REST->new($REST_HOST, $REST_USER, $REST_PASS);
104 | 
105 | my %processed = ();
106 | my %skipfetch = ();
107 | 
108 | sub printerr($)
109 | {
110 |   my ($msg) = @_;
111 |   die $msg.": execution failed: ".$!."\n" if ($? < 0);
112 |   die $msg.": command crashed with signal ".$?."\n" if ($? & 127);
113 |   print STDERR $msg.".\n";
114 | }
115 | 
116 | sub merge_hashes($$);
117 | 
118 | sub merge_hashes($$)
119 | {
120 |   my ($base, $ext) = @_;
121 | 
122 |   for my $k (keys %$ext) {
123 |     my $br = \$$base{$k};
124 |     my $ev = $$ext{$k};
125 |     if (!defined($$br)) {
126 |       $$br = $ev;
127 |     } else {
128 |       my $bt = ref($$br);
129 |       my $et = ref($ev);
130 |       die "Values for '$k' have different types ($bt, $et).\n" if ($bt ne $et);
131 |       if ($et eq "HASH") {
132 |         merge_hashes($$br, $ev);
133 |       } elsif ($et eq "ARRAY") {
134 |         push @$$br, @$ev;
135 |       } elsif ($et eq "") {
136 |         $$br = $$br."\n\n".$ev;
137 |       } else {
138 |         die "Values for '$k' have unsupported type $bt.\n";
139 |       }
140 |     }
141 |   }
142 | }
143 | 
144 | sub process_commit($$$$$)
145 | {
146 |   my ($number, $project, $branch, $ref, $rev) = @_;
147 | 
148 |   if (defined $processed{$ref}) {
149 |     return;
150 |   }
151 |   $processed{$ref} = 1;
152 |   my $orig_project = $project;
153 |   $project =~ s,/$,,; # XXX Workaround QTQAINFRA-381
154 |   my $verdict = {};
155 |   my @invite;
156 |   if (defined($EXCLUDED_PROJECTS{$project})
157 |       || defined($EXCLUDED_PROJECTS{"*:".$branch})
158 |       || defined($EXCLUDED_PROJECTS{$project.":".$branch})) {
159 |     $verbose and print "===== ".strftime("%c", localtime(time()))." ===== excluding commit ".$ref." in ".$project." on branch ".$branch."\n";
160 |     $$verdict{message} = "(skipped)";
161 |     $$verdict{labels}{'Sanity-Review'} = 1;
162 |   } else {
163 |     $verbose and print "===== ".strftime("%c", localtime(time()))." ===== processing commit ".$ref." in ".$project."\n";
164 |     my $GIT_DIR = $GIT_BASEDIR."/".$project.".git";
165 |     if (!-d $GIT_DIR) {
166 |       mkpath $GIT_DIR or die "cannot create ".$GIT_DIR.": ".$!;
167 |     }
168 |     chdir $GIT_DIR or die "cannot change to ".$GIT_DIR.": ".$!;
169 |     if ($GIT_DO_FETCH) {
170 |       if (!-d $GIT_DIR."/refs/remotes" and `git config remote.origin.url` eq "") {
171 |         if (!-d $GIT_DIR."/refs") {
172 |           if (system("git", "init", "--bare")) {
173 |             printerr "Init of ".$project." failed";
174 |             return;
175 |           }
176 |         }
177 |         if (system("git", "remote", "add", "origin", 'ssh://'.$GERRIT_HOST.'/'.$project)) {
178 |           printerr "Adding remote for ".$project." failed";
179 |           return;
180 |         }
181 |       }
182 |       my @mainlines;
183 |       if (!defined $skipfetch{$project}) {
184 |         # Update refs, otherwise the selective fetches start from scratch each time.
185 |         chomp(@mainlines = `git config remote.origin.fetch`);
186 |         $skipfetch{$project} = 1;
187 |       }
188 |       if (system("git", "fetch", "-f", "--prune", "origin", $ref.":refs/changes/".$number, @mainlines)) {
189 |         printerr "GIT fetch of ".$ref." from ".$project." failed";
190 |         return;
191 |       }
192 |       $verbose and print "===== ".strftime("%c", localtime(time()))." ===== fetched change\n";
193 |     }
194 | 
195 |     for my $w (split(/ /, $WORKERS)) {
196 |       my $worker = $config{'workers.'.$w};
197 |       die "workers.$worker not set.\n" if (!defined($worker));
198 |       $worker =~ s/\@PROJ\@/$project/g;
199 |       $worker =~ s/\@SHA1\@/$rev/g;
200 |       $worker =~ s/\@BRANCH\@/$branch/g;
201 |       my $output;
202 |       open VERDICT, $worker." 2>&1 |" or die "cannot run worker '$w': ".$!;
203 |       {
204 |         local $/;
205 |         $output = <VERDICT>;
206 |       }
207 |       close VERDICT;
208 |       while ($output =~ s/^([^\{][^\n]*\n)//s) {
209 |         print STDERR "Non-JSON output from worker '$w': $1\n";
210 |       }
211 |       die "Worker '$w' for commit ".$ref." in ".$project." crashed with signal ".$?.".\n" if ($? & 127);
212 |       die "Worker '$w' returned non-zero exit code for commit ".$ref." in ".$project.".\n" if ($?);
213 |       my $vd = {};
214 |       if (length($output) > 50000) {
215 |         $$vd{message} = "**** Worker '$w' produced an unreasonable amount of output. You should ask the bot maintainers for advice.";
216 |         push @invite, @MAINTAINERS;
217 |       } else {
218 |         $vd = decode_json($output);
219 |         defined($vd) or die "cannot decode verdict from worker '$w' as JSON\n";
220 |         if (defined($$vd{invite})) {
221 |           push @invite, @{$$vd{invite}};
222 |           delete $$vd{invite};
223 |         }
224 |       }
225 |       merge_hashes($verdict, $vd);
226 |     }
227 |   }
228 |   $$verdict{tag} = 'autogenerated:sanity';
229 |   my $hasComments = defined $$verdict{comments} && %{$$verdict{comments}};
230 |   if (defined $$verdict{labels}{'Sanity-Review'}
231 |       && $$verdict{labels}{'Sanity-Review'} == 1 && !$hasComments) {
232 |       # Don't spam everyone about a boring +1 sanity review with no comments.
233 |       $$verdict{notify} = "NONE";
234 |   }
235 |   if (@invite) {
236 |     if (system(@gerrit_actor, "set-reviewers", (map { ('-a', $_) } @invite), '-p', $project, '--', $rev)) {
237 |       print "===== ".strftime("%c", localtime(time()))." ===== invitation FAILED\n";
238 |       printerr("Inviting reviewers to ".$rev." (".$project."/".$ref.") failed");
239 |     } else {
240 |       $verbose and print "Invited @invite to ".$rev." (".$project."/".$ref.")\n";
241 |     }
242 |   }
243 |   eval {
244 |     $gerrit_rest->POST("/changes/$number/revisions/$rev/review", $verdict);
245 |   };
246 |   if ($@) {
247 |     print "===== ".strftime("%c", localtime(time()))." ===== verdict NOT submitted\n";
248 |     print STDERR "Submission of REST verdict for ".$rev." (".$project."/".$ref.") failed: $@\n";
249 |     return;
250 |   }
251 |   $verbose and print "Submitted verdict for ".$rev." (".$project."/".$ref.")\n";
252 | }
253 | 
254 | sub do_move($$$)
255 | {
256 |   return "Please use the menu in the top right corner 'Move change' instead of this bot.";
257 | }
258 | 
259 | sub process_move($$$) {
260 |   my ($chg, $author, $target) = @_;
261 |   my $number = $$chg{'number'};
262 |   $gerrit_rest->POST("/changes/$number/revisions/current/review",
263 |                      { message => do_move($chg, $author, $target) });
264 | }
265 | 
266 | $| = 1; # make STDOUT autoflush
267 | 
268 | open UPDATES, "-|", @gerrit, "stream-events" or die "cannot run ssh: ".$!;
269 | 
270 | # Try to ensure that the event streaming has started before we make the snapshot, to avoid a race.
271 | # Of course, the first connect may be still delayed ...
272 | sleep(1);
273 | 
274 | my @query = ("status:open");
275 | push @query, "reviewer:".$USER_EMAIL if ($INVITE_ONLY);
276 | open STATUS, "-|", @gerrit, "query", "--format", "JSON", "--current-patch-set", @query or die "cannot run ssh: ".$!;
277 | REVIEW: while (<STATUS>) {
278 |   my $review = decode_json($_);
279 |   defined($review) or die "cannot decode JSON string '".chomp($_)."'\n";
280 |   my $number = $$review{'number'};
281 |   my $project = $$review{'project'};
282 |   my $branch = $$review{'branch'};
283 |   my $cps = $$review{'currentPatchSet'};
284 |   if (defined $cps) {
285 |     my $status = $$review{'status'};
286 |     if ($status ne 'NEW' and $status ne 'DRAFT') {
287 |        next REVIEW;
288 |     }
289 |     my $ref = $$cps{'ref'};
290 |     my $revision = $$cps{'revision'};
291 |     my $approvals = $$cps{'approvals'};
292 |     if (defined $approvals) {
293 |       foreach my $appr (@$approvals) {
294 |         my $by = $$appr{'by'};
295 |         defined $$by{'email'} or next;   # The reviewer may be gone and thus have no valid mail any more.
296 |         if ($$by{'email'} eq $USER_EMAIL) {
297 |           next REVIEW;
298 |         }
299 |       }
300 |     }
301 |     process_commit($number, $project, $branch, $ref, $revision);
302 |   }
303 | }
304 | close STATUS;
305 | 
306 | while (<UPDATES>) {
307 |   my $update = decode_json($_);
308 |   defined($update) or die "cannot decode JSON string '".chomp($_)."'\n";
309 |   my $type = $$update{'type'};
310 |   if (defined($type)) {
311 |     if ($type eq 'patchset-created') {
312 |       my $chg = $$update{'change'};
313 |       my $ps = $$update{'patchSet'};
314 |       process_commit($$chg{'number'}, $$chg{'project'}, $$chg{'branch'}, $$ps{'ref'}, $$ps{'revision'});
315 |     } elsif ($type eq 'ref-updated') {
316 |       my $rup = $$update{'refUpdate'};
317 |       delete $skipfetch{$$rup{'project'}};
318 |     } elsif ($type eq 'comment-added') {
319 |       my $cmd = $$update{'comment'};
320 |       if ($cmd =~ /^(?:gerrit-)?bot:\h*(?:please\h+)?move\h+(?:back\h+)?to\h+(?:branch\h+)?([\w.\/-]*\w)\b/im) {
321 |         process_move($$update{'change'}, $$update{'author'}, $1);
322 |       }
323 |     }
324 |   }
325 | }
326 | close UPDATES;
327 | 


--------------------------------------------------------------------------------
/bin/git-qt-merge-mainlines:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | # -*- coding: utf-8 -*-
  3 | 
  4 | # Copyright (C) 2015 The Qt Company Ltd.
  5 | # Contact: http://www.qt.io/licensing/
  6 | #
  7 | # You may use this file under the terms of the 3-clause BSD license.
  8 | # See the file LICENSE from this package for details.
  9 | #
 10 | 
 11 | from __future__ import print_function
 12 | 
 13 | import os
 14 | import sys
 15 | import logging
 16 | import subprocess
 17 | import re
 18 | import warnings
 19 | 
 20 | fnull = open(os.devnull, "w")
 21 | 
 22 | class colors:
 23 |     HEADER = '\033[95m'
 24 |     BLUE = '\033[94m'
 25 |     GREEN = '\033[92m'
 26 |     WARNING = '\033[93m'
 27 |     FAIL = '\033[91m'
 28 |     ENDC = '\033[0m'
 29 | 
 30 | class BlameParser:
 31 |     __begin = ('<' * 7, '=' * 7)
 32 |     __end_map = {'merge': '=', 'diff3': '|'}
 33 |     # One example line to parse (result from git blame -c --date=short):
 34 |     # "ddd8ab31	(Andras Becsi	2014-06-13 18:17:07 +0200	414)bool GLSurface::InitializeOneOffInternal()"
 35 |     __matcher = re.compile(r"([0-9a-f]+)\s+\((.*?)\s+\d+\)(.*)").match
 36 | 
 37 |     def __init__(self):
 38 |         self.__end = (self.__from_git_config('merge.conflictstyle', 'merge', self.__end_map) * 7, '>' * 7)
 39 | 
 40 |     def __from_git_config(self, parameter, default, mapping):
 41 |         try:
 42 |             value = subprocess.check_output(['git', 'config', parameter]).decode('utf-8').strip()
 43 |         except subprocess.CalledProcessError:
 44 |             # When the value is unset
 45 |             value = ''
 46 |         try:
 47 |             return mapping[value or default]
 48 |         except KeyError:
 49 |             raise ValueError('Unknown git config', parameter, value)
 50 | 
 51 |     def __parse_blame_line(self, codeline):
 52 |         # Match a "git blame -c --date=short" output line
 53 |         m = self.__matcher(codeline)
 54 |         if m:
 55 |             return m.group(1, 2, 3)
 56 |         raise ValueError("Failed to parse blame line: %s" % (codeline))
 57 | 
 58 |     def __get_blame_results(self, conflict):
 59 |         cmd_git_blame = ["git", "blame", "-c", "--date=short", conflict]
 60 |         blame_output = subprocess.check_output(cmd_git_blame).decode('utf-8')
 61 |         return blame_output.split('\n')
 62 | 
 63 |     def parse(self, conflict):
 64 |         results, scan = {}, False
 65 |         for line in self.__get_blame_results(conflict):
 66 |             if not line.strip():
 67 |                 continue
 68 |             sha1, info, code = self.__parse_blame_line(line)
 69 |             if any(code.startswith(b) for b in self.__begin):
 70 |                 scan = True
 71 |                 continue
 72 |             if any(code.startswith(e) for e in self.__end):
 73 |                 scan = False
 74 |             if scan:
 75 |                 results[sha1] = info
 76 | 
 77 |         return results.items()
 78 | 
 79 | # Try to find related commits for the conflicts
 80 | def check_conflicts(module, config, from_ref, conflicts):
 81 |     results = ''
 82 |     blameparser = BlameParser()
 83 |     for conflict in conflicts:
 84 |         changes = blameparser.parse(conflict)
 85 |         results += conflict + ':\n\t' + '\n\t'.join('%s %s' %c for c in changes) + '\n'
 86 |     return results
 87 | 
 88 | # Replace all occurrences of searchExp in one file
 89 | def replaceInFile(file, searchExp, replaceExp):
 90 |     import fileinput
 91 |     for line in fileinput.input(file, inplace=1):
 92 |         line = re.sub(searchExp, replaceExp, line)
 93 |         sys.stdout.write(line)
 94 | 
 95 | # Reset module to destination branch
 96 | def reset_module(module, config):
 97 |     opts = {}
 98 |     opts['to'] = config.branch_to
 99 |     try:
100 |         git_checkout = "git checkout %(to)s" %opts
101 |         subprocess.check_call(git_checkout.split(), stdout=fnull)
102 |         git_reset = "git reset --hard origin/%(to)s" %opts
103 |         subprocess.check_call(git_reset.split(), stdout=fnull, stderr=fnull)
104 |     except Exception as e:
105 |         logging.error("Git reset failed: %s", str(e))
106 |         return False
107 |     return True
108 | 
109 | # Run git merge for one module
110 | def do_merge(module, config, from_ref):
111 |     try:
112 |         cmd_git_merge = ["git", "merge", "-m", \
113 |                          "Merge remote-tracking branch \'origin/" + config.branch_from + "\' into " + config.branch_to, \
114 |                          from_ref, "--no-edit", "--no-ff"]
115 |         ret = subprocess.call(cmd_git_merge, stdout=fnull)
116 |         if ret != 0 and config.mergetool:
117 |             print("Starting mergetool")
118 |             ret = subprocess.call(['git', 'mergetool', '-y'])
119 |             if ret == 0:
120 |                 ret = subprocess.call(['git', 'commit', '--no-edit'], stdout=fnull)
121 |         if ret != 0:
122 |             print("Module %s failed to merge, manual merge needed." % module)
123 |             return False
124 | 
125 |         # Make sure we get a change-id as git merge doesn't generate it for us
126 |         git_amend = "git commit --amend --no-edit"
127 |         subprocess.check_call(git_amend.split(), stdout=fnull)
128 | 
129 |     except Exception as e:
130 |         logging.error("Merge failed: %s", str(e))
131 |         return False
132 | 
133 |     return True
134 | 
135 | def wip_merge(module, config, from_ref):
136 |     conflicts = []
137 |     try:
138 |         cmd_git_status = ["git", "status", "--porcelain"]
139 |         status_output = subprocess.check_output(cmd_git_status).decode('utf-8').strip()
140 |         status_count = 0
141 |         if status_output:
142 |             lines = status_output.split('\n')
143 |             status_count = len(lines)
144 | 
145 |             for line in lines:
146 |                 try: mode, file = line.split()
147 |                 except (ValueError, TypeError): pass # not exactly two tokens
148 |                 else:
149 |                     if 'U' in mode:
150 |                         print("conflict: ", file)
151 |                         conflicts.append(file)
152 | 
153 |         if not conflicts:
154 |             print("Didn't find any conflict. Need to check carefully.")
155 |             return False
156 | 
157 |         cmd_git_commit = ["git", "commit", "-a", "-m",
158 |                           "WIP: Merge remote-tracking branch \'origin/" + config.branch_from + "\' into " + config.branch_to + "\n"
159 |                           + '\nConflicts:\n\t' + '\n\t'.join(conflicts) + '\n']
160 |         ret = subprocess.call(cmd_git_commit, stdout=fnull)
161 |         if ret != 0:
162 |             print("Failed to do \"git commit -a\".")
163 |             return False
164 | 
165 |         # Make sure we get a change-id as git merge doesn't generate it for us
166 |         git_amend = "git commit --amend --no-edit"
167 |         subprocess.check_call(git_amend.split(), stdout=fnull)
168 | 
169 |         related = check_conflicts(module, config, from_ref, conflicts)
170 |         print("Related: ", related)
171 | 
172 |     except Exception as e:
173 |         logging.error("Create WIP change failed: %s", str(e))
174 |         return False
175 | 
176 |     return True
177 | 
178 | # Change the version number in the .qmake.conf file to a given string
179 | def update_qmake_conf(module, version):
180 |     fileName = ".qmake.conf"
181 |     replaceInFile(fileName, "5\..\..", version)
182 |     cmd_git_status = "git status".split()
183 | 
184 |     status = subprocess.check_output(cmd_git_status).decode('utf-8')
185 |     print(status)
186 |     if status.find(fileName) < 0:
187 |         return False
188 | 
189 |     cmd_git_add = "git add .qmake.conf".split()
190 |     subprocess.check_call(cmd_git_add, stdout=fnull)
191 |     cmd_git_commit = ['git', 'commit', '-m', 'Update module version to %s' % version]
192 |     subprocess.check_call(cmd_git_commit, stdout=fnull)
193 |     return True
194 | 
195 | # Run git push to the destination branch for one module
196 | def push_gerrit(module, config):
197 |     subprocess.call(["git", "show"])
198 |     print('\n"%s" was successfully updated and merged' % module)
199 |     # fix for python 2.x compatibility
200 |     try: input = raw_input
201 |     except NameError: pass
202 |     confirm = input('Push merge? [Y/n] ')
203 |     if not confirm or confirm.startswith(('y', 'Y')):
204 |         output = subprocess.check_output(('git push gerrit HEAD:refs/for/%s' % config.branch_to).split()).decode('utf-8')
205 |         #url = re.search("https.*", output).group(0).strip()
206 |         #print(url)
207 | 
208 |         #GERRIT_CHANGE_ID=$(echo "$GIT_PUSH" | sed 's/.*https:\/\/codereview.qt-project.org\/\(.*\)/\;tx;d;:x')
209 |         #echo "ChangeId: $GERRIT_CHANGE_ID"
210 |         # if we had gerrit 2.4, we could do this:
211 |         #for reviewer in
212 |         #   sh codereview.qt-project.org gerrit set-reviewers --add jedrzej.nowacki@digia.com 49938
213 | 
214 |     else:
215 |         print(colors.WARNING + "Merge not pushed." + colors.ENDC)
216 | 
217 | # Perform merge and push it for one module
218 | def merge(module, config, from_ref):
219 |     push_required = False
220 |     if config.merge or config.wip:
221 |         if not do_merge(module, config, from_ref):
222 |             return False
223 |         push_required = True
224 | 
225 |     if config.version:
226 |         print('Updating .qmake.conf for', module)
227 |         if update_qmake_conf(module, config.version):
228 |             push_required = True
229 | 
230 |     if push_required:
231 |         push_gerrit(module, config)
232 |     return True
233 | 
234 | # Create WIP change when having conflicts
235 | def create_wip(module, config, from_ref):
236 |     if config.wip:
237 |         if not wip_merge(module, config, from_ref):
238 |             return False
239 | 
240 |         push_gerrit(module, config)
241 | 
242 |     return True
243 | 
244 | def get_module_sha_from_super(module, branch):
245 |     result = ""
246 |     cmd_git_lstree = ["git", "ls-tree", "origin/" + branch, module]
247 |     lstree_output = subprocess.check_output(cmd_git_lstree).decode('utf-8').strip()
248 |     lstree_outputs = lstree_output.split()
249 |     if len(lstree_outputs) == 4 and lstree_outputs[3] == module:
250 |         result = lstree_outputs[2].strip()
251 |     return result
252 | 
253 | # Iterate over all modules (either default or passed with -m option)
254 | def process_modules(config):
255 |     if config.list_modules:
256 |         print("Modules: ", config.modules)
257 |         return
258 | 
259 |     cmd_git_fetch = ["git", "fetch"]
260 |     subprocess.check_call(cmd_git_fetch, stdout=fnull, stderr=fnull)
261 | 
262 |     manual_merges = []
263 | 
264 |     for module in config.modules.split():
265 |         print("\nModule: " + colors.GREEN + module + colors.ENDC)
266 |         if not os.path.isdir(module):
267 |             print("Directory '%s' does not exist. Skipping..." % module)
268 |             continue
269 |         try:
270 |             os.chdir(module)
271 |             try:
272 |                 cmd_git_fetch = ["git", "fetch"]
273 |                 subprocess.check_call(cmd_git_fetch, stdout=fnull, stderr=fnull)
274 | 
275 |                 to_string = "origin/" + config.branch_to
276 |                 from_string = "origin/" + config.branch_from
277 | 
278 |                 if config.super:
279 |                     os.chdir("..")
280 |                     from_sha1 = get_module_sha_from_super(module, config.branch_from)
281 |                     if from_sha1:
282 |                         from_string = from_sha1
283 |                     else:
284 |                         print("Unable to obtain sha1 from super module for module ", module, "\n")
285 |                     os.chdir(module)
286 | 
287 |                 print("Merge from", from_string, "to", to_string, ":")
288 |                 cmd_git_cherry = ["git", "cherry", to_string, from_string, "-v"]
289 |                 cherry_output = subprocess.check_output(cmd_git_cherry).decode('utf-8').strip()
290 | 
291 |                 change_count = 0
292 |                 if cherry_output:
293 |                     change_count = len(cherry_output.split('\n'))
294 | 
295 |                 if config.status:
296 |                     print(cherry_output)
297 |                     print(colors.GREEN, change_count, colors.ENDC, "patches to be merged in", module, "\n")
298 | 
299 |                 if config.reset or config.merge or config.version or config.wip:
300 |                     reset_module(module, config)
301 | 
302 |                 if change_count > 0:
303 |                     if not merge(module, config, from_string):
304 |                         manual_merges.append(module)
305 |                         if config.wip:
306 |                             create_wip(module, config, from_string)
307 | 
308 |             except Exception as e:
309 |                 logging.error("Command execution failed: %s", str(e))
310 |                 import traceback
311 |                 traceback.print_exc(file=sys.stdout)
312 |             finally:
313 |                 os.chdir("..")
314 | 
315 |         except Exception as e:
316 |             logging.error("Changing current dir failed: %s", str(e))
317 |             import traceback
318 |             traceback.print_exc(file=sys.stdout)
319 | 
320 |     if manual_merges:
321 |         print("Modules failed to merge: ", manual_merges)
322 | 
323 | # get a list of submodules and a list of submodules that are not checked out
324 | def get_submodules():
325 |     git_submodule_status = subprocess.check_output('git submodule status'.split(' ')).strip()
326 |     modules = []
327 |     modules_not_checked_out = []
328 |     for line in git_submodule_status.split('\n'):
329 |         module = line.strip().split(' ')[1]
330 |         if line.startswith('-'):
331 |             modules_not_checked_out.append(module)
332 |             print('WARNING:', module, 'is not checked out')
333 |         elif module in ('qtqa', 'qtrepotools'):
334 |             print('skipping', module)
335 |         else:
336 |             modules.append(module)
337 |     return modules, modules_not_checked_out
338 | 
339 | 
340 | if __name__== "__main__":
341 |     import argparse
342 |     parser = argparse.ArgumentParser(prog="git-qt-merge-branches",
343 |         description="Merge branches for the Qt Project",
344 |         epilog="""
345 | 
346 | Run from within a work tree of the qt5 super-module, with all relevant
347 | sub-modules checked out (e.g. using qt5/init-repository).
348 | """)
349 |     group = parser.add_argument_group("Primary action", "Chose one of:")
350 |     group.add_argument('-s', '--status', action="store_true",
351 |                        help='show the status (which patches will be merged)')
352 |     group.add_argument('-d', '--merge', action="store_true",
353 |                        help='do the merge')
354 |     parser.add_argument('-u', '--super', action="store_true",
355 |                         help='obtain sha1s from supermodule instead of using branch tips')
356 |     parser.add_argument('-m', '--modules',
357 |                         help='override the list of modules (eg. -m "qtbase qtdeclarative")')
358 |     group.add_argument('-l', '--list-modules', action="store_true",
359 |                        help='list the modules to be merged and exit')
360 |     group.add_argument('--reset', action="store_true",
361 |                        help='reset to origin/to_branch. this is implicit in the merge command')
362 |     parser.add_argument('-f', '--branch-from', default='stable',
363 |                         help='from which branch to merge')
364 |     parser.add_argument('-t', '--branch-to', default='dev',
365 |                         help='the target branch')
366 |     group.add_argument('-v', '--version', default='',
367 |                        help='set version in .qmake.conf to given version string')
368 |     parser.add_argument('--mergetool', action="store_true",
369 |                         help='run mergetool for conflicts')
370 |     parser.add_argument('-w', '--wip', action="store_true",
371 |                         help='create WIP change when conflicts arise')
372 |     config = parser.parse_args()
373 | 
374 |     print("Qt Project merge tool\n")
375 |     default_modules, modules_not_checked_out = get_submodules()
376 |     if config.modules is None:
377 |         config.modules = ' '.join(default_modules)
378 |     print("Submodules: ", default_modules)
379 |     print("Ignored submodules: ", modules_not_checked_out)
380 | 
381 |     logging.basicConfig(format='%(levelname)s: %(message)s')
382 | 
383 |     if config.status or config.merge or config.reset or config.list_modules or config.version or config.wip:
384 |         process_modules(config)
385 |     else:
386 |         parser.print_help()
387 |     print("Submodules that are not checked out and are ignored:\n",
388 |           ' '.join(modules_not_checked_out))
389 | 


--------------------------------------------------------------------------------
/bin/git-ggc:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | # Copyright (C) 2018 The Qt Company Ltd.
  3 | # Contact: http://www.qt.io/licensing/
  4 | #
  5 | # You may use this file under the terms of the 3-clause BSD license.
  6 | # See the file LICENSE from this package for details.
  7 | #
  8 | 
  9 | use v5.14;
 10 | use strict;
 11 | use warnings;
 12 | no warnings qw(io);
 13 | 
 14 | our ($script, $script_path);
 15 | BEGIN {
 16 |     use Cwd qw(abs_path);
 17 |     if ($^O eq "msys") {
 18 |         $0 =~ s,\\,/,g;
 19 |         $0 =~ s,^(.):/,/$1/,g;
 20 |     }
 21 |     $script_path = $script = abs_path($0);
 22 |     $script_path =~ s,/[^/]+$,,;
 23 |     unshift @INC, $script_path;
 24 | }
 25 | use git_gpush;
 26 | 
 27 | use JSON;
 28 | 
 29 | sub usage()
 30 | {
 31 |     print << "EOM";
 32 | Usage:
 33 |     git ggc [options]
 34 | 
 35 |     This program cleans up state from git-gpush that became stale due
 36 |     to local Changes disappearing (most likely being upstreamed).
 37 | 
 38 |     You should use git-gpull instead of 'git pull --rebase', to make
 39 |     sure that git-ggc is called at regular intervals (default 30 days,
 40 |     configurable with gpush.gcInterval).
 41 | 
 42 |     The only recognized options are --help (-h, -?), --dry-run (-n),
 43 |     --verbose (-v), --quiet (-q), and --debug with the usual meanings
 44 |     (see git-gpush help).
 45 | 
 46 | Copyright:
 47 |     Copyright (C) 2018 The Qt Company Ltd.
 48 |     Contact: http://www.qt.io/licensing/
 49 | 
 50 | License:
 51 |     You may use this file under the terms of the 3-clause BSD license.
 52 | EOM
 53 | }
 54 | 
 55 | sub parse_arguments(@)
 56 | {
 57 |     while (scalar @_) {
 58 |         my $arg = shift @_;
 59 |         if ($arg eq "-v" || $arg eq "--verbose") {
 60 |             $verbose = 1;
 61 |         } elsif ($arg eq "-q" || $arg eq "--quiet") {
 62 |             $quiet = 1;
 63 |         } elsif ($arg eq "--debug") {
 64 |             $debug = 1;
 65 |             $verbose = 1;
 66 |         } elsif ($arg eq "-n" || $arg eq "--dry-run") {
 67 |             $dry_run = 1;
 68 |         } elsif ($arg eq "-?" || $arg eq "--?" || $arg eq "-h" || $arg eq "--help") {
 69 |             usage();
 70 |             exit;
 71 |         } else {
 72 |             fail("Unrecognized command line argument '$arg'.\n");
 73 |         }
 74 |     }
 75 |     fail("--quiet and --verbose/--debug are mutually exclusive.\n")
 76 |         if ($quiet && $verbose);
 77 | }
 78 | 
 79 | my %upstream_remotes;
 80 | 
 81 | sub get_gerrit_config()
 82 | {
 83 |     $remote = git_config('gpush.remote');
 84 |     # If a remote is specified, use exactly that one.
 85 |     if (!$remote) {
 86 |         # Otherwise try 'gerrit', and fall back to the origin.
 87 |         $remote = 'gerrit';
 88 |         if (!git_config('remote.'.$remote.'.url')) {
 89 |             my @remotes = keys %upstream_remotes;
 90 |             if (@remotes == 1) {
 91 |                 $remote = shift @remotes;
 92 |             } else {
 93 |                 $remote = git_config('gpush.upstream', 'origin');
 94 |                 werr("Notice: Upstream remote is ambiguous; defaulting to '$remote'.\n")
 95 |                     if (!$quiet);
 96 |             }
 97 |         }
 98 |     }
 99 |     set_gerrit_config($remote);
100 | }
101 | 
102 | sub visit_revs_pull(@)
103 | {
104 |     my %changeids;
105 |     my $log = open_cmd_pipe(USE_STDIN, 'git', 'log', '-z', '--pretty=%H%x00%B', '--stdin',
106 |                                        @upstream_excludes);
107 |     write_process($log, map { "$_\n" } @_);
108 |     while (read_fields($log, my ($id, $message))) {
109 |         $message =~ /^(.*)$/m;
110 |         my $subject = $1;
111 | 
112 |         # Gerrit uses the last Change-Id if multiple are present.
113 |         my @cids = ($message =~ /^Change-Id: (.+)$/mg);
114 |         next if (!@cids);
115 |         my $changeid = $cids[-1];
116 | 
117 |         print "-- $id: $subject\n" if ($debug);
118 | 
119 |         $changeids{$changeid} = 1;
120 |     }
121 |     close_process($log);
122 |     return \%changeids;
123 | }
124 | 
125 | # The garbage-collecting workhorse.
126 | # Note that we entirely ignore branches. A Change is assumed to be still
127 | # relevant if it exists on any local branch or exists in a non-terminal
128 | # state on Gerrit for any branch.
129 | sub perform_gc()
130 | {
131 |     my %kept_changes;  # { change-id => reason-string }
132 | 
133 |     print "Loading refs ...\n" if ($debug);
134 |     my %pushed;  # { sequence-number => sha1 }
135 |     my %pushed_inv;  # { sha1 => sequence-number }
136 |     my %zaps;  # { sequence-number => [ state-ref, ... ] }
137 |     my %fzaps;  # { gerrit-number => [ patchset-number => fetched-ref, ... ] }
138 |     my %visits;  # { sha1 => 1 }
139 |     my @local_refs;  # These define which Changes are still active.
140 |     my %remote_refs;  # Used for quickly validating upstreams.
141 |     my $branches = open_cmd_pipe(0, "git", "for-each-ref", "--format=%(objectname) %(refname)",
142 |                                     "refs/heads/", "refs/remotes/", "refs/gpush/");
143 |     while (read_process($branches)) {
144 |         if (s,^.{40} refs/remotes/,,) {
145 |             $remote_refs{$_} = 1;
146 |         } elsif (s,^.{40} refs/heads/,,) {
147 |             push @local_refs, $_;
148 |         } elsif (s,^(.{40}) refs/gpush/,,) {
149 |             my $sha1 = $1;
150 |             if (m,^i(\d+)_(.*)$,) {
151 |                 push @{$zaps{$1}}, $_;
152 |                 if ($2 eq "pushed") {
153 |                     $pushed{$1} = $sha1;
154 |                     # Collisions are possible here, but we want only the Change-Id
155 |                     # anyway, and that is inherently the same for all candidates.
156 |                     $pushed_inv{$sha1} = $1;
157 |                     $visits{$sha1} = 1;
158 |                 }
159 |             } elsif (m,^g(\d+)_(\d+)$,) {
160 |                 $fzaps{$1}[$2] = $_;
161 |                 $visits{$sha1} = 1;
162 |             } elsif (!m,^state(-new)?$,) {
163 |                 print "Keeping unrecognized '$_'.\n" if ($debug);
164 |             }
165 |         }
166 |     }
167 |     close_process($branches);
168 | 
169 |     my %upstream_refs;
170 |     foreach my $ref (@local_refs) {
171 |         my ($uprm, $upbr) = (git_config("branch.$ref.remote"), git_config("branch.$ref.merge"));
172 |         # Local WIP branches typically have no upstream.
173 |         next if (!$uprm || !$upbr);
174 |         $upbr =~ s,^refs/heads/,,;
175 |         my $upref = $uprm.'/'.$upbr;
176 |         # The upstream branch may have been pruned. Don't error out when this happens.
177 |         next if (!defined($remote_refs{$upref}));
178 |         # Note that multiple branches may have the same upstream.
179 |         $upstream_refs{$upref} = 1;
180 |         # Record which remotes are used as upstreams.
181 |         $upstream_remotes{$uprm} = 1;
182 |     }
183 |     @upstream_excludes = map { '^refs/remotes/'.$_ } keys %upstream_refs;
184 | 
185 |     # Changes which are on local branches are excluded from pruning. Obviously.
186 |     print "Visiting local branches ...\n" if ($debug);
187 |     my $local_changes = visit_revs_pull('HEAD', (map { 'refs/heads/'.$_ } @local_refs));
188 | 
189 |     print "Collecting locally present Changes ...\n" if ($debug);
190 |     my %push_hash;
191 |     foreach my $changeid (keys %changes_by_id) {
192 |         if (defined($$local_changes{$changeid})) {
193 |             $kept_changes{$changeid} = "exists locally";
194 |             $push_hash{$changeid} = 1;
195 | 
196 |             my $changes = $changes_by_id{$changeid};
197 |             foreach my $change (@$changes) {
198 |                 foreach my $tip ($$change{tip}, $$change{ptip}) {
199 |                     next if (!defined($tip));
200 |                     my $tip_chg = $change_by_key{$tip};
201 |                     next if (!defined($tip_chg));  # Not supposed to happen
202 |                     my $tipchgid = $$tip_chg{id};
203 |                     $kept_changes{$tipchgid} //= "is tip of push";
204 |                     $push_hash{$tipchgid} = 1;
205 |                 }
206 |             }
207 |         }
208 |     }
209 | 
210 |     print "Visiting pushed and fetched PatchSets ...\n" if ($debug);
211 |     visit_local_commits([ keys %visits ], 1);
212 | 
213 |     # Keep ancestors of pushed commits, so complete_pushed_series()
214 |     # in gpick does not need to re-fetch them.
215 |     # On the downside, this means that long closed Changes will be kept
216 |     # if the remaining part of their containing series is not rebased.
217 |     my @visit_push = sort keys %push_hash;
218 |     while (my $changeid = shift @visit_push) {
219 |         foreach my $change (@{$changes_by_id{$changeid}}) {
220 |             my $sha1 = $$change{pushed};
221 |             next if (!defined($sha1));
222 | 
223 |             my $commit = $commit_by_id{$sha1};
224 |             next if (!$commit);  # Not supposed to happen
225 | 
226 |             # We ignore push bases here, so chained series are treated
227 |             # as one. This is a feature ... sort of.
228 |             $sha1 = get_1st_parent($commit);
229 |             $commit = $commit_by_id{$sha1};
230 |             next if (!$commit);  # Hit upstream
231 | 
232 |             if ($mail_mode) {
233 |                 # In mail mode, the "pushed" commits have no Change-Ids.
234 |                 # Mail mode doesn't use minimal mode, so the lookup by
235 |                 # SHA1 should work reliably.
236 |                 my $key = $pushed_inv{$sha1};
237 |                 next if (!defined($key));  # Not supposed to happen
238 |                 my $chg = $change_by_key{$key};
239 |                 next if (!$chg);  # Not supposed to happen
240 |                 $changeid = $$chg{id};
241 |             } else {
242 |                 $changeid = $$commit{changeid};
243 |             }
244 | 
245 |             next if (defined($kept_changes{$changeid}));
246 |             $kept_changes{$changeid} = "part of push";
247 | 
248 |             push @visit_push, $changeid;
249 |         }
250 |     }
251 | 
252 |     # Even Changes which are absent from the local branch are pruned
253 |     # only if they are in a terminal state. Otherwise, there is reason
254 |     # to believe that they might be used again at a later point.
255 |     my %zap_ids = map { $_ => 1 }
256 |                   grep { !defined($kept_changes{$_}) }
257 |                   keys %changes_by_id;
258 |     if ((%zap_ids || %fzaps) && !$mail_mode) {
259 |         print "Querying Gerrit for prunable Changes ...\n" if ($debug);
260 |         get_gerrit_config();
261 |         my $ginfos = query_gerrit_only([ map { "change:".$_ } (keys %zap_ids, keys %fzaps) ]);
262 |         foreach my $ginfo (@$ginfos) {
263 |             my ($changeid, $status, $branch) =
264 |                     ($$ginfo{id}, $$ginfo{status}, $$ginfo{branch});
265 |             my $active = (($status ne 'MERGED') && ($status ne 'ABANDONED'));
266 |             print "$changeid is ".($active ? "" : "NOT ")."active on $branch.\n" if ($debug);
267 |             $kept_changes{$changeid} //= "active on Gerrit"
268 |                 if ($active);
269 |         }
270 |     }
271 | 
272 |     print "Pruning stale Changes ...\n" if ($debug);
273 |     foreach my $key (sort keys %change_by_key) {
274 |         my $change = $change_by_key{$key};
275 |         my $changeid = $$change{id};
276 |         my $reason = $kept_changes{$changeid};
277 |         if (defined($reason)) {
278 |             print "Keeping $key ($changeid): $reason.\n" if ($verbose);
279 |             delete $zaps{$key};
280 |         } else {
281 |             print "Pruning $key ($changeid).\n" if ($verbose);
282 |             $$change{garbage} = 1;
283 |         }
284 |     }
285 |     if ($verbose) {
286 |         foreach my $key (sort keys %zaps) {
287 |             # This is unlikely to ever trigger, as the regular load_refs()
288 |             # cleans up anyway.
289 |             print "Pruning $key (unrecognized Change).\n"
290 |                 if (!$change_by_key{$key});
291 |         }
292 |     }
293 | 
294 |     # Keep fetched PatchSets that correspond with kept Changes, but only the ones
295 |     # that are not older than the pushed revision of the Change. Older PatchSets
296 |     # are accessed only when explicitly picking an old state of the series, which
297 |     # is very rare, so it is not worth keeping these refs cached.
298 |     my (@visit_sha1s, %seen_sha1s, %chop_gs);
299 |     foreach my $key (sort keys %fzaps) {
300 |         my $ginfo = $gerrit_info_by_key{$key};
301 |         if (!defined($ginfo)) {
302 |             $chop_gs{$key} = -1;
303 |             next;
304 |         }
305 | 
306 |         my $changeid = $$ginfo{id};
307 |         if (!defined($kept_changes{$changeid})) {
308 |             # Might be still referenced recursively.
309 |             print "Might prune fetched $key ($changeid): corresponds with no kept Change.\n"
310 |                 if ($debug);
311 |             next;
312 |         }
313 | 
314 |         my $chgs = $changes_by_id{$changeid};
315 |         if (!$chgs) {
316 |             # Corresponding commits exist locally, but we never assigned them to Changes.
317 |             print "Might prune fetched $key ($changeid): corresponds with no tracked Change.\n"
318 |                 if ($debug);
319 |             next;
320 |         }
321 | 
322 |         my $revs = $$ginfo{revs};
323 |         my $mps = $$revs[-1]{ps};
324 |         # Subsequent sync-up attempts will fetch the current (and previous,
325 |         # for MERGED Changes) PatchSet, so keep that in every case.
326 |         my $kps = ($mps > 1 && ($$ginfo{status} eq "MERGED")) ? $mps - 1 : $mps;
327 |         foreach my $change (@$chgs) {
328 |             next if ($$change{garbage});
329 | 
330 |             my $sha1 = $pushed{$$change{key}};
331 |             # This Change was not gpushed/gpicked, and a possible sync-up failed.
332 |             next if (!defined($sha1));
333 | 
334 |             my $rev = $$ginfo{rev_by_id}{$sha1};
335 |             # A Change on a different branch owns this commit.
336 |             next if (!$rev);
337 | 
338 |             my $ps = $$rev{ps};
339 |             $kps = $ps if ($ps < $kps);
340 |         }
341 | 
342 |         # Note that this may include SHA1s that were not fetched.
343 |         push @visit_sha1s, map { $$_{id} } grep { $$_{ps} >= $kps } @$revs;
344 |         $chop_gs{$key} = $kps;
345 |     }
346 |     # Keep all fetched PatchSets that are ancestors of other kept
347 |     # PatchSets, recursively.
348 |     while (my $sha1 = shift @visit_sha1s) {
349 |         while (!defined($seen_sha1s{$sha1})) {
350 |             $seen_sha1s{$sha1} = 1;
351 | 
352 |             my $commit = $commit_by_id{$sha1};
353 |             last if (!$commit);  # Hit bottom of series, or initial commit was not fetched.
354 | 
355 |             # If the Change disappeared, then its fetched refs will be nuked anyway,
356 |             # and ancestors which are not in the initial set won't be accessed anymore.
357 |             my $ginfo = $gerrit_info_by_sha1{$sha1};
358 |             last if (!$ginfo);
359 | 
360 |             # Ancestry traversal may lead us to older PatchSets than those in the
361 |             # initial set, but assemble_series()' callbacks would upgrade from these
362 |             # anyway, so we can just stop here.
363 |             last if (defined($kept_changes{$$ginfo{id}}));
364 | 
365 |             my $ps = $$ginfo{rev_by_id}{$sha1};
366 |             last if (!defined($ps));  # Shouldn't happen.
367 | 
368 |             push @visit_sha1s, map { $$_{id} } grep { $$_{ps} >= $ps } @{$$ginfo{revs}};
369 |             my $key = $$ginfo{key};
370 |             my $ops = $chop_gs{$key};
371 |             $chop_gs{$key} = $ps if (!defined($ops) || $ops > $ps);
372 | 
373 |             $sha1 = get_1st_parent($commit);
374 |         }
375 |     }
376 |     foreach my $key (sort keys %fzaps) {
377 |         my $fzap = $fzaps{$key};
378 |         my $kps = $chop_gs{$key};
379 |         if (!defined($kps)) {
380 |             print "Pruning fetched $key (unused).\n" if ($verbose);
381 |         } elsif ($kps < 0) {
382 |             print "Pruning fetched $key (disappeared from Gerrit).\n" if ($verbose);
383 |         } else {
384 |             my $mps = $#$fzap;
385 |             print "Keeping fetched $key starting at $kps/$mps.\n" if ($verbose);
386 |             splice @$fzap, $kps;
387 |         }
388 |         $fzaps{$key} = [ grep { defined($_) } @$fzap ];
389 |     }
390 | 
391 |     # We completely bypass the regular state handling when it comes
392 |     # to refs, as we want to also prune refs in our namespace that
393 |     # don't correspond with known state keys.
394 |     update_refs(DRY_RUN, [
395 |         map { "delete refs/gpush/$_\n" } map { @$_ } (values %zaps, values %fzaps)
396 |     ]);
397 | }
398 | 
399 | parse_arguments(@ARGV);
400 | goto_gitdir();
401 | load_config();
402 | load_state_file();  # No load_state(), and thus no load_refs().
403 | perform_gc();
404 | $last_gc = time();
405 | save_state($dry_run);
406 | 


--------------------------------------------------------------------------------
/bin/ibmake.bat:
--------------------------------------------------------------------------------
  1 | @goto invoke_perl
  2 | 
  3 | #!/usr/bin/perl
  4 | 
  5 | # Copyright (C) 2015 The Qt Company Ltd.
  6 | # Contact: http://www.qt.io/licensing/
  7 | #
  8 | # You may use this file under the terms of the 3-clause BSD license.
  9 | # See the file LICENSE from this package for details.
 10 | #
 11 | 
 12 | # Use modules --------------------------------------------------------
 13 | use strict;
 14 | use File::Basename;
 15 | 
 16 | my $script_path = dirname($0);
 17 | $script_path =~ s=^/(.)/=\1:\\=;
 18 | $script_path =~ s=/=\\=g;
 19 | 
 20 | # Simplify program name, if it is a path.
 21 | my $orig_argv0 = $0; #save the old $0
 22 | $0 =~ s/.*(\\|\/)//;
 23 | 
 24 | my @targetProjects;
 25 | my @allPossibleTargetProjects;
 26 | my $compiler = "msvc"; # Default compiler
 27 | my $verbose = 0;
 28 | my $openMonitor = 0;
 29 | my $configuration = "";
 30 | my $lastTarget = "";
 31 | my $projectFile = "";
 32 | my $isSolution = 0;
 33 | my $passOnArguments = "";
 34 | my $lastKnownArgument = 0;
 35 | my $onlyShow = 0;
 36 | my $buildforks = 15;
 37 | 
 38 | sub usage {
 39 |     printf "Usage:\n";
 40 |     printf "$0 [project file <.pro, .sln/.vcproj, or .dsw/.dsp>] [projects in the .sln file] \n";
 41 |     printf "       [-j<n>] [[-c] configuration] [--monitor] [--help | -help]\n\n";
 42 | 
 43 |     printf "     By default, without any parameters, $0 will build the project or whole\n";
 44 |     printf "     solution in debug configuration. If no .sln or .vcproj file is found\n";
 45 |     printf "     in the current directory, the first .pro is generated, and its resulting\n";
 46 |     printf "     project file is used.\n\n";
 47 | 
 48 |     printf "     If a directory contains more than one project/solution file, you'll have\n";
 49 |     printf "     to specify the target. If a project/solution contains more than one\n";;
 50 |     printf "     configuration containing \"debug\", you'll have to specify the correct one.\n";
 51 |     printf "     (If the last 'project' on the commandline is either \"debug\" or \"release\"\n";
 52 |     printf "     it is assumed that you meant a configuration, so for these you don't need to\n";
 53 |     printf "     specify the '-c' option. For all others, you'll need the '-c' option)\n\n";
 54 | 
 55 |     printf "     Specifying a project within a solution file lets you build just a project\n";
 56 |     printf "     and its dependencies.\n\n";
 57 | 
 58 |     printf "     -j<n>            Sets the number of jobs for this build using the /MAXCPUS=<n>\n";
 59 |     printf "                      option for MSVC builds, and the -j<n> option for MinGW builds\n";
 60 |     printf "     --n              Show everthing that will be done, but don't actually do them\n";
 61 |     printf "     --monitor        Opens the build monitor, if not already open. (same as\n";
 62 |     printf "                      specifying /buildmonitor)\n";
 63 |     printf "     --help, -help    This help\n\n";
 64 | 
 65 |     printf "     Specifying any other option will simply pass the option on to the\n";
 66 |     printf "     buildconsole command, including any other arguments following an the last\n";
 67 |     printf "     known $0 option.\n\n";
 68 | 
 69 |     printf " Ex:\n";
 70 |     printf "     $0 release\n";
 71 |     printf "                  Builds the project / solution in release\n";
 72 |     printf "     $0 debug release\n";
 73 |     printf "                  Builds the \"debug\" project in a solution in release\n";
 74 |     printf "     $0 release debug\n";
 75 |     printf "                  Builds the \"release\" project in a solution in debug\n";
 76 |     printf "     $0 some_project.vcproj release\n";
 77 |     printf "                  Builds the \"some_project\" project in release\n";
 78 |     printf "     $0 some_project.vcproj -c profiled\n";
 79 |     printf "                  Builds the \"some_project\" project in profiled configuration\n";
 80 |     printf "     $0 some_big_project.sln test_app -c profiled\n";
 81 |     printf "                  Builds the \"test_app\" project (and its dependencies) in the\n";
 82 |     printf "                  \"some_big_project\" solution in profiled configuration\n";
 83 | 
 84 |     exit( 0 );
 85 | }
 86 | 
 87 | ######################################################################
 88 | # Syntax:  findFiles(dir, match, descend)
 89 | # Params:  dir, string, directory to search for name
 90 | #          match, string, regular expression to match in dir
 91 | #          descend, integer, 0 = non-recursive search
 92 | #                            1 = recurse search into subdirectories
 93 | #
 94 | # Purpose: Finds files matching a regular expression.
 95 | # Returns: List of matching files.
 96 | #
 97 | # Examples:
 98 | #   findFiles("/usr","\.cpp$",1)  - finds .cpp files in /usr and below
 99 | #   findFiles("/tmp","^#",0)      - finds #* files in /tmp
100 | ######################################################################
101 | sub findFiles {
102 |     my ($dir,$match,$descend) = @_;
103 |     my ($file,$p,@files);
104 |     local(*D);
105 |     $dir =~ s=\\=/=g;
106 |     ($dir eq "") && ($dir = ".");
107 |     if ( opendir(D,$dir) ) {
108 |         if ( $dir eq "." ) {
109 |             $dir = "";
110 |         } else {
111 |             ($dir =~ /\/$/) || ($dir .= "/");
112 |         }
113 |         foreach $file ( readdir(D) ) {
114 |             next if ( $file  =~ /^\.\.?$/ );
115 |             $p = $file;
116 |             ($file =~ /$match/) && (push @files, $p);
117 |             if ( $descend && -d $p && ! -l $p ) {
118 |                 push @files, &findFiles($p,$match,$descend);
119 |             }
120 |         }
121 |         closedir(D);
122 |     }
123 |     return @files;
124 | }
125 | 
126 | sub findProjectFile {
127 |     printf "Searching for sln/dsw files......";
128 |     my @filesFound = findFiles(".", "^.*\.(sln|dsw)\$", 0);
129 | 
130 |     if (scalar(@filesFound) == 0) {
131 |         printf "[none]\n";
132 |         printf "Searching for vcproj/dsp files...";
133 |         @filesFound = findFiles(".", "^.*\.(vcproj|dsp)\$", 0);
134 |     }
135 | 
136 |     if (scalar(@filesFound) == 0) {
137 |         printf "[none]\n";
138 |         printf "Searching for Makefiles files....";
139 |         @filesFound = findFiles(".", "^Makefile\$", 0);
140 |         foreach my $file (@filesFound) {
141 |             my @configs = findPossibleConfigurations($file, "", @targetProjects);
142 | 
143 |             # If the Makefile is for msvc, clear it, as we
144 |             # want to use MSVC projects for that compiler
145 |             @filesFound = () if ($compiler eq "msvc");
146 |         }
147 |     }
148 | 
149 |     if (scalar(@filesFound) == 0) {
150 |         printf "[none]\n";
151 |         printf "Searching for .pro files.........";
152 |         @filesFound = findFiles(".", "^.*\.pro\$", 0);
153 |     }
154 | 
155 |     if (scalar(@filesFound) == 0) {
156 |         printf "[error]\n";
157 |         printf "Found no possible project file! You can't build in this directory!\n";
158 |         exit(1);
159 |     }
160 | 
161 |     my $found = join(", ", @filesFound);
162 |     printf "[$found]\n";
163 |     if (scalar(@filesFound) > 1) {
164 |         printf "Too many possible project files! You have to specify the correct file!\n";
165 |         exit(2);
166 |     }
167 |     return pop @filesFound;
168 | }
169 | 
170 | sub findPossibleConfigurations {
171 |     my ($file, $conf, @prjs) = @_;
172 |     my @possibleConf;
173 | 
174 |     # Load contents of $file into $filecontents
175 |     open(I, "< " . $file) || die "Could not open $file for reading";
176 |     my @filecontents = <I>;
177 |     close I;
178 | 
179 |     # MSVC.NET Solution file -------
180 |     if ($file =~ /\.sln$/) {
181 |         my @confs = grep(/[ \t]*ConfigName\.\d+[ \t]+=.*$conf.*/i, @filecontents);
182 |         foreach (@confs) {
183 |             my $txt = $_;
184 |             $txt =~ s,^[^=]*=\s*(.*)\s*$,\1,;
185 |             $txt =~ tr/\r//d;
186 |             push @possibleConf, $txt;
187 |         }
188 | 
189 |         # 2005 version -------
190 |         my @confs = grep(/[ \t]*$conf\|\w+[ \t]+=.*$conf\|.*/i, @filecontents);
191 |         foreach (@confs) {
192 |             my $txt = $_;
193 |             $txt =~ s,^[^=]*=\s*(.*)\s*$,\1,;
194 |             $txt =~ tr/\r//d;
195 |             push @possibleConf, $txt;
196 |         }
197 | 
198 | 
199 |     # MSVC.NET Project file --------
200 |     } elsif ($file =~ /\.vcproj$/) {
201 |         # Resplit the file in XML elements instead
202 |         my $flatContents = join(" ", @filecontents);
203 |         $flatContents =~ s/[\r\n]//g;
204 |         $flatContents =~ s/\s\s+/ /g;
205 |         $flatContents =~ s/> />\n/g;
206 |         @filecontents = split(/\n/, $flatContents);
207 | 
208 |         my @confs = grep(/^<Configuration /i, @filecontents);
209 |         foreach (@confs) {
210 |             my $txt = $_;
211 |             $txt =~ s,^.*Name[^=]*=[^"]*"([^"]*).*,\1,;
212 |             $txt =~ tr/\r//d;
213 |             push @possibleConf, $txt if ($txt =~ /$conf/i);
214 |         }
215 | 
216 |     # MSVC Workspace file ----------
217 |     } elsif ($file =~ /\.dsw$/) {
218 |         # Get all potential target projects from Workspace
219 |         my @possiblePrjs = grep(/^Project:.*/i, @filecontents);
220 |         my @temp;
221 |         foreach (@possiblePrjs) {
222 |             my $txt = $_;
223 |             $txt =~ s/^Project: "([^"]*)"=(.*) - Package Owner.*[\n\r]*$/\1@@@\2/;
224 |             $txt =~ tr/\r//d;
225 |             push @temp, $txt;
226 |         }
227 |         @possiblePrjs = @temp;
228 | 
229 |         # Populate all the possible targets, used later for the "Targets: (all)" simplification
230 |         foreach (@possiblePrjs) {
231 |             my $txt = $_;
232 |             $txt =~ s/(.*)@@@.*/\1/;
233 |             $txt =~ tr/\r//d;
234 |             push @allPossibleTargetProjects, $txt;
235 |         }
236 | 
237 |         if (scalar(@targetProjects) == 0) {
238 |             # No projects were specified, so we'll go through and populate the list with all of them
239 |             foreach (@possiblePrjs) {
240 |                 my $txt = $_;
241 |                 $txt =~ s/(.*)@@@.*/\1/;
242 |                 $txt =~ tr/\r//d;
243 |                 push @targetProjects, $txt;
244 |             }
245 |         }
246 | 
247 |         # Go through every project file specified as target project, to check if they have any
248 |         # configuration which is ambiguous to the one specified. *puh*
249 |         my @dupConfs; # All possible subProject configurations will be stored here
250 |                       # Any dups will be removed later
251 |         foreach (@targetProjects) {
252 |             my $myTrgPrj = $_;
253 |             @temp = grep(/$myTrgPrj@@@.*/i, @possiblePrjs);
254 |             foreach (@temp) {
255 |                 my $temp_prj = $_;
256 |                 my $subFile = $temp_prj;
257 |                 $subFile =~ s/.*@@@(.*)/\1/;
258 |                 $subFile =~ tr/\r//d;
259 |                 push @dupConfs, findPossibleConfigurations($subFile, $conf, @targetProjects);
260 |             }
261 |         }
262 | 
263 |         # Removing dups
264 |         my %seen = ();
265 |         $seen{$_}++ foreach (@dupConfs);
266 | 
267 |         @possibleConf = keys %seen;
268 | 
269 | 
270 |     # MSVC Project file ------------
271 |     } elsif ($file =~ /\.dsp$/) {
272 |         #Remove everthing from "# Begin Target"
273 |         my $flatContents = join("@@@", @filecontents);
274 |         $flatContents =~ s/[\r\n]//g;
275 |         $flatContents =~ s/^(.*)# Begin Target.*$/\1/;
276 |         @filecontents = split(/@@@/, $flatContents);
277 | 
278 |         my @confs = grep(/.*"\$\(CFG\)" == .*$conf.*/i, @filecontents);
279 |         foreach (@confs) {
280 |             my $txt = $_;
281 |             $txt =~ s,.*"\$\(CFG\)" ==[^"]*".* - ([^"]*)"\s*$,\1,;
282 |             $txt =~ tr/\r//d;
283 |             push @possibleConf, $txt;
284 |         }
285 | 
286 | 
287 |     # Makefile ------------
288 |     } elsif ($file =~ /^Makefile$/) {
289 |         my @confs = grep(/^\S*: .*/, @filecontents);
290 |         foreach (@confs) {
291 |             my $txt = $_;
292 |             if ($txt =~ /win32-g\+\+/) {
293 |                 $compiler = "mingw";
294 |             } elsif ($txt =~ /win32-icc/) {
295 |                 $compiler = "icc";
296 |             } elsif ($txt =~ /win32-msvc/) {
297 |                 $compiler = "msvc";
298 |             }
299 |         }
300 |         #printf("Possible configs: '%s', Possible targets: '%s'\n", join("', '", @possibleConf), join("', '", @allPossibleTargetProjects));
301 |     }
302 |     return @possibleConf;
303 | }
304 | 
305 | while ( @ARGV ) {
306 |     my $arg = shift @ARGV;
307 | 
308 |     if ($lastKnownArgument) {
309 |         $passOnArguments .= "$arg ";
310 |     } elsif ( $arg =~ /^(-+|\/).*$/ ) {
311 |         # Commandlineoptions
312 |         if ( $arg eq "--help" or $arg eq "-help" ) {
313 |             usage;
314 |         } elsif ( $arg eq "--monitor" ) {
315 |             $openMonitor = 1;
316 |         } elsif ( $arg eq "--n" ) {
317 |             $onlyShow = 1;
318 |         } elsif ( $arg eq "--verbose" ) {
319 |             $verbose = 1;
320 |         } elsif ( $arg eq "-j" ) {
321 |             $buildforks = shift @ARGV;
322 |         } elsif ( $arg =~ /^-j/ ) {
323 |             $buildforks = $arg;
324 |             $buildforks =~ s/-j//;
325 |         } elsif ( $arg eq "-c" ) {
326 |             $configuration = shift @ARGV;
327 |             $configuration = "debug" if (!defined $configuration);
328 |         } else {
329 |             $passOnArguments .= "$arg ";
330 |             $lastKnownArgument = 1;
331 |         }
332 | 
333 |     } elsif ( $arg =~ /^.*\.(sln|dsw)/ ) {
334 |         $projectFile = $arg;
335 |         $isSolution = 1;
336 |     } elsif ( $arg =~ /^.*\.(vcproj|dsp)/ ) {
337 |         $projectFile = $arg;
338 |         $isSolution = 0;
339 |     } elsif ( $arg =~ /^Makefile.*/ ) {
340 |         $projectFile = $arg;
341 |     } else {
342 |         push @targetProjects, $arg;
343 |         $lastTarget = $arg;
344 |     }
345 | }
346 | 
347 | if ($projectFile eq "") {
348 |     $projectFile = findProjectFile;
349 |     if ($projectFile =~ /^.*\.pro/) {
350 |         printf "Running qmake on .pro file.......";
351 |         if($compiler eq "msvc") {
352 |             system("qmake $projectFile -tp vc");
353 |         }
354 |         else {
355 |             system("qmake $projectFile");
356 |         }
357 |         printf "[done]\n";
358 |         # Find the project file, after qmake'ing
359 |         $projectFile = findProjectFile;
360 |     }
361 | }
362 | 
363 | if ($configuration eq "" && $compiler eq "msvc") {
364 |     # Check if the last item in @targetProjects is either "debug" or "release", if so
365 |     # use that, and remove it from the stack.
366 |     if ($lastTarget eq "debug" || $lastTarget eq "release") {
367 |         $configuration = "$lastTarget";
368 |         pop @targetProjects;
369 |     } else {
370 |         $configuration = "debug";
371 |     }
372 | }
373 | 
374 | if ($compiler eq "msvc") {
375 |     my @fullConfigurationNames = findPossibleConfigurations($projectFile, $configuration, @targetProjects);
376 |     if (scalar @fullConfigurationNames == 0) {
377 |         printf "* No possible configuration matching your specification ($configuration).\n";
378 |         exit(4);
379 |     } elsif (scalar @fullConfigurationNames > 1
380 |              && scalar grep("^$configuration\$", @fullConfigurationNames) > 1) {
381 |         my $allConfs = join(", ", @fullConfigurationNames);
382 |         printf "* Too many possible configurations ($allConfs), so you have to specify one\n";
383 |         exit(3);
384 |     }
385 |     $configuration = pop @fullConfigurationNames;
386 | }
387 | my $projects = join(" ", @targetProjects);
388 | 
389 | printf "---\n";
390 | printf "Using IncrediBuild for $compiler building:\n";
391 | printf "    Project: $projectFile\n";
392 | if ($projects eq "" || $projects eq join(" ", @allPossibleTargetProjects)) {
393 |     printf "    Targets: (%s)\n", ($compiler eq "msvc") ? "all" : "first";
394 | } else {
395 |     printf "    Targets: $projects\n";
396 | }
397 | printf "         As: $configuration\n";
398 | printf "  Arguments: $passOnArguments\n";
399 | 
400 | # Check if Makefile
401 | #   Detect which compiler ($compiler)
402 | #   Use xgconsole
403 | 
404 | my $build_cmd;
405 | if ($compiler eq "msvc") {
406 |     # MSVC buildconsole command --------------------------------------------------------------------
407 |     my $prjComma = join(",", @targetProjects);
408 |     $build_cmd = "buildconsole ";
409 |     $build_cmd .= "$projectFile ";
410 |     $build_cmd .= "-PRJ=\"$prjComma\" " if ($projects ne "");
411 |     $build_cmd .= "-CFG=\"$configuration\" ";
412 |     $build_cmd .= "-MAXCPUS=$buildforks ";
413 |     $build_cmd .= "-OPENMONITOR " if ($openMonitor);
414 |     $build_cmd .= "-USEENV $passOnArguments";
415 | } else {
416 |     # Makefile xgconsole command -------------------------------------------------------------------
417 |     my $xgeprofile = $script_path;
418 |     $xgeprofile .= ($compiler eq "mingw") ? "\\mingw-xge-profile.xge" : "\\icc-xge-profile.xge";
419 |     $build_cmd = "xgconsole ";
420 |     $build_cmd .= "-OPENMONITOR " if ($openMonitor);
421 |     $build_cmd .= "-PROFILE=\"$xgeprofile\" ";
422 |     $build_cmd .= "-COMMAND=\"";
423 |     $build_cmd .= ($compiler eq "mingw") ? "mingw32-make" : "make";
424 |     $build_cmd .= " -j$buildforks";
425 |     $build_cmd .= " $projects" if ($projects ne "");
426 |     $build_cmd .= "\" $passOnArguments";
427 | }
428 | printf "  Build CMD: $build_cmd\n";
429 | printf "---\n";
430 | 
431 | if (!$onlyShow) {
432 |     system($build_cmd);
433 |     exit $? >> 8;
434 | }
435 | 
436 | __END__
437 | 
438 | :invoke_perl
439 | @perl -x %~f0 %*
440 | 


--------------------------------------------------------------------------------
/LICENSES/GPL-2.0-only.txt:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 2, June 1991
  3 | 
  4 |  Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
  5 |  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 |                             Preamble
 10 | 
 11 |   The licenses for most software are designed to take away your
 12 | freedom to share and change it.  By contrast, the GNU General Public
 13 | License is intended to guarantee your freedom to share and change free
 14 | software--to make sure the software is free for all its users.  This
 15 | General Public License applies to most of the Free Software
 16 | Foundation's software and to any other program whose authors commit to
 17 | using it.  (Some other Free Software Foundation software is covered by
 18 | the GNU Lesser General Public License instead.)  You can apply it to
 19 | your programs, too.
 20 | 
 21 |   When we speak of free software, we are referring to freedom, not
 22 | price.  Our General Public Licenses are designed to make sure that you
 23 | have the freedom to distribute copies of free software (and charge for
 24 | this service if you wish), that you receive source code or can get it
 25 | if you want it, that you can change the software or use pieces of it
 26 | in new free programs; and that you know you can do these things.
 27 | 
 28 |   To protect your rights, we need to make restrictions that forbid
 29 | anyone to deny you these rights or to ask you to surrender the rights.
 30 | These restrictions translate to certain responsibilities for you if you
 31 | distribute copies of the software, or if you modify it.
 32 | 
 33 |   For example, if you distribute copies of such a program, whether
 34 | gratis or for a fee, you must give the recipients all the rights that
 35 | you have.  You must make sure that they, too, receive or can get the
 36 | source code.  And you must show them these terms so they know their
 37 | rights.
 38 | 
 39 |   We protect your rights with two steps: (1) copyright the software, and
 40 | (2) offer you this license which gives you legal permission to copy,
 41 | distribute and/or modify the software.
 42 | 
 43 |   Also, for each author's protection and ours, we want to make certain
 44 | that everyone understands that there is no warranty for this free
 45 | software.  If the software is modified by someone else and passed on, we
 46 | want its recipients to know that what they have is not the original, so
 47 | that any problems introduced by others will not reflect on the original
 48 | authors' reputations.
 49 | 
 50 |   Finally, any free program is threatened constantly by software
 51 | patents.  We wish to avoid the danger that redistributors of a free
 52 | program will individually obtain patent licenses, in effect making the
 53 | program proprietary.  To prevent this, we have made it clear that any
 54 | patent must be licensed for everyone's free use or not licensed at all.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 |                     GNU GENERAL PUBLIC LICENSE
 60 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 61 | 
 62 |   0. This License applies to any program or other work which contains
 63 | a notice placed by the copyright holder saying it may be distributed
 64 | under the terms of this General Public License.  The "Program", below,
 65 | refers to any such program or work, and a "work based on the Program"
 66 | means either the Program or any derivative work under copyright law:
 67 | that is to say, a work containing the Program or a portion of it,
 68 | either verbatim or with modifications and/or translated into another
 69 | language.  (Hereinafter, translation is included without limitation in
 70 | the term "modification".)  Each licensee is addressed as "you".
 71 | 
 72 | Activities other than copying, distribution and modification are not
 73 | covered by this License; they are outside its scope.  The act of
 74 | running the Program is not restricted, and the output from the Program
 75 | is covered only if its contents constitute a work based on the
 76 | Program (independent of having been made by running the Program).
 77 | Whether that is true depends on what the Program does.
 78 | 
 79 |   1. You may copy and distribute verbatim copies of the Program's
 80 | source code as you receive it, in any medium, provided that you
 81 | conspicuously and appropriately publish on each copy an appropriate
 82 | copyright notice and disclaimer of warranty; keep intact all the
 83 | notices that refer to this License and to the absence of any warranty;
 84 | and give any other recipients of the Program a copy of this License
 85 | along with the Program.
 86 | 
 87 | You may charge a fee for the physical act of transferring a copy, and
 88 | you may at your option offer warranty protection in exchange for a fee.
 89 | 
 90 |   2. You may modify your copy or copies of the Program or any portion
 91 | of it, thus forming a work based on the Program, and copy and
 92 | distribute such modifications or work under the terms of Section 1
 93 | above, provided that you also meet all of these conditions:
 94 | 
 95 |     a) You must cause the modified files to carry prominent notices
 96 |     stating that you changed the files and the date of any change.
 97 | 
 98 |     b) You must cause any work that you distribute or publish, that in
 99 |     whole or in part contains or is derived from the Program or any
100 |     part thereof, to be licensed as a whole at no charge to all third
101 |     parties under the terms of this License.
102 | 
103 |     c) If the modified program normally reads commands interactively
104 |     when run, you must cause it, when started running for such
105 |     interactive use in the most ordinary way, to print or display an
106 |     announcement including an appropriate copyright notice and a
107 |     notice that there is no warranty (or else, saying that you provide
108 |     a warranty) and that users may redistribute the program under
109 |     these conditions, and telling the user how to view a copy of this
110 |     License.  (Exception: if the Program itself is interactive but
111 |     does not normally print such an announcement, your work based on
112 |     the Program is not required to print an announcement.)
113 | 
114 | These requirements apply to the modified work as a whole.  If
115 | identifiable sections of that work are not derived from the Program,
116 | and can be reasonably considered independent and separate works in
117 | themselves, then this License, and its terms, do not apply to those
118 | sections when you distribute them as separate works.  But when you
119 | distribute the same sections as part of a whole which is a work based
120 | on the Program, the distribution of the whole must be on the terms of
121 | this License, whose permissions for other licensees extend to the
122 | entire whole, and thus to each and every part regardless of who wrote it.
123 | 
124 | Thus, it is not the intent of this section to claim rights or contest
125 | your rights to work written entirely by you; rather, the intent is to
126 | exercise the right to control the distribution of derivative or
127 | collective works based on the Program.
128 | 
129 | In addition, mere aggregation of another work not based on the Program
130 | with the Program (or with a work based on the Program) on a volume of
131 | a storage or distribution medium does not bring the other work under
132 | the scope of this License.
133 | 
134 |   3. You may copy and distribute the Program (or a work based on it,
135 | under Section 2) in object code or executable form under the terms of
136 | Sections 1 and 2 above provided that you also do one of the following:
137 | 
138 |     a) Accompany it with the complete corresponding machine-readable
139 |     source code, which must be distributed under the terms of Sections
140 |     1 and 2 above on a medium customarily used for software interchange; or,
141 | 
142 |     b) Accompany it with a written offer, valid for at least three
143 |     years, to give any third party, for a charge no more than your
144 |     cost of physically performing source distribution, a complete
145 |     machine-readable copy of the corresponding source code, to be
146 |     distributed under the terms of Sections 1 and 2 above on a medium
147 |     customarily used for software interchange; or,
148 | 
149 |     c) Accompany it with the information you received as to the offer
150 |     to distribute corresponding source code.  (This alternative is
151 |     allowed only for noncommercial distribution and only if you
152 |     received the program in object code or executable form with such
153 |     an offer, in accord with Subsection b above.)
154 | 
155 | The source code for a work means the preferred form of the work for
156 | making modifications to it.  For an executable work, complete source
157 | code means all the source code for all modules it contains, plus any
158 | associated interface definition files, plus the scripts used to
159 | control compilation and installation of the executable.  However, as a
160 | special exception, the source code distributed need not include
161 | anything that is normally distributed (in either source or binary
162 | form) with the major components (compiler, kernel, and so on) of the
163 | operating system on which the executable runs, unless that component
164 | itself accompanies the executable.
165 | 
166 | If distribution of executable or object code is made by offering
167 | access to copy from a designated place, then offering equivalent
168 | access to copy the source code from the same place counts as
169 | distribution of the source code, even though third parties are not
170 | compelled to copy the source along with the object code.
171 | 
172 |   4. You may not copy, modify, sublicense, or distribute the Program
173 | except as expressly provided under this License.  Any attempt
174 | otherwise to copy, modify, sublicense or distribute the Program is
175 | void, and will automatically terminate your rights under this License.
176 | However, parties who have received copies, or rights, from you under
177 | this License will not have their licenses terminated so long as such
178 | parties remain in full compliance.
179 | 
180 |   5. You are not required to accept this License, since you have not
181 | signed it.  However, nothing else grants you permission to modify or
182 | distribute the Program or its derivative works.  These actions are
183 | prohibited by law if you do not accept this License.  Therefore, by
184 | modifying or distributing the Program (or any work based on the
185 | Program), you indicate your acceptance of this License to do so, and
186 | all its terms and conditions for copying, distributing or modifying
187 | the Program or works based on it.
188 | 
189 |   6. Each time you redistribute the Program (or any work based on the
190 | Program), the recipient automatically receives a license from the
191 | original licensor to copy, distribute or modify the Program subject to
192 | these terms and conditions.  You may not impose any further
193 | restrictions on the recipients' exercise of the rights granted herein.
194 | You are not responsible for enforcing compliance by third parties to
195 | this License.
196 | 
197 |   7. If, as a consequence of a court judgment or allegation of patent
198 | infringement or for any other reason (not limited to patent issues),
199 | conditions are imposed on you (whether by court order, agreement or
200 | otherwise) that contradict the conditions of this License, they do not
201 | excuse you from the conditions of this License.  If you cannot
202 | distribute so as to satisfy simultaneously your obligations under this
203 | License and any other pertinent obligations, then as a consequence you
204 | may not distribute the Program at all.  For example, if a patent
205 | license would not permit royalty-free redistribution of the Program by
206 | all those who receive copies directly or indirectly through you, then
207 | the only way you could satisfy both it and this License would be to
208 | refrain entirely from distribution of the Program.
209 | 
210 | If any portion of this section is held invalid or unenforceable under
211 | any particular circumstance, the balance of the section is intended to
212 | apply and the section as a whole is intended to apply in other
213 | circumstances.
214 | 
215 | It is not the purpose of this section to induce you to infringe any
216 | patents or other property right claims or to contest validity of any
217 | such claims; this section has the sole purpose of protecting the
218 | integrity of the free software distribution system, which is
219 | implemented by public license practices.  Many people have made
220 | generous contributions to the wide range of software distributed
221 | through that system in reliance on consistent application of that
222 | system; it is up to the author/donor to decide if he or she is willing
223 | to distribute software through any other system and a licensee cannot
224 | impose that choice.
225 | 
226 | This section is intended to make thoroughly clear what is believed to
227 | be a consequence of the rest of this License.
228 | 
229 |   8. If the distribution and/or use of the Program is restricted in
230 | certain countries either by patents or by copyrighted interfaces, the
231 | original copyright holder who places the Program under this License
232 | may add an explicit geographical distribution limitation excluding
233 | those countries, so that distribution is permitted only in or among
234 | countries not thus excluded.  In such case, this License incorporates
235 | the limitation as if written in the body of this License.
236 | 
237 |   9. The Free Software Foundation may publish revised and/or new versions
238 | of the General Public License from time to time.  Such new versions will
239 | be similar in spirit to the present version, but may differ in detail to
240 | address new problems or concerns.
241 | 
242 | Each version is given a distinguishing version number.  If the Program
243 | specifies a version number of this License which applies to it and "any
244 | later version", you have the option of following the terms and conditions
245 | either of that version or of any later version published by the Free
246 | Software Foundation.  If the Program does not specify a version number of
247 | this License, you may choose any version ever published by the Free Software
248 | Foundation.
249 | 
250 |   10. If you wish to incorporate parts of the Program into other free
251 | programs whose distribution conditions are different, write to the author
252 | to ask for permission.  For software which is copyrighted by the Free
253 | Software Foundation, write to the Free Software Foundation; we sometimes
254 | make exceptions for this.  Our decision will be guided by the two goals
255 | of preserving the free status of all derivatives of our free software and
256 | of promoting the sharing and reuse of software generally.
257 | 
258 |                             NO WARRANTY
259 | 
260 |   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
268 | REPAIR OR CORRECTION.
269 | 
270 |   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
278 | POSSIBILITY OF SUCH DAMAGES.
279 | 
280 |                      END OF TERMS AND CONDITIONS
281 | 
282 |             How to Apply These Terms to Your New Programs
283 | 
284 |   If you develop a new program, and you want it to be of the greatest
285 | possible use to the public, the best way to achieve this is to make it
286 | free software which everyone can redistribute and change under these terms.
287 | 
288 |   To do so, attach the following notices to the program.  It is safest
289 | to attach them to the start of each source file to most effectively
290 | convey the exclusion of warranty; and each file should have at least
291 | the "copyright" line and a pointer to where the full notice is found.
292 | 
293 |     <one line to give the program's name and a brief idea of what it does.>
294 |     Copyright (C) <year>  <name of author>
295 | 
296 |     This program is free software; you can redistribute it and/or modify
297 |     it under the terms of the GNU General Public License as published by
298 |     the Free Software Foundation; either version 2 of the License, or
299 |     (at your option) any later version.
300 | 
301 |     This program is distributed in the hope that it will be useful,
302 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
303 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
304 |     GNU General Public License for more details.
305 | 
306 |     You should have received a copy of the GNU General Public License along
307 |     with this program; if not, write to the Free Software Foundation, Inc.,
308 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
309 | 
310 | Also add information on how to contact you by electronic and paper mail.
311 | 
312 | If the program is interactive, make it output a short notice like this
313 | when it starts in an interactive mode:
314 | 
315 |     Gnomovision version 69, Copyright (C) year name of author
316 |     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317 |     This is free software, and you are welcome to redistribute it
318 |     under certain conditions; type `show c' for details.
319 | 
320 | The hypothetical commands `show w' and `show c' should show the appropriate
321 | parts of the General Public License.  Of course, the commands you use may
322 | be called something other than `show w' and `show c'; they could even be
323 | mouse-clicks or menu items--whatever suits your program.
324 | 
325 | You should also get your employer (if you work as a programmer) or your
326 | school, if any, to sign a "copyright disclaimer" for the program, if
327 | necessary.  Here is a sample; alter the names:
328 | 
329 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
330 |   `Gnomovision' (which makes passes at compilers) written by James Hacker.
331 | 
332 |   <signature of Ty Coon>, 1 April 1989
333 |   Ty Coon, President of Vice
334 | 
335 | This General Public License does not permit incorporating your program into
336 | proprietary programs.  If your program is a subroutine library, you may
337 | consider it more useful to permit linking proprietary applications with the
338 | library.  If this is what you want to do, use the GNU Lesser General
339 | Public License instead of this License.
340 | 


--------------------------------------------------------------------------------
/git-hooks/qdoc-bot:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | # -*- coding: utf-8 -*-
  3 | 
  4 | # Copyright (C) 2015 The Qt Company Ltd.
  5 | # Contact: http://www.qt.io/licensing/
  6 | #
  7 | # You may use this file under the terms of the 3-clause BSD license.
  8 | # See the file LICENSE from this package for details.
  9 | #
 10 | 
 11 | # Checkouts have to have the remote: origin codereview-bot:qt/qtbase.git
 12 | 
 13 | # Run with --dir and --addr
 14 | # python qdoc-bot.py --dir /home/USER/dev/qt-qdoc/ --addr codereview-bot
 15 | # --dir is where the sources are checked out
 16 | # --addr codereview-bot
 17 | # With .ssh/config:
 18 | # Host codereview-bot
 19 | #    Hostname codereview.qt-project.org
 20 | #    Port 29418
 21 | #    User qt_docbot
 22 | #    IdentityFile /home/USER/.ssh/docbot_id_rsa
 23 | 
 24 | 
 25 | 
 26 | import os
 27 | import subprocess
 28 | import sys
 29 | import logging
 30 | import re
 31 | 
 32 | config = None # configuration object, it is initialized in main and passed to every worker process created by multiprocessing.Pool
 33 | 
 34 | #{
 35 |     #"change": {
 36 |         #"branch": "2.6",
 37 |         #"id": "I765c9e165f9e7a5e0928401f5c5254397ad9be0b",
 38 |         #"number": "33424",
 39 |         #"owner": {
 40 |             #"email": "Friedemann.Kleint@nokia.com",
 41 |             #"name": "Friedemann Kleint"
 42 |         #},
 43 |         #"project": "qt-creator/qt-creator",
 44 |         #"subject": "WIP: CDB: Fix some dumpers.",
 45 |         #"url": "https://codereview.qt-project.org/33424"
 46 |         #},
 47 |     #"patchSet": {
 48 |         #"number": "1",
 49 |         #"ref": "refs/changes/24/33424/1",
 50 |         #"revision": "c4dd516729ff8f9b7cb1e13d9c8f09560cf2c078",
 51 |         #"uploader": {
 52 |             #"email": "Friedemann.Kleint@nokia.com",
 53 |             #"name": "Friedemann Kleint"
 54 |         #}
 55 |     #},
 56 |     #"type": "patchset-created",
 57 |     #"uploader": {
 58 |         #"email": "Friedemann.Kleint@nokia.com",
 59 |         #"name": "Friedemann Kleint"
 60 |     #}
 61 | #}
 62 | 
 63 | 
 64 | 
 65 | def pasteKDE(data):
 66 |     import httplib, urllib, json
 67 |     params = urllib.urlencode({'paste_data': data,
 68 |                                'paste_lang': 'text',
 69 |                                'api_submit': True,
 70 |                                'mode': 'json',
 71 |                                'paste_project':'Qt',
 72 |                                'paste_user': 'Qt Doc bot',
 73 |                                'paste_private': 'yes',
 74 |                                'paste_expire': 2629744 # around 1 month
 75 |                               })
 76 |     headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}
 77 |     conn = httplib.HTTPConnection("paste.kde.org")
 78 |     try:
 79 |         conn.request("POST", "", params, headers)
 80 |         response = json.loads(conn.getresponse().read())
 81 |         logging.debug("Making a paste %s", response)
 82 |         return "http://pastebin.kde.org/" + str(response['result']['id']) + "/" + str(response['result']['hash'])
 83 |     finally:
 84 |         conn.close()
 85 | 
 86 | #make sub-qdoc in src/tools
 87 | def run_qdoc(module_name):
 88 |     output = []
 89 |     try:
 90 |         environment = os.environ
 91 |         environment["CCACHE_BASEDIR"] =  os.getcwd()
 92 |         environment["QT_HASH_SEED"] = "1234"
 93 |         environment["QMAKEFLAGS"] = "CONFIG+=force_bootstrap"
 94 |         for cmd in ["/bin/sh ./configure --opensource --confirm-license --release".split()
 95 |                    , "make sub-src-qmake_all".split()
 96 |                    , ["/bin/sh", "-c", "if [ -f src/tools/Makefile ] ; then make -Csrc/tools sub-qdoc; else make -Csrc sub-qdoc ; fi"] # build qdoc
 97 |                    ]:
 98 |             logging.debug("Executing command: %s", cmd)
 99 |             try:
100 |                 proc = subprocess.Popen(cmd, env=environment, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
101 |                 buildOutput = proc.communicate()[0]
102 |             except Exception, e:
103 |                 logging.error("Unknown error. Command execution failed: %s", str(e))
104 |                 raise e
105 | 
106 |             if proc.returncode:
107 |                 raise subprocess.CalledProcessError(proc.returncode, cmd, buildOutput)
108 | 
109 |         cmd = "make html_docs".split()
110 |         output.append(subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=environment).communicate()[1])
111 |         def smart_concatenate(r, x):
112 |             # concatenate multi-line comments
113 |             if x.startswith("    ["):
114 |                 r[-1] = r[-1] + x  # add comment
115 |             else:
116 |                 r.append(x)        # new error
117 |             return r
118 |         output[-1] = reduce(smart_concatenate, output[-1].split('\n'), [])
119 |         output[-1].sort()
120 |         output[-1] = "\n".join(output[-1])
121 |     except KeyError:
122 |         pass
123 |     return "\n".join(output)
124 | 
125 | #ssh codereview.qt-project.org gerrit review --project qt/qtbase --message "hello" 33219,44
126 | def post_review(event, message, score):
127 |     project = event["change"]["project"]
128 |     sha1 = event["patchSet"]["revision"]
129 |     command = ["ssh", config.gerrit_address, "gerrit", "review", "--project", project,
130 |                "--code-review", str(score), "--tag", "autogenerated:qdoc"]
131 |     if len(message) > 0:
132 |         command += "--message", "\"" + message + "\"",
133 |     command += sha1,
134 |     logging.debug(command)
135 |     if not config.sandbox:
136 |         subprocess.check_call(command)
137 |     elif event["change"]["number"] == '48230':
138 |         subprocess.check_call(command)
139 | 
140 | def remove_moved_doc_errors(fixes, errors):
141 |     for fix in fixes:
142 |         pos = fix.find(":")
143 |         if pos >= 0:
144 |             begin = "+" + fix[1:pos]
145 |             end = fix[fix.find(":", pos+1):]
146 |             logging.debug(end)
147 |             for i in range(len(errors)):
148 |                 if errors[i].startswith(begin) and errors[i].endswith(end):
149 |                     del errors[i]
150 |                     break;
151 |     message = ""
152 |     for line in errors:
153 |         message += line + "\n "
154 |     return message
155 | 
156 | def review_output(event, output_no_patch, output_with_patch, score_on_negative_review):
157 |     try:
158 |         import difflib
159 |         project = event["change"]["project"]
160 |         patch_set = event["patchSet"]
161 |         url = event["change"]["url"]
162 |         subject = event["change"]["subject"]
163 |         new_error_count = output_with_patch.count("\n") - output_no_patch.count("\n")
164 |         if new_error_count == 0:
165 |             logging.info("NO DOC ERRORS: %s, %s", subject, url)
166 |             #post_review(event, "", 1)
167 |             return 0
168 |         logging.debug("DIFF for %s: %s", subject, url)
169 |         message = ""
170 |         score = 0
171 |         if new_error_count == 1:
172 |             message += "This change introduces one new documentation error."
173 |             score = score_on_negative_review
174 |         elif new_error_count > 1:
175 |             message += "This change introduces " + str(new_error_count) + " new documentation errors."
176 |             score = score_on_negative_review
177 |         elif new_error_count == -1:
178 |             message += "This change removes a documentation error. Thank you!"
179 |             score = 0
180 |         else:
181 |             message = "This change removes " + str(abs(new_error_count)) + " documentation errors. Thank you!"
182 |             score = 0
183 | 
184 |         message += "\n\n "
185 |         fixes = []
186 |         errors = []
187 |         line_count = 0
188 |         for line in difflib.unified_diff(output_no_patch.split('\n'), output_with_patch.split('\n'), fromfile='before', tofile='after', n=0):
189 |             line_count += 1
190 |             if line_count > 2:
191 |                 if line[0] == "-":
192 |                     fixes.append(line)
193 |                 elif line[0] == "+":
194 |                     errors.append(line)
195 |         new_errors = remove_moved_doc_errors(fixes, errors)
196 |         if len(new_errors) > 0:
197 |             message += "New qdoc warnings:\n \n "
198 |             message += new_errors
199 |         message += "\n\nThis comment was generated by the qtdoc bot.\n\nPlease contact Jedrzej Nowacki (nierob) or Frederik Gladhorn (fregl) if you have questions or think the script gives you false positives."
200 |         logging.debug("Review result: %s", message)
201 |         post_review(event, message, score)
202 |         return score
203 |     except:
204 |         logging.error("Unexpected error: %s", sys.exc_info())
205 | 
206 | 
207 | def fetch_change(project, patch_set, change_number):
208 |     try:
209 |         gerrit_url = config.gerrit_address + ":" + project
210 |         # the mainlines need to be updated, so that we keep the updated refs and fetches don't start from scratch every time
211 |         mainlines = subprocess.check_output(["git", "config", "remote.origin.fetch"]).rstrip()
212 |         fetch_cmd = ["git", "fetch", "-f", "origin", patch_set["ref"]+":refs/changes/"+change_number, mainlines]
213 |         num_tries = 0
214 |         while True:
215 |             try:
216 |                 p = subprocess.check_call(fetch_cmd)
217 |                 return 0
218 | 
219 |             except subprocess.CalledProcessError, e:
220 |                 # Try to fetch again - one problem is that running git fetch will fail if run simultaneously
221 |                 num_tries += 1
222 |                 logging.warn("Fetching subprocess failed, trying again: %s", e)
223 |                 import time
224 |                 time.sleep(30)
225 |                 if num_tries > 11:
226 |                     raise e
227 | 
228 |     except subprocess.CalledProcessError, e:
229 |         logging.error("Fetching subprocess failed too many times: %s", e)
230 |         return -1
231 | 
232 | 
233 | #git fetch https://codereview.qt-project.org/p/qt/qtbase refs/changes/46/32446/6 && git checkout FETCH_HEAD
234 | def process_event(event_string):
235 |     # load the event data
236 |     import time
237 |     start_time = time.time()
238 |     import json
239 |     import tempfile
240 |     import shutil
241 | 
242 |     try:
243 |         event = json.loads(event_string)
244 |     except ValueError, e:
245 |         logging.error("JSON loading problem: %s\nJSON data: %s", e, event_string)
246 |         return -1
247 | 
248 |     if event["type"] != "patchset-created":
249 |         return 0
250 | 
251 |     # go to the right project checkout
252 |     project = event["change"]["project"]
253 |     patch_set = event["patchSet"]
254 |     change_number = event["change"]["number"]
255 | 
256 |     module_name = project.split('/')[-1]
257 |     if module_name not in ["qtbase"]: # TODO for now we care only about qtbase
258 |         logging.info("IGNORED MODULE: %s %s", module_name, patch_set)
259 |         return 0
260 | 
261 |     logging.info("MODULE NAME: %s %s", module_name, patch_set)
262 | 
263 |     source_path = config.watcher_working_dir + "/" + project
264 |     try:
265 |         os.chdir(source_path)
266 |     except OSError, e:
267 |         logging.info("Unknown project: %s, trying to clone it", project)
268 |         tmp_dir = tempfile.mkdtemp(prefix="qdoc_code_")
269 |         os.chdir(tmp_dir)
270 |         try:
271 |             logging.debug("Clonning a new project (%s) to a tmp_dir (%s)", project, tmp_dir)
272 |             cmd_git_clone = ["git", "clone", "ssh://" + config.gerrit_address + "/" + project, "."]
273 |             subprocess.check_call(cmd_git_clone)
274 |         except Error, e:
275 |             logging.error("Could not clone a new project (%s) to a tmp_dir (%s), error message:", project, tmp_dir, e)
276 |             shutil.rmtree(tmp_dir)
277 |             return -1
278 |         try:
279 |             root_project_dir = config.watcher_working_dir + "/" + project.split('/')[:-1][0]
280 |             logging.debug("Creating destination folder (%s) for the new project (%s)", root_project_dir, project)
281 |             try:
282 |                 os.mkdir(root_project_dir)
283 |             except OSError, e:
284 |                 if e.errno != 17: # if error is different then "File exist"
285 |                     logging.error("Can not make project root directory: %s ", e)
286 |                     raise e
287 |             logging.debug("Moving the clone (%s) from tmp dir (%s) to the destination folder (%s)", project, tmp_dir, source_path)
288 |             os.rename(tmp_dir, source_path)
289 |         except Error, e:
290 |             logging.info("Initialization of a new project (%s) failed because it was initialized before, probably by an other process", project)
291 |             logging.debug("Exception caught during rename operation: %s", e)
292 |             shutil.rmtree(tmp_dir)
293 |         os.chdir(source_path)
294 |         logging.info("New project (%s) was initialized correctly", project)
295 | 
296 |     if fetch_change(project, patch_set, change_number) != 0:
297 |         return -1
298 | 
299 |     try:
300 |         #make own copy
301 |         tmp_dir = tempfile.mkdtemp(prefix="qdoc_")
302 |         logging.info("CREATING TMP DIR: %s", tmp_dir)
303 |         try:
304 |             os.chdir(tmp_dir)
305 | 
306 |             cmd_git_clone = ["git", "clone", source_path, module_name]
307 |             subprocess.check_call(cmd_git_clone)
308 | 
309 |             os.chdir(module_name)
310 | 
311 |             cmd_git_reset = ["git", "checkout", event["patchSet"]["revision"], "-b", "tmp"]
312 |             subprocess.check_call(cmd_git_reset)
313 | 
314 |             score_on_negative_review = -1
315 |             header = subprocess.check_output(["git", "log", '--pretty=oneline', '-n 1'])
316 |             if  (re.search(r'\bWIP\b', header) or header.find('***') >= 0):
317 |                 score_on_negative_review = 0 # Respect work in progress
318 | 
319 |             try:
320 |                 output_with_patch = run_qdoc(module_name)
321 |             except subprocess.CalledProcessError, e:
322 |                 logging.debug("RUNNING QDOC FAILED: %s", e)
323 |                 msg = "Qt Doc Bot tried to build the change on Linux, without success. Most likely because of a bug in the patch. "
324 |                 msg += "Please verify that a clean build works."
325 |                 msg += "\n\nRunning command\n " + str(e.cmd) + "\nfailed."
326 |                 if e.output != None:
327 |                     link = pasteKDE(e.output)
328 |                     msg += "\n\nBuild log can be found here: "
329 |                     msg += link
330 |                 post_review(event, msg, -1)
331 |                 return -1
332 | 
333 |             #reseting to parent and cleaning (especially needed for docs removal)
334 |             cmd_git_clean = ["git", "clean", "-fdxq"]
335 |             subprocess.check_call(cmd_git_clean)
336 |             cmd_git_reset = ["git", "reset", "--hard", "HEAD^"]
337 |             subprocess.check_call(cmd_git_reset)
338 | 
339 |             output_no_patch = run_qdoc(module_name)
340 | 
341 |             logging.info("DONE RUNNING QDOC")
342 |             return review_output(event, output_no_patch, output_with_patch, score_on_negative_review)
343 | 
344 |         finally:
345 |             # TODO reuse tmp dir
346 |             logging.info("REMOVING TMP DIR: %s", tmp_dir)
347 |             shutil.rmtree(tmp_dir)
348 |             logging.debug("WORKER EXECUTION TIME: %s", time.time() - start_time)
349 |     except subprocess.CalledProcessError, e:
350 |         logging.error("QDoc sanity failed because of an internal error: %s", e)
351 |         return -1
352 | 
353 | 
354 | def watcher():
355 |     while True:
356 |         try:
357 |             ssh = subprocess.Popen(["ssh", config.gerrit_address, "gerrit", "stream-events"], stdout=subprocess.PIPE)
358 |             import multiprocessing
359 |             logging.info("STARTING WATCHER")
360 |             def multiprocess_config_assign(c):
361 |                 config = c
362 |             processPool = multiprocessing.Pool(processes=config.workers_count,
363 |                                                initializer=multiprocess_config_assign,
364 |                                                initargs=(config,),
365 |                                                maxtasksperchild=5)
366 |             os.chdir(config.watcher_working_dir)
367 |             event_string = ssh.stdout.readline()
368 |             while len(event_string):
369 |                 try:
370 |                     processPool.apply_async(func=process_event, args=(event_string,))
371 |                 finally:
372 |                     #clean up working dir is it neccessery?
373 |                     os.chdir(config.watcher_working_dir)
374 |                 event_string = ssh.stdout.readline()
375 |             # we can get here if connection was broken somehow for example because of a timeout
376 |             logging.error("WATCHER RESTART because an empty response was received")
377 |             try:
378 |                 if ssh.returncode is None:
379 |                     # try to terminate the connection, it is better then wait for gc to do it.
380 |                     logging.warn("WATCHER received empty response but the connection was not closed, about to terminate it before restart")
381 |                     ssh.terminate()
382 |                 else:
383 |                     logging.warn("WATCHER was terminated with error code: %s", ssh.returncode)
384 |             except:
385 |                 pass
386 |         except:
387 |             logging.critical("WATCHER RESTART because of: %s", sys.exc_info())
388 |         finally:
389 |             # an error occurred let's restart in 15 sec
390 |             import time
391 |             time.sleep(15)
392 |             try:
393 |                 ssh.kill()
394 |             except: # swallow all errors, we do not care anymore
395 |                 pass
396 | 
397 | 
398 | if __name__== "__main__":
399 |     class Config(object): pass
400 |     config = Config()
401 |     import argparse
402 |     parser = argparse.ArgumentParser(prog="QDoc bot",
403 |                    description='It listens to gerrit events and tries to catch all new documentation errors',
404 |                    epilog="QDoc bot takes into consideration different environment variables (like TMP or TEMP). It also may use ccache and icecc if configured correctly")
405 |     parser.add_argument('-j',
406 |                    type=int,
407 |                    dest="workers_count",
408 |                    default=None,
409 |                    help='Workers count, how many parallel builds can be done at the same time. Default is equals to CPU count.')
410 |     parser.add_argument('--addr',
411 |                    type=str,
412 |                    dest="gerrit_address",
413 |                    metavar="gerrit.example.org",
414 |                    default="codereview.qt-project.org",
415 |                    help='Address of the gerrit instance. Default is codereview.qt-project.org')
416 |     parser.add_argument('--dir',
417 |                    type=str,
418 |                    dest="watcher_working_dir",
419 |                    metavar="/home/user/dev/qdoc-watcher",
420 |                    required=True,
421 |                    help='Set working directory which contains all neccessery checkouts')
422 |     parser.add_argument('--log-level',
423 |                    type=str,
424 |                    dest="logging_level",
425 |                    choices=["debug", "info", "warning", "error", "critical"],
426 |                    default="INFO",
427 |                    help='Set verbose level')
428 |     parser.add_argument('--sandbox',
429 |                    dest="sandbox",
430 |                    action="store_true",
431 |                    default=False,
432 |                    help='The option should be used for debugging only. It simulates execution of the bot, post reviews are sent only for 33219 and 33224 changes')
433 | 
434 |     args = parser.parse_args(namespace=config)
435 |     logging.basicConfig(format='(PID: %(process)d) %(asctime)s %(levelname)s: %(message)s', level=getattr(logging, config.logging_level.upper(), None))
436 |     watcher()
437 | 


--------------------------------------------------------------------------------
/bin/qt6_tool:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python3
  2 | # Copyright (C) 2022 The Qt Company Ltd.
  3 | # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
  4 | 
  5 | from argparse import ArgumentParser, RawTextHelpFormatter
  6 | from enum import Enum
  7 | import os
  8 | import re
  9 | import subprocess
 10 | import sys
 11 | import shutil
 12 | import time
 13 | import yaml  # pip install pyyaml
 14 | import warnings
 15 | 
 16 | DESCRIPTION = """
 17 | Typical Usage:
 18 | 
 19 | Create a repository          : qt6_tool -i qt-6
 20 | 
 21 | Update and build a repository: qt6_tool -p -b
 22 | 
 23 | Build and install directories are siblings to the repository
 24 | named build-<repository> and install-<repository>.
 25 | 
 26 | qt6_tool.py can be configured by creating a configuration file
 27 | in the format key=value:
 28 |     "%CONFIGFILE%"
 29 | 
 30 | Configuration keys:
 31 | Acceleration       Incredibuild or unset
 32 | BuildType          CMake Build type
 33 | CMake              CMake binary
 34 | ConfigureArguments Configure arguments
 35 | DeveloperBuild     (boolean) Developer build
 36 | DisabledFeatures   Disabled CMake features
 37 | Features           CMake features
 38 | Examples           (boolean) whether to build examples
 39 | Generator          CMake generator, defaults to Ninja
 40 | Mkspec             Qt make spec (e.g. win32-g++)
 41 | GerritUser         Gerrit user
 42 | InitArguments      ,-separated list of arguments to init-repository
 43 | Jobs               Number of jobs to be run simultaneously
 44 | Modules            ,-separated list of modules to build ("all": all modules,
 45 |                    ("wall": all modules except qtwebengine [default]).
 46 | Static             Build statically
 47 | Unity              CMake Unity (Jumbo) builds
 48 | UnityBatchSize     Batch size for Unity (32)
 49 | Tests              (boolean) whether to build tests
 50 | 
 51 | It is possible to use repository-specific values by adding a suffix preceded by
 52 | a dash, eg:
 53 | Modules-qt-611=qtbase,qtdeclarative
 54 | The suffix defaults to the repository folder base name unless specified
 55 | on the command line
 56 | Arbitrary keys can be referenced by $(name):
 57 | 
 58 | Run pip install pyyaml to install the required modules (Windows: Admin)
 59 | """
 60 | 
 61 | 
 62 | class BuildMode(Enum):
 63 |     NONE = 0
 64 |     BUILD = 1
 65 |     RECONFIGURE = 2
 66 |     MAKE = 3
 67 | 
 68 | 
 69 | class Platform(Enum):
 70 |     UNIX = 0
 71 |     WINDOWS = 1
 72 |     MACOS = 2
 73 | 
 74 | 
 75 | class Generator(Enum):
 76 |     NINJA = 0
 77 |     MAKE = 1
 78 |     NMAKE = 2
 79 |     JOM = 3
 80 | 
 81 | 
 82 | class Acceleration(Enum):
 83 |     NONE = 0
 84 |     INCREDIBUILD = 1
 85 | 
 86 | 
 87 | qt_dir = None
 88 | config_suffix = None
 89 | install_dir = None
 90 | build_dir = None
 91 | build_mode = BuildMode.NONE
 92 | opt_dry_run = False
 93 | 
 94 | PLATFORM = Platform.UNIX
 95 | if sys.platform == 'win32':
 96 |     PLATFORM = Platform.WINDOWS
 97 | elif sys.platform == 'darwin':
 98 |     PLATFORM = Platform.MACOS
 99 | 
100 | INCREDIBUILD_CONSOLE = 'BuildConsole' if PLATFORM == Platform.WINDOWS \
101 |                        else '/opt/incredibuild/bin/ib_console'
102 | 
103 | config_file = None
104 | 
105 | DEFAULT_GENERATOR_NAME = 'Ninja'
106 | GENERATORS = {'Ninja': Generator.NINJA,
107 |               'Unix Makefiles': Generator.MAKE,
108 |               'MinGW Makefiles': Generator.MAKE,
109 |               'NMake Makefiles': Generator.NMAKE,
110 |               'NMake Makefiles JOM': Generator.JOM}
111 | GIT_IGNORE_FOR_BRANCHES = ['qtcanvas3d']
112 | GIT_SPECIAL_BRANCHES = {'qtrepotools': 'master'}
113 | 
114 | # Config file keys
115 | ACCELERATION_KEY = 'Acceleration'
116 | BUILD_EXAMPLES_KEY = 'Examples'
117 | BUILD_TESTS_KEY = 'Tests'
118 | BUILD_TYPE_KEY = 'BuildType'
119 | CONFIGURE_ARGUMENTS_KEY = 'ConfigureArguments'
120 | CMAKE_KEY = 'CMake'
121 | DEVELOPER_BUILD_KEY = 'DeveloperBuild'
122 | DISABLED_FEATURES_KEY = 'DisabledFeatures'
123 | FEATURES_KEY = 'Features'
124 | GENERATOR_KEY = 'Generator'
125 | GERRIT_USER_KEY = 'GerritUser'
126 | INIT_ARGUMENTS_KEY = 'InitArguments'
127 | JOBS_KEY = 'Jobs'
128 | MKSPEC_KEY = 'Mkspec'
129 | MODULES_KEY = 'Modules'
130 | STATIC_KEY = 'Static'
131 | UNITY_KEY = 'Unity'
132 | UNITY_BATCH_SIZE_KEY = 'UnityBatchSize'
133 | 
134 | 
135 | def default_config_file():
136 |     return (f"{GENERATOR_KEY}={DEFAULT_GENERATOR_NAME}\n"
137 |             f"{BUILD_TESTS_KEY}=False\n"
138 |             f"{BUILD_TYPE_KEY}=Debug\n"
139 |             f"{BUILD_EXAMPLES_KEY}=False\n"
140 |             f"{INIT_ARGUMENTS_KEY}=--module-subset=default,-qtwebengine\n")
141 | 
142 | 
143 | def which(needle):
144 |     """Perform a path search"""
145 |     needles = [needle]
146 |     if PLATFORM == Platform.WINDOWS:
147 |         for ext in ("exe", "bat", "cmd"):
148 |             needles.append("{}.{}".format(needle, ext))
149 | 
150 |     for path in os.environ.get("PATH", "").split(os.pathsep):
151 |         for n in needles:
152 |             binary = os.path.join(path, n)
153 |             if os.path.isfile(binary):
154 |                 return binary
155 |     return None
156 | 
157 | 
158 | def command_log_string(args, dir):
159 |     return '[### {}] {}'.format(os.path.basename(dir), ' '.join(args))
160 | 
161 | 
162 | def execute(args):
163 |     """Execute a command and print to log"""
164 |     cur_dir = os.getcwd()
165 |     log_string = command_log_string(args, cur_dir)
166 |     print(log_string)
167 |     if opt_dry_run:
168 |         return
169 |     exit_code = subprocess.call(args)
170 |     if exit_code != 0:
171 |         raise RuntimeError(f'FAIL({exit_code}): {log_string} in {cur_dir}')
172 | 
173 | 
174 | def execute_in_dir(args, dir):
175 |     """Execute a command in a directory and print to log"""
176 |     if opt_dry_run:
177 |         print(command_log_string(args, dir))
178 |         return
179 |     current_dir = os.getcwd()
180 |     try:
181 |         os.chdir(dir)
182 |         execute(args)
183 |     finally:
184 |         os.chdir(current_dir)
185 | 
186 | 
187 | def run_process_output(args):
188 |     """Run a process and return its output. Also run in dry_run mode"""
189 |     std_out = subprocess.Popen(args, universal_newlines=1,
190 |                                stdout=subprocess.PIPE).stdout
191 |     result = [line.rstrip() for line in std_out.readlines()]
192 |     std_out.close()
193 |     return result
194 | 
195 | 
196 | def run_process_output_in_dir(args, dir):
197 |     """Run a process in dir and return its output. Also run in dry_run mode"""
198 |     current_dir = os.getcwd()
199 |     result = []
200 |     try:
201 |         os.chdir(dir)
202 |         result = run_process_output(args)
203 |     finally:
204 |         os.chdir(current_dir)
205 |     return result
206 | 
207 | 
208 | def git_branch(dir):
209 |     """Returns a tuple of current_branch, branches"""
210 |     branches = []
211 |     current_branch = None
212 |     for line in run_process_output_in_dir([git, 'branch'], dir):
213 |         branch = line[2:]  # "* dev\n  5.12"
214 |         if line.startswith('* '):
215 |             current_branch = branch
216 |         branches.append(branch)
217 |     return (current_branch, branches)
218 | 
219 | 
220 | def git_remote_branches(dir):
221 |     """Returns remote branches"""
222 |     branches = []
223 |     for line in run_process_output_in_dir([git, 'branch', '-r'], dir):
224 |         if '->' not in line:
225 |             branches.append(line[2:])
226 |     return branches
227 | 
228 | 
229 | def git_checkout_branch(dir, desired_branch):
230 |     branches = git_branch(dir)
231 |     # Already on desired branch
232 |     if branches[0] and branches[0] == desired_branch:
233 |         return
234 |     if desired_branch not in branches[1]:
235 |         # Try to find matching remote branch
236 |         desired_remote_branch = None
237 |         needle = f'/{desired_branch}'
238 |         remote_branches = git_remote_branches(dir)
239 |         for remote_branch in remote_branches:
240 |             if remote_branch.endswith(needle):
241 |                 desired_remote_branch = remote_branch
242 |                 break
243 |         if not desired_remote_branch:
244 |             base = os.path.basename(dir)
245 |             available = ', '.join(remote_branches)
246 |             m = f'[{base}]: Cannot find {desired_branch} in: {available}'
247 |             warnings.warn(m, RuntimeWarning)
248 |             return
249 |         execute_in_dir([git, 'branch', '--track', desired_branch,
250 |                        desired_remote_branch], dir)
251 |     execute_in_dir([git, 'checkout', desired_branch], dir)
252 | 
253 | 
254 | def is_available_module(dir_entry, filter_buildable=False):
255 |     """Check whether a directory is an available Qt module (under git)"""
256 |     if filter_buildable and dir_entry == 'qtqa':
257 |         return False
258 |     path = os.path.join(qt_dir, dir_entry)
259 |     git_config = os.path.join(path, '.git')
260 |     if not os.path.isdir(path) or not os.path.exists(git_config):
261 |         return False
262 |     if filter_buildable:
263 |         cmake_list = os.path.join(path, 'CMakeLists.txt')
264 |         if not os.path.isfile(cmake_list):
265 |             return False
266 |     return True
267 | 
268 | 
269 | def available_modules(filter_buildable=False):
270 |     """Return available Qt modules (under git)"""
271 |     result = []
272 |     for entry in os.listdir(qt_dir):
273 |         if is_available_module(entry, filter_buildable):
274 |             result.append(entry)
275 |     return result
276 | 
277 | 
278 | def modules_dependencies():
279 |     """Return a dict modules to their required modules with parameters as
280 |        obtained by parsing the dependencies.yaml files."""
281 |     result = {}
282 |     for module in os.listdir(qt_dir):
283 |         dependencies = os.path.join(qt_dir, module, 'dependencies.yaml')
284 |         if os.path.isfile(dependencies):
285 |             dependencies_dict = {}
286 |             try:
287 |                 file = open(dependencies, 'r')
288 |                 # Fix the dependent keys having a "../" prefix
289 |                 dep_yaml = yaml.load(file, Loader=yaml.SafeLoader)
290 |                 items = dep_yaml.get('dependencies').items()
291 |                 for dep_module, param_dict in items:
292 |                     if dep_module.startswith('../'):
293 |                         dep_module = dep_module[3:]
294 |                     if dep_module.startswith('tqtc-'):
295 |                         dep_module = dep_module[5:]
296 |                     dependencies_dict[dep_module] = param_dict
297 |                 result[module] = dependencies_dict
298 |             except Exception as e:
299 |                 print('Error parsing ', dependencies, ': ', str(e))
300 |             finally:
301 |                 file.close()
302 |     return result
303 | 
304 | 
305 | def print_dependency_graph(modules_dependency_dict):
306 |     """Print a graph showing dependencies for graphviz.
307 |        modules_dependency_dict is obtained from modules_dependencies(). Pipe
308 |         the output into | dot -ot.jpg -Tjpg"""
309 |     print('digraph Dependencies {')
310 |     for module, dependencies in modules_dependency_dict.items():
311 |         for dep_module, param_dict in dependencies.items():
312 |             required = param_dict.get('required')
313 |             edge_attribute = ' [style=bold]' if required else ''
314 |             print(f'    {module} -> {dep_module}{edge_attribute}')
315 |     print('}')
316 | 
317 | 
318 | def sort_by_dependencies(desired_module_list, modules_dependency_dict):
319 |     """Sort a list of modules to be built so that the dependencies
320 |        are built in order. modules_dependency_dict is obtained from
321 |        modules_dependencies()"""
322 |     result = []
323 |     # Transform the dependency dict into a simple dict
324 |     # of module->list of required modules for the desired list.
325 |     simple_dependencies = {}
326 |     for module, dependencies in modules_dependency_dict.items():
327 |         if module in desired_module_list:
328 |             required_dependencies = []
329 |             for dep_module, param_dict in dependencies.items():
330 |                 required = bool(param_dict.get('required'))
331 |                 if required or dep_module in desired_module_list:
332 |                     required_dependencies.append(dep_module)
333 |             simple_dependencies[module] = required_dependencies
334 |     # Brute force: Keep adding modules all of whose requirements are present
335 |     # to result list until done.
336 |     while len(result) < len(desired_module_list):
337 |         found = False
338 |         for module, dependencies in simple_dependencies.items():
339 |             if module not in result:
340 |                 if all(dependency in result for dependency in dependencies):
341 |                     result.append(module)
342 |                     found = True
343 |         if not found:
344 |             message = 'Module dependencies are not satisfied for'
345 |             for desired_module in desired_module_list:
346 |                 if desired_module not in result:
347 |                     message += ' ' + desired_module
348 |             raise ValueError(message)
349 |     return result
350 | 
351 | 
352 | def checkout_branch(branch):
353 |     """Switch repository to a branch"""
354 |     git_checkout_branch(qt_dir, branch)
355 |     for module in available_modules():
356 |         if module not in GIT_IGNORE_FOR_BRANCHES:
357 |             special_branch = GIT_SPECIAL_BRANCHES.get(module)
358 |             module_branch = special_branch if special_branch else branch
359 |             dir = os.path.join(qt_dir, module)
360 |             git_checkout_branch(dir, module_branch)
361 | 
362 | 
363 | def run_git(args):
364 |     """Run git in the Qt directory and its submodules"""
365 |     args.insert(0, git)  # run in repo
366 |     execute_in_dir(args, qt_dir)  # run for submodules
367 |     module_args = [git, "submodule", "foreach"]
368 |     module_args.extend(args)
369 |     execute_in_dir(module_args, qt_dir)
370 | 
371 | 
372 | def expand_reference(cache_dict, value):
373 |     """Expand references to other keys in config files $(name) by value."""
374 |     pattern = re.compile(r"\$\([^)]+\)")
375 |     while True:
376 |         match = pattern.match(value)
377 |         if not match:
378 |             break
379 |         key = match.group(0)[2:-1]
380 |         value = value[:match.start(0)] + cache_dict[key] + value[match.end(0):]
381 |     return value
382 | 
383 | 
384 | # Config file handling, cache and read function
385 | config_dict = {}
386 | 
387 | 
388 | def read_config_file(file_name):
389 |     """Read the config file into config_dict, expanding continuation lines"""
390 |     global config_dict
391 |     keyPattern = re.compile(r'^\s*([A-Za-z0-9\_\-]+)\s*=\s*(.*)$')
392 |     with open(file_name) as f:
393 |         while True:
394 |             line = f.readline()
395 |             if not line:
396 |                 break
397 |             line = line.rstrip()
398 |             match = keyPattern.match(line)
399 |             if match:
400 |                 key = match.group(1)
401 |                 value = match.group(2)
402 |                 while value.endswith('\\'):
403 |                     value = value.rstrip('\\')
404 |                     value += f.readline().rstrip()
405 |                 config_dict[key] = expand_reference(config_dict, value)
406 | 
407 | 
408 | def read_config(key):
409 |     """Read a value from the configuration file (caching it in a dict). When
410 |        given a key 'key' for the repository directory '/foo/qt-6', check for
411 |        the repo-specific value 'key-qt6' and then for the general 'key'."""
412 |     if not config_dict:
413 |         read_config_file(config_file)
414 |     repo_value = config_dict.get(key + '-' + config_suffix)
415 |     return repo_value if repo_value else config_dict.get(key)
416 | 
417 | 
418 | def read_bool_config(key):
419 |     value = read_config(key)
420 |     return value and value in ['1', 'true', 'True']
421 | 
422 | 
423 | def read_int_config(key, default=-1):
424 |     value = read_config(key)
425 |     return int(value) if value else default
426 | 
427 | 
428 | def read_list_config(key):
429 |     value = read_config(key)
430 |     return value.split(',') if value else []
431 | 
432 | 
433 | def read_cmake_bool_config(key):
434 |     return 'ON' if read_bool_config(key) else 'OFF'
435 | 
436 | 
437 | def read_generator_config():
438 |     value = read_config(GENERATOR_KEY)
439 |     return value if value else DEFAULT_GENERATOR_NAME
440 | 
441 | 
442 | def read_acceleration_config():
443 |     value = read_config(ACCELERATION_KEY)
444 |     if value:
445 |         value = value.lower()
446 |         if value == 'incredibuild':
447 |             return Acceleration.INCREDIBUILD
448 |     return Acceleration.NONE
449 | 
450 | 
451 | def read_config_modules_argument():
452 |     value = read_list_config(MODULES_KEY)
453 |     if len(value) > 1:
454 |         value_set = set(value)
455 |         if len(value_set) < len(value):
456 |             for set_entry in value_set:
457 |                 value.remove(set_entry)
458 |             raise ValueError('Duplicate entries in module list: ' + ' '.join(value))
459 |         return value
460 |     # Special keywords
461 |     if len(value) == 1 and value[0] == 'all':
462 |         return available_modules(True)
463 |     if not value or (len(value) == 1 and value[0] == 'wall'):
464 |         all_buildable_modules = available_modules(True)
465 |         if 'qtwebengine' in all_buildable_modules:
466 |             all_buildable_modules.remove('qtwebengine')
467 |         return all_buildable_modules
468 |     return value
469 | 
470 | 
471 | def cmake():
472 |     result = read_config(CMAKE_KEY)
473 |     return result if result else 'cmake'
474 | 
475 | 
476 | def get_config_file(base_name):
477 |     """Return configure file path, .config/qt6_tool.config, or equivalent on
478 |        Windows"""
479 |     home = os.getenv('HOME')
480 |     if PLATFORM == Platform.WINDOWS:
481 |         # Set a HOME variable on Windows such that scp. etc.
482 |         # feel at home (locating .ssh).
483 |         if not home:
484 |             home = os.getenv('HOMEDRIVE') + os.getenv('HOMEPATH')
485 |             os.environ['HOME'] = home
486 |         return os.path.join(os.getenv('APPDATA'), base_name)
487 |     config_dir = os.path.join(home, '.config')
488 |     if os.path.exists(config_dir):
489 |         return os.path.join(config_dir, base_name)
490 |     return os.path.join(home, '.' + base_name)
491 | 
492 | 
493 | def editor():
494 |     editor = os.getenv('EDITOR')
495 |     if not editor:
496 |         return 'notepad' if PLATFORM == Platform.WINDOWS else 'vi'
497 |     editor = editor.strip()
498 |     if PLATFORM == Platform.WINDOWS:
499 |         # Windows: git requires quotes in the variable
500 |         if editor.startswith('"') and editor.endswith('"'):
501 |             editor = editor[1:-1]
502 |         editor = editor.replace('/', '\\')
503 |     return editor
504 | 
505 | 
506 | def edit_config_file():
507 |     exit_code = -1
508 |     try:
509 |         exit_code = subprocess.call([editor(), config_file])
510 |     except Exception as e:
511 |         print('Unable to launch: {}: {}'.format(editor(), str(e)))
512 |     return exit_code
513 | 
514 | 
515 | def create_argument_parser(desc):
516 |     parser = ArgumentParser(description=desc,
517 |                             formatter_class=RawTextHelpFormatter)
518 |     parser.add_argument('--branch', '-B',
519 |                         help='Checkout tracking branch')
520 |     parser.add_argument('--build', '-b', action='store_true',
521 |                         help='Build (configure + build)')
522 |     parser.add_argument('--clean', '-c', action='store_true',
523 |                         help='Git clean')
524 |     parser.add_argument('--dependencies', '-D', action='store_true',
525 |                         help='Print a dependency graph for Graphviz')
526 |     parser.add_argument('--dry-run', '-d', action='store_true',
527 |                         help='Dry run, print commands')
528 |     parser.add_argument('--edit', '-e', action='store_true',
529 |                         help='Edit config file')
530 |     parser.add_argument('--init', '-i',
531 |                         help='Init a new repository')
532 |     parser.add_argument('--make', '-m', action='store_true',
533 |                         help='Make')
534 |     parser.add_argument('--pull', '-p', action='store_true',
535 |                         help='Git pull')
536 |     parser.add_argument('--reconfigure', '-R', action='store_true',
537 |                         help='Reconfigure and build')
538 |     parser.add_argument('--suffix', '-s',
539 |                         help='Suffix')
540 |     parser.add_argument('--reset', '-r', action='store_true',
541 |                         help='Git reset hard to upstream state')
542 |     parser.add_argument('--test', '-t', action='store_true',
543 |                         help='Test')
544 |     parser.add_argument('--version', '-v', action='version',
545 |                         version='%(prog)s 1.0')
546 |     parser.add_argument("modules", help="Override modules configuration",
547 |                         nargs='*', type=str)
548 |     return parser
549 | 
550 | 
551 | def ensure_dir(dir):
552 |     if not os.path.isdir(dir):
553 |         print(f'Creating {dir}')
554 |         if not opt_dry_run:
555 |             os.mkdir(dir)
556 | 
557 | 
558 | def remove_dir_recursively(dir):
559 |     if not os.path.exists(dir):
560 |         return
561 |     if not os.path.isdir(dir):
562 |         raise RuntimeError(f'{dir} is not a directory')
563 |     print(f'Removing {dir} ...')
564 |     if not opt_dry_run:
565 |         shutil.rmtree(dir, ignore_errors=True)
566 | 
567 | 
568 | def cmake_bool_value(value):
569 |     return "ON" if value else "OFF"
570 | 
571 | 
572 | def configure_arguments():
573 |     generator = read_generator_config()
574 |     build_type = read_config(BUILD_TYPE_KEY)
575 |     build_examples = cmake_bool_value(read_bool_config(BUILD_EXAMPLES_KEY))
576 |     build_tests = cmake_bool_value(read_bool_config(BUILD_TESTS_KEY))
577 |     build_statically = read_bool_config(STATIC_KEY)
578 |     unity_build = read_bool_config(UNITY_KEY)
579 |     arguments = read_config(CONFIGURE_ARGUMENTS_KEY)
580 |     mkspec = read_config(MKSPEC_KEY)
581 | 
582 |     result = [cmake(), f'-DCMAKE_INSTALL_PREFIX={install_dir}',
583 |               f'-G{generator}']
584 |     # Prevent mis-detection of clang/g++ when in path by coincidence
585 |     if PLATFORM == Platform.WINDOWS and os.environ.get('VCINSTALLDIR'):
586 |         result.append('-DCMAKE_CXX_COMPILER=cl.exe')
587 |     result.append(f'-DQT_BUILD_TESTS={build_tests}')
588 |     result.append(f'-DQT_BUILD_EXAMPLES={build_examples}')
589 |     if build_statically:
590 |         result.append('-DBUILD_SHARED_LIBS=OFF')
591 |     if unity_build:
592 |         batch_size = read_int_config(UNITY_BATCH_SIZE_KEY, 32)
593 |         result.extend(['-DQT_UNITY_BUILD=ON',
594 |                        f'-DQT_UNITY_BUILD_BATCH_SIZE={batch_size}'])
595 |     if mkspec:
596 |         result.append(f'-DQT_QMAKE_TARGET_MKSPEC={mkspec}')
597 | 
598 |     features = read_list_config(FEATURES_KEY)
599 |     if read_bool_config(DEVELOPER_BUILD_KEY):
600 |         features.append('developer_build')
601 |     for feature in features:
602 |         result.append(f'-DFEATURE_{feature}=ON')
603 |     for disabled_feature in read_list_config(DISABLED_FEATURES_KEY):
604 |         result.append(f'-DFEATURE_{disabled_feature}=OFF')
605 | 
606 |     if build_type:
607 |         result.append(f'-DCMAKE_BUILD_TYPE={build_type}')
608 | 
609 |     if arguments:
610 |         result.extend(arguments.split())
611 | 
612 |     return result
613 | 
614 | 
615 | def windows_build_cmd(generator, jobs):
616 |     """Return Windows build command without acceleration"""
617 |     if generator == Generator.NINJA:
618 |         return ['ninja', '-j', str(jobs)]
619 |     if generator == Generator.MAKE:
620 |         return ['mingw32-make', '-s', '-j', str(jobs)]
621 |     if generator == Generator.JOM:
622 |         return ['jom', '/s', '/j', str(jobs)]
623 |     return ['nmake', '/s', '/nologo']
624 | 
625 | 
626 | def windows_incredibuild_cmd(generator, jobs):
627 |     """Return Windows build command for incredibuild"""
628 |     cmd = ' '.join(windows_build_cmd(generator, jobs))
629 |     return [INCREDIBUILD_CONSOLE, f'/command={cmd}']
630 | 
631 | 
632 | def unix_build_cmd(acceleration, generator, jobs):
633 |     """UNIX build command"""
634 |     result = []
635 |     if acceleration == Acceleration.INCREDIBUILD:
636 |         result.extend([INCREDIBUILD_CONSOLE, '--avoid'])
637 |     if generator == Generator.NINJA:
638 |         result.extend(['ninja', '-j', str(jobs)])
639 |     else:
640 |         result.extend(['make', '-s', '-j', str(jobs)])
641 |     return result
642 | 
643 | 
644 | def build_cmd():
645 |     """Determine build command"""
646 |     jobs = read_int_config(JOBS_KEY, 1)
647 |     acceleration = read_acceleration_config()
648 |     if acceleration == Acceleration.NONE and jobs <= 1:
649 |         return [cmake(), '--build', '.', '--parallel']
650 |     generator = GENERATORS.get(read_generator_config())
651 |     if not generator:
652 |         values = '", "'.join(GENERATORS.keys())
653 |         raise ValueError(f'Generator must be one of "{values}")')
654 | 
655 |     if PLATFORM == Platform.WINDOWS:
656 |         if acceleration == Acceleration.INCREDIBUILD:
657 |             return windows_incredibuild_cmd(generator, jobs)
658 |         return windows_build_cmd(generator, jobs)
659 |     return unix_build_cmd(acceleration, generator, jobs)
660 | 
661 | 
662 | def build(modules, default_modules):
663 |     """Run configure and build steps"""
664 |     start_time = time.time()
665 |     # Building default: Wipe all directories
666 |     if build_mode == BuildMode.BUILD and default_modules:
667 |         remove_dir_recursively(install_dir)
668 |         remove_dir_recursively(build_dir)
669 | 
670 |     ensure_dir(install_dir)
671 |     ensure_dir(build_dir)
672 | 
673 |     for module in modules:
674 |         module_build_dir = os.path.join(build_dir, module)
675 |         if build_mode == BuildMode.BUILD and not default_modules:
676 |             remove_dir_recursively(module_build_dir)
677 |         ensure_dir(module_build_dir)
678 | 
679 |         cmake_cache = os.path.join(module_build_dir, 'CMakeCache.txt')
680 |         if build_mode == BuildMode.RECONFIGURE:
681 |             if os.path.isfile(cmake_cache):
682 |                 os.remove(cmake_cache)
683 | 
684 |         if build_mode != BuildMode.MAKE or not os.path.isfile(cmake_cache):
685 |             cmake_args = configure_arguments()
686 |             source = os.path.join(qt_dir, module)
687 |             cmake_args.append(f'-H{source}')
688 |             execute_in_dir(cmake_args, module_build_dir)
689 | 
690 |         execute_in_dir(build_cmd(), module_build_dir)
691 | 
692 |         install_cmd = [cmake(), '--install', '.']
693 |         execute_in_dir(install_cmd, module_build_dir)
694 | 
695 |     elapsed_time = int(time.time() - start_time)
696 |     print(f'--- Done({elapsed_time}s) ---')
697 | 
698 | 
699 | def run_tests(modules):
700 |     """Run tests"""
701 |     start_time = time.time()
702 |     result = 0
703 |     test_cmd = ['ctest', '--progress', '--output-on-failure']
704 |     for module in modules:
705 |         module_build_dir = os.path.join(build_dir, module)
706 |         try:
707 |             execute_in_dir(test_cmd, module_build_dir)
708 |         except Exception:
709 |             result += 1
710 |     elapsed_time = int(time.time() - start_time)
711 |     print(f'--- Done({result}, {elapsed_time}s) ---')
712 |     return result
713 | 
714 | 
715 | def init_repository(dir):
716 |     global qt_dir
717 |     target = os.path.basename(dir)
718 |     execute_in_dir([git, 'clone', 'git://code.qt.io/qt/qt5.git', target],
719 |                    os.path.dirname(dir))
720 | 
721 |     if PLATFORM == Platform.WINDOWS:
722 |         cmd = os.environ.get("COMSPEC")
723 |         init_cmd = [cmd, '/c', 'init-repository.bat']
724 |     else:
725 |         init_cmd = ['sh', 'init-repository']
726 |     init_arguments_value = read_config(INIT_ARGUMENTS_KEY)
727 |     if init_arguments_value:
728 |         init_cmd.extend(init_arguments_value.split(' '))
729 |     user = read_config(GERRIT_USER_KEY)
730 |     if user:
731 |         init_cmd.append(f'--codereview-username={user}')
732 |     execute_in_dir(init_cmd, dir)
733 |     qt_dir = dir
734 |     checkout_branch('dev')
735 | 
736 | 
737 | if __name__ == '__main__':
738 |     if sys.version_info[0] == 2 or sys.version_info[1] < 6:
739 |         print('Requires Python 3.6')
740 |         sys.exit(-1)
741 | 
742 |     config_file = get_config_file('qt6_tool.conf')
743 | 
744 |     desc = DESCRIPTION.replace('%CONFIGFILE%', config_file)
745 |     argument_parser = create_argument_parser(desc)
746 |     options = argument_parser.parse_args()
747 |     opt_dry_run = options.dry_run
748 | 
749 |     # We expect to live in qtrepotools/bin
750 |     qt_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
751 | 
752 |     if options.dependencies:
753 |         print_dependency_graph(modules_dependencies())
754 |         sys.exit(0)
755 | 
756 |     if not os.path.exists(config_file) and not opt_dry_run:
757 |         print('Create initial config file ', config_file, " ..")
758 |         with open(config_file, 'w') as f:
759 |             f.write(default_config_file())
760 | 
761 |     if options.edit:
762 |         sys.exit(edit_config_file())
763 | 
764 |     if options.build:
765 |         build_mode = BuildMode.BUILD
766 |     elif options.make:
767 |         build_mode = BuildMode.MAKE
768 |     elif options.reconfigure:
769 |         build_mode = BuildMode.RECONFIGURE
770 | 
771 |     if build_mode == BuildMode.NONE and not (options.init or options.branch
772 |        or options.clean or options.pull or options.test or options.reset):
773 |         argument_parser.print_help()
774 |         sys.exit(0)
775 | 
776 |     config_suffix = options.suffix if options.suffix else os.path.basename(qt_dir)
777 |     install_dir = os.path.join(os.path.dirname(qt_dir),
778 |                                f'install-{config_suffix}')
779 |     build_dir = os.path.join(os.path.dirname(qt_dir),
780 |                              f'build-{config_suffix}')
781 | 
782 |     git = which('git')
783 |     if git is None:
784 |         print('Unable to find git')
785 |         sys.exit(-1)
786 |     # Windows: git submodule foreach cannot handle spaces or backslashes
787 |     if sys.platform == 'win32':
788 |         git = 'git.exe'
789 | 
790 |     if options.branch:
791 |         checkout_branch(options.branch)
792 |         sys.exit(0)
793 | 
794 |     if options.init:
795 |         init_repository(os.path.abspath(options.init))
796 |         sys.exit(0)
797 | 
798 |     if not os.path.isdir(qt_dir):
799 |         print(f'{qt_dir} is not a valid Qt directory.')
800 |         sys.exit(-1)
801 | 
802 |     if options.clean:
803 |         run_git(['clean', '-dxf'])
804 | 
805 |     if options.reset:
806 |         run_git(['reset', '--hard', '@{upstream}'])
807 | 
808 |     if options.pull:
809 |         run_git(['pull', '--rebase'])
810 | 
811 |     sorted_modules = options.modules
812 |     use_default_modules = not sorted_modules
813 |     if use_default_modules and (build_mode != BuildMode.NONE or options.test):
814 |         sorted_modules = sort_by_dependencies(read_config_modules_argument(),
815 |                                               modules_dependencies())
816 | 
817 |     if build_mode != BuildMode.NONE:
818 |         build(sorted_modules, use_default_modules)
819 | 
820 |     if options.test:
821 |         sys.exit(run_tests(sorted_modules))
822 | 
823 |     sys.exit(0)
824 | 


--------------------------------------------------------------------------------