0e6be2aa5d
We use syncqt to generate .qmake.cache also for submodules, which contains the location of forwarding module profiles for that module. This enables us to build without having to put module profiles into mkspecs/modules until install time. Also added support for -developer-build to syncqt. What it does is to point build directories for binaries and libraries to a common location in QtBase. This is more convenient when doing development, since you don't need to set your path to every module's bin/ directory, but it cannot be used with release builds, since they need to build independently of QtBase, in their own directory. Change-Id: I959c62c11c644f2147a98da894a72452d9c44327 Task: QTBUG-19585 Task: QTBUG-19583 Reviewed-on: http://codereview.qt.nokia.com/232 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Marius Storm-Olsen <marius.storm-olsen@nokia.com>
1270 lines
52 KiB
Perl
Executable File
1270 lines
52 KiB
Perl
Executable File
#!/usr/bin/perl -w
|
|
######################################################################
|
|
#
|
|
# Synchronizes Qt header files - internal development tool.
|
|
#
|
|
# Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
# Contact: Nokia Corporation (qt-info@nokia.com)
|
|
#
|
|
######################################################################
|
|
|
|
# use packages -------------------------------------------------------
|
|
use File::Basename;
|
|
use File::Path;
|
|
use Cwd;
|
|
use Cwd 'abs_path';
|
|
use Config;
|
|
use strict;
|
|
|
|
# set output basedir to be where ever syncqt is run from
|
|
our $out_basedir = getcwd();
|
|
$out_basedir =~ s=\\=/=g;
|
|
our $basedir;
|
|
our $quoted_basedir;
|
|
|
|
|
|
# try to figure out where QtBase is located
|
|
# normally the script location should be enough, if not fall back to
|
|
# QTDIR environment variable. If that doesn't work, later ask the
|
|
# user to use the -qtdir option explicitly.
|
|
my $qtbasedir = $ENV{"QTDIR"};
|
|
$qtbasedir = dirname(dirname($0)) if (!$qtbasedir);
|
|
$qtbasedir =~ s=\\=/=g if (defined $qtbasedir);
|
|
|
|
# will be defined based on the modules sync.profile
|
|
our (%modules, %moduleheaders, %classnames, %mastercontent, %modulepris);
|
|
|
|
# global variables (modified by options)
|
|
my $isunix = 0;
|
|
my $module = 0;
|
|
my $showonly = 0;
|
|
my $quiet = 0;
|
|
my $remove_stale = 1;
|
|
my $force_win = 0;
|
|
my $force_relative = 0;
|
|
my $check_includes = 0;
|
|
my $copy_headers = 0;
|
|
my $create_uic_class_map = 0;
|
|
my $create_private_headers = 1;
|
|
my $module_fwd = "";
|
|
my $cache_module_fwd = 0;
|
|
my $developer_build = 0;
|
|
my $no_module_version_header = 0;
|
|
my @modules_to_sync ;
|
|
$force_relative = 1 if ( -d "/System/Library/Frameworks" );
|
|
|
|
|
|
# functions ----------------------------------------------------------
|
|
|
|
######################################################################
|
|
# Syntax: showUsage()
|
|
# Params: -none-
|
|
#
|
|
# Purpose: Show the usage of the script.
|
|
# Returns: -none-
|
|
######################################################################
|
|
sub showUsage
|
|
{
|
|
print "$0 usage:\n";
|
|
print " <module directory> Specifies which module to sync header files for (required for shadow builds!)\n\n";
|
|
|
|
print " -copy Copy headers instead of include-fwd(default: " . ($copy_headers ? "yes" : "no") . ")\n";
|
|
print " -remove-stale Removes stale headers (default: " . ($remove_stale ? "yes" : "no") . ")\n";
|
|
print " -relative Force relative symlinks (default: " . ($force_relative ? "yes" : "no") . ")\n";
|
|
print " -windows Force platform to Windows (default: " . ($force_win ? "yes" : "no") . ")\n";
|
|
print " -showonly Show action but not perform (default: " . ($showonly ? "yes" : "no") . ")\n";
|
|
print " -outdir <PATH> Specify output directory for sync (default: $out_basedir)\n";
|
|
print " -qtdir <PATH> Set the path to QtBase (detected: " . (defined $qtbasedir ? $qtbasedir : "-none-") . ")\n";
|
|
print " -quiet Only report problems, not activity (default: " . ($quiet ? "yes" : "no") . ")\n";
|
|
print " -separate-module <NAME>:<PROFILEDIR>:<HEADERDIR>\n";
|
|
print " Create headers for <NAME> with original headers in\n";
|
|
print " <HEADERDIR> relative to <PROFILEDIR> \n";
|
|
print " -private Force copy private headers (default: " . ($create_private_headers ? "yes" : "no") . ")\n";
|
|
print " -module-fwd <PATH> Create fwd includes for module pri files in the given\n";
|
|
print " path (default: none)\n";
|
|
print " -cache-module-fwd Create a .qmake.cache file to cache the location of the\n";
|
|
print " fwd includes\n";
|
|
print " -developer-build Point libraries and binaries to a common directory for\n";
|
|
print " easy development\n";
|
|
print " -no-module-version-header\n";
|
|
print " Don't create module version header file\n";
|
|
print " -help This help\n";
|
|
exit 0;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: checkUnix()
|
|
# Params: -none-
|
|
#
|
|
# Purpose: Check if script runs on a Unix system or not. Cygwin
|
|
# systems are _not_ detected as Unix systems.
|
|
# Returns: 1 if a unix system, else 0.
|
|
######################################################################
|
|
sub checkUnix {
|
|
my ($r) = 0;
|
|
if ( $force_win != 0) {
|
|
return 0;
|
|
} elsif ( -f "/bin/uname" ) {
|
|
$r = 1;
|
|
(-f "\\bin\\uname") && ($r = 0);
|
|
} elsif ( -f "/usr/bin/uname" ) {
|
|
$r = 1;
|
|
(-f "\\usr\\bin\\uname") && ($r = 0);
|
|
}
|
|
if($r) {
|
|
$_ = $Config{'osname'};
|
|
$r = 0 if( /(ms)|(cyg)win/i );
|
|
}
|
|
return $r;
|
|
}
|
|
|
|
sub checkRelative {
|
|
my ($dir) = @_;
|
|
return 0 if($dir =~ /^\//);
|
|
return 0 if(!checkUnix() && $dir =~ /[a-zA-Z]:[\/\\]/);
|
|
return 1;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: shouldMasterInclude(iheader)
|
|
# Params: iheader, string, filename to verify inclusion
|
|
#
|
|
# Purpose: Determines if header should be in the master include file.
|
|
# Returns: 0 if file contains "#pragma qt_no_master_include" or not
|
|
# able to open, else 1.
|
|
######################################################################
|
|
sub shouldMasterInclude {
|
|
my ($iheader) = @_;
|
|
return 0 if(basename($iheader) =~ /_/);
|
|
return 0 if(basename($iheader) =~ /qconfig/);
|
|
if(open(F, "<$iheader")) {
|
|
while(<F>) {
|
|
chomp;
|
|
return 0 if(/^\#pragma qt_no_master_include$/);
|
|
}
|
|
close(F);
|
|
} else {
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: classNames(iheader)
|
|
# Params: iheader, string, filename to parse for classname "symlinks"
|
|
#
|
|
# Purpose: Scans through iheader to find all classnames that should be
|
|
# synced into library's include structure.
|
|
# Returns: List of all class names in a file.
|
|
######################################################################
|
|
sub classNames {
|
|
my @ret;
|
|
my ($iheader) = @_;
|
|
|
|
my $classname = $classnames{basename($iheader)};
|
|
push @ret, $classname if ($classname);
|
|
|
|
my $parsable = "";
|
|
if(open(F, "<$iheader")) {
|
|
while(<F>) {
|
|
my $line = $_;
|
|
chomp $line;
|
|
chop $line if ($line =~ /\r$/);
|
|
if($line =~ /^\#/) {
|
|
if($line =~ /\\$/) {
|
|
while($line = <F>) {
|
|
chomp $line;
|
|
last unless($line =~ /\\$/);
|
|
}
|
|
}
|
|
return @ret if($line =~ m/^#pragma qt_sync_stop_processing/);
|
|
push(@ret, $1) if($line =~ m/^#pragma qt_class\(([^)]*)\)[\r\n]*$/);
|
|
$line = 0;
|
|
}
|
|
if($line) {
|
|
$line =~ s,//.*$,,; #remove c++ comments
|
|
$line .= ";" if($line =~ m/^Q_[A-Z_]*\(.*\)[\r\n]*$/); #qt macro
|
|
$line .= ";" if($line =~ m/^QT_(BEGIN|END)_HEADER[\r\n]*$/); #qt macro
|
|
$line .= ";" if($line =~ m/^QT_(BEGIN|END)_NAMESPACE[\r\n]*$/); #qt macro
|
|
$line .= ";" if($line =~ m/^QT_MODULE\(.*\)[\r\n]*$/); # QT_MODULE macro
|
|
$parsable .= " " . $line;
|
|
}
|
|
}
|
|
close(F);
|
|
}
|
|
|
|
my $last_definition = 0;
|
|
my @namespaces;
|
|
for(my $i = 0; $i < length($parsable); $i++) {
|
|
my $definition = 0;
|
|
my $character = substr($parsable, $i, 1);
|
|
if($character eq "/" && substr($parsable, $i+1, 1) eq "*") { #I parse like this for greedy reasons
|
|
for($i+=2; $i < length($parsable); $i++) {
|
|
my $end = substr($parsable, $i, 2);
|
|
if($end eq "*/") {
|
|
$last_definition = $i+2;
|
|
$i++;
|
|
last;
|
|
}
|
|
}
|
|
} elsif($character eq "{") {
|
|
my $brace_depth = 1;
|
|
my $block_start = $i + 1;
|
|
BLOCK: for($i+=1; $i < length($parsable); $i++) {
|
|
my $ignore = substr($parsable, $i, 1);
|
|
if($ignore eq "{") {
|
|
$brace_depth++;
|
|
} elsif($ignore eq "}") {
|
|
$brace_depth--;
|
|
unless($brace_depth) {
|
|
for(my $i2 = $i+1; $i2 < length($parsable); $i2++) {
|
|
my $end = substr($parsable, $i2, 1);
|
|
if($end eq ";" || $end ne " ") {
|
|
$definition = substr($parsable, $last_definition, $block_start - $last_definition) . "}";
|
|
$i = $i2 if($end eq ";");
|
|
$last_definition = $i + 1;
|
|
last BLOCK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} elsif($character eq ";") {
|
|
$definition = substr($parsable, $last_definition, $i - $last_definition + 1);
|
|
$last_definition = $i + 1;
|
|
} elsif($character eq "}") {
|
|
# a naked } must be a namespace ending
|
|
# if it's not a namespace, it's eaten by the loop above
|
|
pop @namespaces;
|
|
$last_definition = $i + 1;
|
|
}
|
|
|
|
if (substr($parsable, $last_definition, $i - $last_definition + 1) =~ m/ namespace ([^ ]*) /
|
|
&& substr($parsable, $i+1, 1) eq "{") {
|
|
push @namespaces, $1;
|
|
|
|
# Eat the opening { so that the condensing loop above doesn't see it
|
|
$i++;
|
|
$last_definition = $i + 1;
|
|
}
|
|
|
|
if($definition) {
|
|
$definition =~ s=[\n\r]==g;
|
|
my @symbols;
|
|
if($definition =~ m/^ *typedef *.*\(\*([^\)]*)\)\(.*\);$/) {
|
|
push @symbols, $1;
|
|
} elsif($definition =~ m/^ *typedef +(.*) +([^ ]*);$/) {
|
|
push @symbols, $2;
|
|
} elsif($definition =~ m/^ *(template *<.*> *)?(class|struct) +([^ ]* +)?([^<\s]+) ?(<[^>]*> ?)?\s*((,|:)\s*(public|protected|private) *.*)? *\{\}$/) {
|
|
push @symbols, $4;
|
|
} elsif($definition =~ m/^ *Q_DECLARE_.*ITERATOR\((.*)\);$/) {
|
|
push @symbols, "Q" . $1 . "Iterator";
|
|
push @symbols, "QMutable" . $1 . "Iterator";
|
|
}
|
|
|
|
foreach my $symbol (@symbols) {
|
|
$symbol = (join("::", @namespaces) . "::" . $symbol) if (scalar @namespaces);
|
|
push @ret, $symbol
|
|
if ($symbol =~ /^Q[^:]*$/ # no-namespace, starting with Q
|
|
|| $symbol =~ /^Phonon::/); # or in the Phonon namespace
|
|
}
|
|
}
|
|
}
|
|
return @ret;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: syncHeader(header, iheader, copy, timestamp)
|
|
# Params: header, string, filename to create "symlink" for
|
|
# iheader, string, destination name of symlink
|
|
# copy, forces header to be a copy of iheader
|
|
# timestamp, the requested modification time if copying
|
|
#
|
|
# Purpose: Syncronizes header to iheader
|
|
# Returns: 1 if successful, else 0.
|
|
######################################################################
|
|
sub syncHeader {
|
|
my ($header, $iheader, $copy, $ts) = @_;
|
|
$iheader =~ s=\\=/=g;
|
|
$header =~ s=\\=/=g;
|
|
return copyFile($iheader, $header) if($copy);
|
|
|
|
unless(-e $header) {
|
|
my $header_dir = dirname($header);
|
|
mkpath $header_dir, !$quiet;
|
|
|
|
#write it
|
|
my $iheader_out = fixPaths($iheader, $header_dir);
|
|
open HEADER, ">$header" || die "Could not open $header for writing!\n";
|
|
print HEADER "#include \"$iheader_out\"\n";
|
|
close HEADER;
|
|
if(defined($ts)) {
|
|
utime(time, $ts, $header) or die "$iheader, $header";
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: fixPaths(file, dir)
|
|
# Params: file, string, filepath to be made relative to dir
|
|
# dir, string, dirpath for point of origin
|
|
#
|
|
# Purpose: file is made relative (if possible) of dir.
|
|
# Returns: String with the above applied conversion.
|
|
######################################################################
|
|
sub fixPaths {
|
|
my ($file, $dir) = @_;
|
|
$file =~ s=\\=/=g;
|
|
$dir =~ s=\\=/=g;
|
|
|
|
#setup
|
|
my $ret = $file;
|
|
$ret =~ s,/cygdrive/([a-zA-Z])/,$1:/,g;
|
|
my $file_dir = dirname($file);
|
|
if($file_dir eq ".") {
|
|
$file_dir = getcwd();
|
|
$file_dir =~ s=\\=/=g;
|
|
}
|
|
$file_dir =~ s,/cygdrive/([a-zA-Z])/,$1:/,g;
|
|
if($dir eq ".") {
|
|
$dir = getcwd();
|
|
$dir =~ s=\\=/=g;
|
|
}
|
|
$dir =~ s,/cygdrive/([a-zA-Z])/,$1:/,g;
|
|
return basename($file) if($file_dir eq $dir);
|
|
|
|
#guts
|
|
while ($file_dir =~ s,/[^/]+/\.\./,/,) {}
|
|
while ($dir =~ s,/[^/]+/\.\./,/,) {}
|
|
my $match_dir = 0;
|
|
for(my $i = 1; $i < length($file_dir); $i++) {
|
|
my $slash = index($file_dir, "/", $i);
|
|
last if($slash == -1);
|
|
my $tmp = substr($file_dir, 0, $slash);
|
|
last unless($dir =~ m,^\Q$tmp\E/,);
|
|
$match_dir = $tmp;
|
|
$i = $slash;
|
|
}
|
|
if($match_dir) {
|
|
my $after = substr($dir, length($match_dir));
|
|
my $count = ($after =~ tr,/,,);
|
|
my $dots = "";
|
|
for(my $i = 0; $i < $count; $i++) {
|
|
$dots .= "../";
|
|
}
|
|
$ret =~ s,^\Q$match_dir\E,$dots,;
|
|
}
|
|
$ret =~ s,/+,/,g;
|
|
return $ret;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: fileContents(filename)
|
|
# Params: filename, string, filename of file to return contents
|
|
#
|
|
# Purpose: Get the contents of a file.
|
|
# Returns: String with contents of the file, or empty string if file
|
|
# doens't exist.
|
|
# Warning: Dies if it does exist but script cannot get read access.
|
|
######################################################################
|
|
sub fileContents {
|
|
my ($filename) = @_;
|
|
my $filecontents = "";
|
|
if (-e $filename) {
|
|
open(I, "< $filename") || die "Could not open $filename for reading, read block?";
|
|
local $/;
|
|
binmode I;
|
|
$filecontents = <I>;
|
|
close I;
|
|
}
|
|
return $filecontents;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: fileCompare(file1, file2)
|
|
# Params: file1, string, filename of first file
|
|
# file2, string, filename of second file
|
|
#
|
|
# Purpose: Determines if files are equal, and which one is newer.
|
|
# Returns: 0 if files are equal no matter the timestamp, -1 if file1
|
|
# is newer, 1 if file2 is newer.
|
|
######################################################################
|
|
sub fileCompare {
|
|
my ($file1, $file2) = @_;
|
|
my $file1contents = fileContents($file1);
|
|
my $file2contents = fileContents($file2);
|
|
if (! -e $file1) { return 1; }
|
|
if (! -e $file2) { return -1; }
|
|
return $file1contents ne $file2contents ? (stat($file2))[9] <=> (stat($file1))[9] : 0;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: copyFile(file, ifile)
|
|
# Params: file, string, filename to create duplicate for
|
|
# ifile, string, destination name of duplicate
|
|
#
|
|
# Purpose: Keeps files in sync so changes in the newer file will be
|
|
# written to the other.
|
|
# Returns: 1 if files were synced, else 0.
|
|
# Warning: Dies if script cannot get write access.
|
|
######################################################################
|
|
sub copyFile
|
|
{
|
|
my ($file,$ifile, $copy,$knowdiff,$filecontents,$ifilecontents) = @_;
|
|
# Bi-directional synchronization
|
|
open( I, "< " . $file ) || die "Could not open $file for reading";
|
|
local $/;
|
|
binmode I;
|
|
$filecontents = <I>;
|
|
close I;
|
|
if ( open(I, "< " . $ifile) ) {
|
|
local $/;
|
|
binmode I;
|
|
$ifilecontents = <I>;
|
|
close I;
|
|
$copy = fileCompare($file, $ifile);
|
|
$knowdiff = 0,
|
|
} else {
|
|
$copy = -1;
|
|
$knowdiff = 1;
|
|
}
|
|
|
|
if ( $knowdiff || ($filecontents ne $ifilecontents) ) {
|
|
if ( $copy > 0 ) {
|
|
my $file_dir = dirname($file);
|
|
mkpath $file_dir, !$quiet unless(-e $file_dir);
|
|
open(O, "> " . $file) || die "Could not open $file for writing (no write permission?)";
|
|
local $/;
|
|
binmode O;
|
|
print O $ifilecontents;
|
|
close O;
|
|
utime time, (stat($ifile))[9], $file;
|
|
return 1;
|
|
} elsif ( $copy < 0 ) {
|
|
my $ifile_dir = dirname($ifile);
|
|
mkpath $ifile_dir, !$quiet unless(-e $ifile_dir);
|
|
open(O, "> " . $ifile) || die "Could not open $ifile for writing (no write permission?)";
|
|
local $/;
|
|
binmode O;
|
|
print O $filecontents;
|
|
close O;
|
|
utime time, (stat($file))[9], $ifile;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: symlinkFile(file, ifile)
|
|
# Params: file, string, filename to create "symlink" for
|
|
# ifile, string, destination name of symlink
|
|
#
|
|
# Purpose: File is symlinked to ifile (or copied if filesystem doesn't
|
|
# support symlink).
|
|
# Returns: 1 on success, else 0.
|
|
######################################################################
|
|
sub symlinkFile
|
|
{
|
|
my ($file,$ifile) = @_;
|
|
|
|
if ($isunix) {
|
|
print "symlink created for $file " unless $quiet;
|
|
if ( $force_relative && ($ifile =~ /^$quoted_basedir/)) {
|
|
my $t = getcwd();
|
|
my $c = -1;
|
|
my $p = "../";
|
|
$t =~ s-^$quoted_basedir/--;
|
|
$p .= "../" while( ($c = index( $t, "/", $c + 1)) != -1 );
|
|
$file =~ s-^$quoted_basedir/-$p-;
|
|
print " ($file)\n" unless $quiet;
|
|
}
|
|
print "\n" unless $quiet;
|
|
return symlink($file, $ifile);
|
|
}
|
|
return copyFile($file, $ifile);
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: findFiles(dir, match, descend)
|
|
# Params: dir, string, directory to search for name
|
|
# match, string, regular expression to match in dir
|
|
# descend, integer, 0 = non-recursive search
|
|
# 1 = recurse search into subdirectories
|
|
#
|
|
# Purpose: Finds files matching a regular expression.
|
|
# Returns: List of matching files.
|
|
#
|
|
# Examples:
|
|
# findFiles("/usr","\.cpp$",1) - finds .cpp files in /usr and below
|
|
# findFiles("/tmp","^#",0) - finds #* files in /tmp
|
|
######################################################################
|
|
sub findFiles {
|
|
my ($dir,$match,$descend) = @_;
|
|
my ($file,$p,@files);
|
|
local(*D);
|
|
$dir =~ s=\\=/=g;
|
|
($dir eq "") && ($dir = ".");
|
|
if ( opendir(D,$dir) ) {
|
|
if ( $dir eq "." ) {
|
|
$dir = "";
|
|
} else {
|
|
($dir =~ /\/$/) || ($dir .= "/");
|
|
}
|
|
foreach $file ( sort readdir(D) ) {
|
|
next if ( $file =~ /^\.\.?$/ );
|
|
$p = $file;
|
|
($file =~ /$match/) && (push @files, $p);
|
|
if ( $descend && -d $p && ! -l $p ) {
|
|
push @files, &findFiles($p,$match,$descend);
|
|
}
|
|
}
|
|
closedir(D);
|
|
}
|
|
return @files;
|
|
}
|
|
|
|
######################################################################
|
|
# Syntax: loadSyncProfile()
|
|
#
|
|
# Purpose: Locates the sync.profile.
|
|
# Returns: Hashmap of module name -> directory.
|
|
######################################################################
|
|
sub loadSyncProfile {
|
|
my ($srcbase, $outbase) = @_;
|
|
print("srcbase = $$srcbase \n");
|
|
print("outbase = $$outbase \n");
|
|
|
|
my $syncprofile = "$$srcbase/sync.profile";
|
|
my $result;
|
|
unless ($result = do "$syncprofile") {
|
|
die "syncqt couldn't parse $syncprofile: $@" if $@;
|
|
die "syncqt couldn't execute $syncprofile: $!" unless defined $result;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
sub locateSyncProfile
|
|
{
|
|
my ($directory) = @_;
|
|
my $syncprofile;
|
|
$directory = abs_path($directory);
|
|
while(!defined $syncprofile) {
|
|
local(*D);
|
|
if (opendir(D, $directory)) {
|
|
foreach my $file (sort readdir(D)) {
|
|
next if ($file =~ /^\.\.?$/);
|
|
$syncprofile = "$directory/$file" if ($file =~ /^sync\.profile$/);
|
|
last if (defined $syncprofile);
|
|
}
|
|
closedir(D);
|
|
}
|
|
last if (defined $syncprofile || $directory eq "/" || $directory =~ /^?:[\/\\]$/);
|
|
$directory = dirname($directory);
|
|
}
|
|
return $syncprofile;
|
|
}
|
|
|
|
# check if this is an in-source build, and if so use that as the basedir too
|
|
$basedir = locateSyncProfile($out_basedir);
|
|
if ($basedir) {
|
|
$basedir = dirname($basedir) ;
|
|
$basedir =~ s=\\=/=g;
|
|
$quoted_basedir = "\Q$basedir";
|
|
}
|
|
|
|
# --------------------------------------------------------------------
|
|
# "main" function
|
|
# --------------------------------------------------------------------
|
|
|
|
while ( @ARGV ) {
|
|
my $var = 0;
|
|
my $val = 0;
|
|
|
|
#parse
|
|
my $arg = shift @ARGV;
|
|
if ($arg eq "-h" || $arg eq "-help" || $arg eq "-?" || $arg eq "?") {
|
|
$var = "show_help";
|
|
$val = "yes";
|
|
} elsif($arg eq "-copy") {
|
|
$var = "copy";
|
|
$val = "yes";
|
|
} elsif($arg eq "-o" || $arg eq "-outdir") {
|
|
$var = "output";
|
|
$val = shift @ARGV;
|
|
} elsif($arg eq "-showonly" || $arg eq "-remove-stale" || $arg eq "-windows" ||
|
|
$arg eq "-relative" || $arg eq "-check-includes") {
|
|
$var = substr($arg, 1);
|
|
$val = "yes";
|
|
} elsif($arg eq "-module-fwd") {
|
|
$var = "module_fwd";
|
|
$val = shift @ARGV;
|
|
} elsif($arg eq "-cache-module-fwd") {
|
|
$var = "cache_module_fwd";
|
|
$val = "yes";
|
|
} elsif($arg eq "-developer-build") {
|
|
$var = "developer_build";
|
|
$val = "yes";
|
|
} elsif($arg eq "-no-module-version-header") {
|
|
$var = "no_module_version_header";
|
|
$val = "yes";
|
|
} elsif($arg =~ /^-no-(.*)$/) {
|
|
$var = $1;
|
|
$val = "no";
|
|
#these are for commandline compat
|
|
} elsif($arg eq "-inc") {
|
|
$var = "output";
|
|
$val = shift @ARGV;
|
|
} elsif($arg eq "-module") {
|
|
$var = "module";
|
|
$val = shift @ARGV;
|
|
} elsif($arg eq "-separate-module") {
|
|
$var = "separate-module";
|
|
$val = shift @ARGV;
|
|
} elsif($arg eq "-show") {
|
|
$var = "showonly";
|
|
$val = "yes";
|
|
} elsif($arg eq "-quiet") {
|
|
$var = "quiet";
|
|
$val = "yes";
|
|
} elsif($arg eq "-private") {
|
|
$var = "create_private_headers";
|
|
$val = "yes";
|
|
} elsif($arg eq "-qtdir") {
|
|
$var = "qtdir";
|
|
$val = shift @ARGV;
|
|
} elsif($arg eq "-base-dir") {
|
|
# skip, it's been dealt with at the top of the file
|
|
shift @ARGV;
|
|
next;
|
|
} elsif($arg =~/^-/) {
|
|
print "Unknown option: $arg\n\n" if(!$var);
|
|
showUsage();
|
|
} else {
|
|
$basedir = locateSyncProfile($arg);
|
|
die "Could not find a sync.profile for '$arg'\n" if (!$basedir);
|
|
$basedir = dirname($basedir);
|
|
$basedir =~ s=\\=/=g;
|
|
$quoted_basedir = "\Q$basedir";
|
|
$var = "ignore";
|
|
}
|
|
|
|
#do something
|
|
if(!$var || $var eq "show_help") {
|
|
print "Unknown option: $arg\n\n" if(!$var);
|
|
showUsage();
|
|
} elsif ($var eq "copy") {
|
|
if($val eq "yes") {
|
|
$copy_headers++;
|
|
} elsif($showonly) {
|
|
$copy_headers--;
|
|
}
|
|
} elsif ($var eq "showonly") {
|
|
if($val eq "yes") {
|
|
$showonly++;
|
|
} elsif($showonly) {
|
|
$showonly--;
|
|
}
|
|
} elsif ($var eq "quiet") {
|
|
if($val eq "yes") {
|
|
$quiet++;
|
|
} elsif($quiet) {
|
|
$quiet--;
|
|
}
|
|
} elsif ($var eq "check-includes") {
|
|
if($val eq "yes") {
|
|
$check_includes++;
|
|
} elsif($check_includes) {
|
|
$check_includes--;
|
|
}
|
|
} elsif ($var eq "remove-stale") {
|
|
if($val eq "yes") {
|
|
$remove_stale++;
|
|
} elsif($remove_stale) {
|
|
$remove_stale--;
|
|
}
|
|
} elsif ($var eq "windows") {
|
|
if($val eq "yes") {
|
|
$force_win++;
|
|
} elsif($force_win) {
|
|
$force_win--;
|
|
}
|
|
} elsif ($var eq "relative") {
|
|
if($val eq "yes") {
|
|
$force_relative++;
|
|
} elsif($force_relative) {
|
|
$force_relative--;
|
|
}
|
|
} elsif ($var eq "module") {
|
|
print "module :$val:\n" unless $quiet;
|
|
die "No such module: $val" unless(defined $modules{$val});
|
|
push @modules_to_sync, $val;
|
|
} elsif ($var eq "separate-module") {
|
|
my ($module, $prodir, $headerdir) = split(/:/, $val);
|
|
$modules{$module} = $prodir;
|
|
push @modules_to_sync, $module;
|
|
$moduleheaders{$module} = $headerdir;
|
|
$create_uic_class_map = 0;
|
|
} elsif ($var eq "qtdir") {
|
|
if($val) {
|
|
$qtbasedir = $val;
|
|
$qtbasedir =~ s=\\=/=g;
|
|
} else {
|
|
die "The -qtdir option requires an argument";
|
|
}
|
|
} elsif ($var eq "module_fwd") {
|
|
$module_fwd = $val;
|
|
} elsif ($var eq "cache_module_fwd") {
|
|
$cache_module_fwd = 1;
|
|
} elsif ($var eq "developer_build") {
|
|
$developer_build = 1;
|
|
} elsif ($var eq "no_module_version_header") {
|
|
$no_module_version_header = 1;
|
|
} elsif ($var eq "output") {
|
|
my $outdir = $val;
|
|
if(checkRelative($outdir)) {
|
|
$out_basedir = getcwd();
|
|
chomp $out_basedir;
|
|
$out_basedir .= "/" . $outdir;
|
|
} else {
|
|
$out_basedir = $outdir;
|
|
}
|
|
# \ -> /
|
|
$out_basedir =~ s=\\=/=g;
|
|
}
|
|
}
|
|
|
|
# if the $qtbasedir neither has 'qtbase' somewhere in its path, nor a
|
|
# '.qmake.cache' file in its directory, we assume it's not a valid path
|
|
# (remember that a yet-to-be-built qtbase doesn't have this file either,
|
|
# thus the 'qtbase' path check!)
|
|
die "Cannot automatically detect/use provided path to QtBase's build directory!\n" .
|
|
"QTDIR detected/provided: " . (defined $qtbasedir ? $qtbasedir : "-none-") . "\n" .
|
|
"Please -qtdir option to provide the correct path.\nsyncqt failed"
|
|
if (!$qtbasedir || !-d "$qtbasedir/mkspecs");
|
|
|
|
# if we have no $basedir we cannot be sure which sources you want, so die
|
|
die "Could not find any sync.profile for your module!\nPass <module directory> to syncqt to sync your header files.\nsyncqt failed" if (!$basedir);
|
|
|
|
my @ignore_headers = ();
|
|
my $class_lib_map_contents = "";
|
|
our @ignore_for_master_contents = ();
|
|
our @ignore_for_include_check = ();
|
|
our @ignore_for_qt_begin_header_check = ();
|
|
our @ignore_for_qt_begin_namespace_check = ();
|
|
our @ignore_for_qt_module_check = ();
|
|
my %colliding_headers = ();
|
|
my %inject_headers = ( "$basedir/src/corelib/global" => ( "qconfig.h" ) ); # all from build dir
|
|
|
|
# load the module's sync.profile here, before we can
|
|
loadSyncProfile(\$basedir, \$out_basedir);
|
|
|
|
@modules_to_sync = keys(%modules) if($#modules_to_sync == -1);
|
|
|
|
$isunix = checkUnix; #cache checkUnix
|
|
|
|
# create path
|
|
mkpath "$out_basedir/include", !$quiet;
|
|
mkpath "$out_basedir/include/Qt", !$quiet;
|
|
|
|
|
|
foreach my $lib (@modules_to_sync) {
|
|
#iteration info
|
|
my $dir = $modules{$lib};
|
|
my $module_version = "";
|
|
my $module_major_version = "";
|
|
my $module_minor_version = "";
|
|
my $module_patch_version = "";
|
|
|
|
if (-e "$modulepris{$lib}") {
|
|
my $content = fileContents($modulepris{$lib});
|
|
my @version_rows = grep(/QT\..*\.VERSION/, split('\n', $content));
|
|
if(@version_rows) {
|
|
# We only pick the first one, since each module need a separate .pri file
|
|
$module_version = $version_rows[0];
|
|
chomp $module_version;
|
|
$module_version =~ s/^\s*QT\..*\.VERSION\s*=\s*([^#]+).*$/$1/;
|
|
$module_version =~ s/\s+$//;
|
|
my @versions = split(/\./, $module_version);
|
|
$module_major_version = $versions[0];
|
|
chomp $module_major_version;
|
|
$module_minor_version = $versions[1];
|
|
chomp $module_minor_version;
|
|
$module_patch_version = $versions[2];
|
|
chomp $module_patch_version;
|
|
}
|
|
}
|
|
print "WARNING: Module $lib\'s pri missing QT.<module>.VERSION variable! Private headers not versioned!\n" if (!$module_version);
|
|
|
|
my $pathtoheaders = "";
|
|
$pathtoheaders = $moduleheaders{$lib} if ($moduleheaders{$lib});
|
|
|
|
#information used after the syncing
|
|
my $pri_install_classes = "";
|
|
my $pri_install_files = "";
|
|
my $pri_install_pfiles = "";
|
|
|
|
my $libcapitals = $lib;
|
|
$libcapitals =~ y/a-z/A-Z/;
|
|
my $master_contents = "#ifndef QT_".$libcapitals."_MODULE_H\n#define QT_".$libcapitals."_MODULE_H\n";
|
|
|
|
#get dependencies
|
|
if(-e "$dir/" . basename($dir) . ".pro") {
|
|
if(open(F, "<$dir/" . basename($dir) . ".pro")) {
|
|
while(my $line = <F>) {
|
|
chomp $line;
|
|
if($line =~ /^ *QT *\+?= *([^\r\n]*)/) {
|
|
foreach(split(/ /, $1)) {
|
|
$_ =~ s/-private$//;
|
|
my $content = $mastercontent{$_};
|
|
$master_contents .= $content if ($content);
|
|
}
|
|
}
|
|
}
|
|
close(F);
|
|
}
|
|
}
|
|
|
|
#remove the old files
|
|
if($remove_stale) {
|
|
my @subdirs = ("$out_basedir/include/$lib");
|
|
foreach my $subdir (@subdirs) {
|
|
if (opendir DIR, $subdir) {
|
|
while(my $t = readdir(DIR)) {
|
|
my $file = "$subdir/$t";
|
|
if(-d $file) {
|
|
push @subdirs, $file unless($t eq "." || $t eq "..");
|
|
} else {
|
|
my @files = ($file);
|
|
#push @files, "$out_basedir/include/Qt/$t" if(-e "$out_basedir/include/Qt/$t");
|
|
foreach my $file (@files) {
|
|
my $remove_file = 0;
|
|
if(open(F, "<$file")) {
|
|
while(my $line = <F>) {
|
|
chomp $line;
|
|
if($line =~ /^\#include \"([^\"]*)\"$/) {
|
|
my $include = $1;
|
|
$include = $subdir . "/" . $include unless(substr($include, 0, 1) eq "/");
|
|
$remove_file = 1 unless(-e $include);
|
|
} else {
|
|
$remove_file = 0;
|
|
last;
|
|
}
|
|
}
|
|
close(F);
|
|
unlink $file if($remove_file);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir DIR;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
# create the version header files for each module
|
|
unless ($no_module_version_header) {
|
|
my $modulepri = $modulepris{$lib};
|
|
if (-e $modulepri) {
|
|
my $modulepriname = basename($modulepri);
|
|
my $moduleversionheader = "$modules{$lib}/" . lc($lib) . "version.h";
|
|
my $modulehexstring = sprintf("0x%02X%02X%02X", int($module_major_version), int($module_minor_version), int($module_patch_version));
|
|
open MODULE_VERSION_HEADER_FILE, ">$moduleversionheader";
|
|
print MODULE_VERSION_HEADER_FILE "/* This file was generated by syncqt with the info from sync.profile. */\n";
|
|
print MODULE_VERSION_HEADER_FILE "#ifndef QT_". uc($lib) . "_VERSION_H\n";
|
|
print MODULE_VERSION_HEADER_FILE "#define QT_". uc($lib) . "_VERSION_H\n";
|
|
print MODULE_VERSION_HEADER_FILE "\n";
|
|
print MODULE_VERSION_HEADER_FILE "#define " .uc($lib) . "_VERSION_STR \"" . $module_version . "\"\n";
|
|
print MODULE_VERSION_HEADER_FILE "\n";
|
|
print MODULE_VERSION_HEADER_FILE "#define " .uc($lib) . "_VERSION $modulehexstring\n", ;
|
|
print MODULE_VERSION_HEADER_FILE "\n";
|
|
print MODULE_VERSION_HEADER_FILE "#endif // QT_". uc($lib) . "_VERSION_H\n";
|
|
} elsif ($modulepri) {
|
|
print "WARNING: Module $lib\'s pri file '$modulepri' not found.\nSkipped creating module version header for $lib.\n";
|
|
}
|
|
}
|
|
|
|
#create the new ones
|
|
foreach my $current_dir (split(/;/, $dir)) {
|
|
my $headers_dir = $current_dir;
|
|
$headers_dir .= "/$pathtoheaders" if ($pathtoheaders);
|
|
#calc subdirs
|
|
my @subdirs = ($headers_dir);
|
|
foreach my $subdir (@subdirs) {
|
|
opendir DIR, $subdir or next;
|
|
while(my $t = readdir(DIR)) {
|
|
push @subdirs, "$subdir/$t" if(-d "$subdir/$t" && !($t eq ".") &&
|
|
!($t eq "..") && !($t eq ".obj") &&
|
|
!($t eq ".moc") && !($t eq ".rcc") &&
|
|
!($t eq ".uic") && !($t eq "build"));
|
|
}
|
|
closedir DIR;
|
|
}
|
|
|
|
#calc files and "copy" them
|
|
foreach my $subdir (@subdirs) {
|
|
my @headers = findFiles($subdir, "^[-a-z0-9_]*\\.h\$" , 0);
|
|
if (defined $inject_headers{$subdir}) {
|
|
foreach my $if ($inject_headers{$subdir}) {
|
|
@headers = grep(!/^\Q$if\E$/, @headers); #in case we configure'd previously
|
|
push @headers, "*".$if;
|
|
}
|
|
}
|
|
foreach my $header (@headers) {
|
|
my $shadow = ($header =~ s/^\*//);
|
|
$header = 0 if($header =~ /^ui_.*.h/);
|
|
foreach (@ignore_headers) {
|
|
$header = 0 if($header eq $_);
|
|
}
|
|
if($header) {
|
|
my $header_copies = 0;
|
|
#figure out if it is a public header
|
|
my $public_header = $header;
|
|
if($public_header =~ /_p.h$/ || $public_header =~ /_pch.h$/) {
|
|
$public_header = 0;
|
|
} else {
|
|
foreach (@ignore_for_master_contents) {
|
|
$public_header = 0 if($header eq $_);
|
|
}
|
|
}
|
|
|
|
my $iheader = $subdir . "/" . $header;
|
|
$iheader =~ s/^\Q$basedir\E/$out_basedir/ if ($shadow);
|
|
my @classes = $public_header ? classNames($iheader) : ();
|
|
if($showonly) {
|
|
print "$header [$lib]\n";
|
|
foreach(@classes) {
|
|
print "SYMBOL: $_\n";
|
|
}
|
|
} else {
|
|
my $ts = (stat($iheader))[9];
|
|
#find out all the places it goes..
|
|
my @headers;
|
|
if ($public_header) {
|
|
@headers = ( "$out_basedir/include/$lib/$header" );
|
|
|
|
# write forwarding headers to include/Qt
|
|
if ($lib ne "phonon" && $subdir =~ /^$quoted_basedir\/src/) {
|
|
my $file_name = "$out_basedir/include/Qt/$header";
|
|
my $file_op = '>';
|
|
my $header_content = '';
|
|
if (exists $colliding_headers{$file_name}) {
|
|
$file_op = '>>';
|
|
} else {
|
|
$colliding_headers{$file_name} = 1;
|
|
my $warning_msg = 'Inclusion of header files from include/Qt is deprecated.';
|
|
$header_content = "#ifndef QT_NO_QT_INCLUDE_WARN\n" .
|
|
" #if defined(__GNUC__)\n" .
|
|
" #warning \"$warning_msg\"\n" .
|
|
" #elif defined(_MSC_VER)\n" .
|
|
" #pragma message(\"WARNING: $warning_msg\")\n" .
|
|
" #endif\n".
|
|
"#endif\n\n";
|
|
}
|
|
$header_content .= '#include "' . "../$lib/$header" . "\"\n";
|
|
open HEADERFILE, $file_op, $file_name or die "unable to open '$file_name' : $!\n";
|
|
print HEADERFILE $header_content;
|
|
close HEADERFILE;
|
|
}
|
|
|
|
foreach my $full_class (@classes) {
|
|
my $header_base = basename($header);
|
|
# Strip namespaces:
|
|
my $class = $full_class;
|
|
$class =~ s/^.*:://;
|
|
# if ($class =~ m/::/) {
|
|
# class =~ s,::,/,g;
|
|
# }
|
|
$class_lib_map_contents .= "QT_CLASS_LIB($full_class, $lib, $header_base)\n";
|
|
$header_copies++ if(syncHeader("$out_basedir/include/$lib/$class", "$out_basedir/include/$lib/$header", 0, $ts));
|
|
|
|
# KDE-Compat headers for Phonon
|
|
if ($lib eq "phonon") {
|
|
$header_copies++ if (syncHeader("$out_basedir/include/phonon_compat/Phonon/$class", "$out_basedir/include/$lib/$header", 0, $ts));
|
|
}
|
|
}
|
|
} elsif ($create_private_headers) {
|
|
if ($module_version) {
|
|
@headers = ( "$out_basedir/include/$lib/$module_version/$lib/private/$header" );
|
|
} else {
|
|
@headers = ( "$out_basedir/include/$lib/private/$header" );
|
|
}
|
|
}
|
|
foreach(@headers) { #sync them
|
|
$header_copies++ if(syncHeader($_, $iheader, $copy_headers && !$shadow, $ts));
|
|
}
|
|
|
|
if($public_header) {
|
|
#put it into the master file
|
|
$master_contents .= "#include \"$public_header\"\n" if(shouldMasterInclude($iheader));
|
|
|
|
#deal with the install directives
|
|
if($public_header) {
|
|
my $pri_install_iheader = fixPaths($iheader, $current_dir);
|
|
foreach my $class (@classes) {
|
|
# Strip namespaces:
|
|
$class =~ s/^.*:://;
|
|
# if ($class =~ m/::/) {
|
|
# $class =~ s,::,/,g;
|
|
# }
|
|
my $class_header = fixPaths("$out_basedir/include/$lib/$class",
|
|
$current_dir) . " ";
|
|
$pri_install_classes .= $class_header
|
|
unless($pri_install_classes =~ $class_header);
|
|
}
|
|
$pri_install_files.= "$pri_install_iheader ";;
|
|
}
|
|
}
|
|
else {
|
|
my $pri_install_iheader = fixPaths($iheader, $current_dir);
|
|
$pri_install_pfiles.= "$pri_install_iheader ";;
|
|
}
|
|
}
|
|
print "header created for $iheader ($header_copies)\n" if($header_copies > 0 && !$quiet);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# close the master include:
|
|
$master_contents .= "#endif\n";
|
|
|
|
unless($showonly) {
|
|
my @master_includes;
|
|
push @master_includes, "$out_basedir/include/$lib/$lib";
|
|
push @master_includes, "$out_basedir/include/phonon_compat/Phonon/Phonon" if ($lib eq "phonon");
|
|
foreach my $master_include (@master_includes) {
|
|
#generate the "master" include file
|
|
my @tmp = split(/;/,$modules{$lib});
|
|
$pri_install_files .= fixPaths($master_include, $tmp[0]) . " "; #get the master file installed too
|
|
if($master_include && -e $master_include) {
|
|
open MASTERINCLUDE, "<$master_include";
|
|
local $/;
|
|
binmode MASTERINCLUDE;
|
|
my $oldmaster = <MASTERINCLUDE>;
|
|
close MASTERINCLUDE;
|
|
$oldmaster =~ s/\r//g; # remove \r's , so comparison is ok on all platforms
|
|
$master_include = 0 if($oldmaster eq $master_contents);
|
|
}
|
|
if($master_include && $master_contents) {
|
|
my $master_dir = dirname($master_include);
|
|
mkpath $master_dir, !$quiet;
|
|
print "header (master) created for $lib\n" unless $quiet;
|
|
open MASTERINCLUDE, ">$master_include";
|
|
print MASTERINCLUDE $master_contents;
|
|
close MASTERINCLUDE;
|
|
}
|
|
}
|
|
|
|
#handle the headers.pri for each module
|
|
my $headers_pri_contents = "";
|
|
$headers_pri_contents .= "SYNCQT.HEADER_FILES = $pri_install_files\n";
|
|
$headers_pri_contents .= "SYNCQT.HEADER_CLASSES = $pri_install_classes\n";
|
|
$headers_pri_contents .= "SYNCQT.PRIVATE_HEADER_FILES = $pri_install_pfiles\n";
|
|
my $headers_pri_file = "$out_basedir/include/$lib/headers.pri";
|
|
if(-e $headers_pri_file) {
|
|
open HEADERS_PRI_FILE, "<$headers_pri_file";
|
|
local $/;
|
|
binmode HEADERS_PRI_FILE;
|
|
my $old_headers_pri_contents = <HEADERS_PRI_FILE>;
|
|
close HEADERS_PRI_FILE;
|
|
$old_headers_pri_contents =~ s/\r//g; # remove \r's , so comparison is ok on all platforms
|
|
$headers_pri_file = 0 if($old_headers_pri_contents eq $headers_pri_contents);
|
|
}
|
|
if($headers_pri_file && $master_contents) {
|
|
my $headers_pri_dir = dirname($headers_pri_file);
|
|
mkpath $headers_pri_dir, !$quiet;
|
|
print "headers.pri file created for $lib\n" unless $quiet;
|
|
open HEADERS_PRI_FILE, ">$headers_pri_file";
|
|
print HEADERS_PRI_FILE $headers_pri_contents;
|
|
close HEADERS_PRI_FILE;
|
|
}
|
|
|
|
# create forwarding module pri in qtbase/mkspecs/modules
|
|
if ($module_fwd) {
|
|
my $modulepri = $modulepris{$lib};
|
|
if (-e $modulepri) {
|
|
my $modulepriname = basename($modulepri);
|
|
mkpath($module_fwd);
|
|
my $moduleprifwd = "$module_fwd/$modulepriname";
|
|
my $mod_base = $developer_build ? $basedir : $out_basedir;
|
|
my $mod_component_base = $developer_build ? $qtbasedir : $out_basedir;
|
|
open MODULE_PRI_FILE, ">$moduleprifwd" or die("Could not open $moduleprifwd for writing");
|
|
print MODULE_PRI_FILE "QT_MODULE_BASE = $mod_base\n";
|
|
print MODULE_PRI_FILE "QT_MODULE_BIN_BASE = $mod_component_base/bin\n";
|
|
print MODULE_PRI_FILE "QT_MODULE_INCLUDE_BASE = $out_basedir/include\n";
|
|
print MODULE_PRI_FILE "QT_MODULE_IMPORT_BASE = $mod_component_base/imports\n";
|
|
print MODULE_PRI_FILE "QT_MODULE_LIB_BASE = $mod_component_base/lib\n";
|
|
print MODULE_PRI_FILE "QT_MODULE_PLUGIN_BASE = $mod_component_base/plugins\n";
|
|
print MODULE_PRI_FILE "include($modulepri)\n";
|
|
close MODULE_PRI_FILE;
|
|
utime(time, (stat($modulepri))[9], $moduleprifwd);
|
|
if ($cache_module_fwd) {
|
|
my $cacheStatement = "QMAKE_EXTRA_MODULE_FORWARDS = \"$module_fwd\"";
|
|
my $cacheFile = "$out_basedir/.qmake.cache";
|
|
my $existingQmakeCache = fileContents($cacheFile);
|
|
# Skip if it's already there.
|
|
if ($existingQmakeCache !~ $cacheStatement) {
|
|
open QMAKE_CACHE_FILE, ">>$cacheFile" or die("Could not open $cacheFile for writing");
|
|
print QMAKE_CACHE_FILE "$cacheStatement\n";
|
|
close(QMAKE_CACHE_FILE);
|
|
}
|
|
}
|
|
} elsif ($modulepri) {
|
|
print "WARNING: Module $lib\'s pri file '$modulepri' not found.\nSkipped creating forwarding pri for $lib.\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
unless($showonly || !$create_uic_class_map) {
|
|
my $class_lib_map = "$out_basedir/src/tools/uic/qclass_lib_map.h";
|
|
if(-e $class_lib_map) {
|
|
open CLASS_LIB_MAP, "<$class_lib_map";
|
|
local $/;
|
|
binmode CLASS_LIB_MAP;
|
|
my $old_class_lib_map_contents = <CLASS_LIB_MAP>;
|
|
close CLASS_LIB_MAP;
|
|
$old_class_lib_map_contents =~ s/\r//g; # remove \r's , so comparison is ok on all platforms
|
|
$class_lib_map = 0 if($old_class_lib_map_contents eq $class_lib_map_contents);
|
|
}
|
|
if($class_lib_map) {
|
|
my $class_lib_map_dir = dirname($class_lib_map);
|
|
mkpath $class_lib_map_dir, !$quiet;
|
|
open CLASS_LIB_MAP, ">$class_lib_map";
|
|
print CLASS_LIB_MAP $class_lib_map_contents;
|
|
close CLASS_LIB_MAP;
|
|
}
|
|
}
|
|
|
|
if($check_includes) {
|
|
for my $lib (keys(%modules)) {
|
|
#calc subdirs
|
|
my @subdirs = ($modules{$lib});
|
|
foreach my $subdir (@subdirs) {
|
|
opendir DIR, $subdir or die "Huh, directory ".$subdir." cannot be opened.";
|
|
while(my $t = readdir(DIR)) {
|
|
push @subdirs, "$subdir/$t" if(-d "$subdir/$t" && !($t eq ".") &&
|
|
!($t eq "..") && !($t eq ".obj") &&
|
|
!($t eq ".moc") && !($t eq ".rcc") &&
|
|
!($t eq ".uic") && !($t eq "build"));
|
|
}
|
|
closedir DIR;
|
|
}
|
|
|
|
foreach my $subdir (@subdirs) {
|
|
my $header_skip_qt_module_test = 0;
|
|
foreach(@ignore_for_qt_module_check) {
|
|
foreach (split(/;/, $_)) {
|
|
$header_skip_qt_module_test = 1 if ($subdir =~ /^$_/);
|
|
}
|
|
}
|
|
my @headers = findFiles($subdir, "^[-a-z0-9_]*\\.h\$" , 0);
|
|
foreach my $header (@headers) {
|
|
my $header_skip_qt_begin_header_test = 0;
|
|
my $header_skip_qt_begin_namespace_test = 0;
|
|
$header = 0 if($header =~ /^ui_.*.h/);
|
|
foreach (@ignore_headers) {
|
|
$header = 0 if($header eq $_);
|
|
}
|
|
if($header) {
|
|
my $public_header = $header;
|
|
if($public_header =~ /_p.h$/ || $public_header =~ /_pch.h$/) {
|
|
$public_header = 0;
|
|
} else {
|
|
foreach (@ignore_for_master_contents) {
|
|
$public_header = 0 if($header eq $_);
|
|
}
|
|
if($public_header) {
|
|
foreach (@ignore_for_include_check) {
|
|
$public_header = 0 if($header eq $_);
|
|
}
|
|
foreach(@ignore_for_qt_begin_header_check) {
|
|
$header_skip_qt_begin_header_test = 1 if ($header eq $_);
|
|
}
|
|
foreach(@ignore_for_qt_begin_namespace_check) {
|
|
$header_skip_qt_begin_namespace_test = 1 if ($header eq $_);
|
|
}
|
|
}
|
|
}
|
|
|
|
my $iheader = $subdir . "/" . $header;
|
|
if($public_header) {
|
|
if(open(F, "<$iheader")) {
|
|
my $qt_module_found = 0;
|
|
my $qt_begin_header_found = 0;
|
|
my $qt_end_header_found = 0;
|
|
my $qt_begin_namespace_found = 0;
|
|
my $qt_end_namespace_found = 0;
|
|
my $line;
|
|
while($line = <F>) {
|
|
chomp $line;
|
|
my $output_line = 1;
|
|
if($line =~ /^ *\# *pragma (qt_no_included_check|qt_sync_stop_processing)/) {
|
|
last;
|
|
} elsif($line =~ /^ *\# *include/) {
|
|
my $include = $line;
|
|
if($line =~ /<.*>/) {
|
|
$include =~ s,.*<(.*)>.*,$1,;
|
|
} elsif($line =~ /".*"/) {
|
|
$include =~ s,.*"(.*)".*,$1,;
|
|
} else {
|
|
$include = 0;
|
|
}
|
|
if($include) {
|
|
for my $trylib (keys(%modules)) {
|
|
if(-e "$out_basedir/include/$trylib/$include") {
|
|
print "WARNING: $iheader includes $include when it should include $trylib/$include\n";
|
|
}
|
|
}
|
|
}
|
|
} elsif ($header_skip_qt_begin_header_test == 0 and $line =~ /^QT_BEGIN_HEADER\s*$/) {
|
|
$qt_begin_header_found = 1;
|
|
} elsif ($header_skip_qt_begin_header_test == 0 and $line =~ /^QT_END_HEADER\s*$/) {
|
|
$qt_end_header_found = 1;
|
|
} elsif ($header_skip_qt_begin_namespace_test == 0 and $line =~ /^QT_BEGIN_NAMESPACE\s*$/) {
|
|
$qt_begin_namespace_found = 1;
|
|
} elsif ($header_skip_qt_begin_namespace_test == 0 and $line =~ /^QT_END_NAMESPACE\s*$/) {
|
|
$qt_end_namespace_found = 1;
|
|
} elsif ($header_skip_qt_module_test == 0 and $line =~ /^QT_MODULE\(.*\)\s*$/) {
|
|
$qt_module_found = 1;
|
|
}
|
|
}
|
|
if ($header_skip_qt_begin_header_test == 0) {
|
|
if ($qt_begin_header_found == 0) {
|
|
print "WARNING: $iheader does not include QT_BEGIN_HEADER\n";
|
|
}
|
|
|
|
if ($qt_begin_header_found && $qt_end_header_found == 0) {
|
|
print "WARNING: $iheader has QT_BEGIN_HEADER but no QT_END_HEADER\n";
|
|
}
|
|
}
|
|
|
|
if ($header_skip_qt_begin_namespace_test == 0) {
|
|
if ($qt_begin_namespace_found == 0) {
|
|
print "WARNING: $iheader does not include QT_BEGIN_NAMESPACE\n";
|
|
}
|
|
|
|
if ($qt_begin_namespace_found && $qt_end_namespace_found == 0) {
|
|
print "WARNING: $iheader has QT_BEGIN_NAMESPACE but no QT_END_NAMESPACE\n";
|
|
}
|
|
}
|
|
|
|
if ($header_skip_qt_module_test == 0) {
|
|
if ($qt_module_found == 0) {
|
|
print "WARNING: $iheader does not include QT_MODULE\n";
|
|
}
|
|
}
|
|
close(F);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
exit 0;
|