| #!/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 Config; |
| use strict; |
| |
| for (my $i = 0; $i < $#ARGV; $i++) { |
| if ($ARGV[$i] eq "-base-dir" && $i < $#ARGV - 1) { |
| $ENV{"QTDIR"} = $ARGV[$i + 1]; |
| last; |
| } |
| } |
| |
| die "syncqt: QTDIR not defined" if ! $ENV{"QTDIR"}; # sanity check |
| |
| # global variables |
| my $isunix = 0; |
| my $basedir = $ENV{"QTDIR"}; |
| $basedir =~ s=\\=/=g; |
| my %modules = ( # path to module name map |
| "QtGui" => "$basedir/src/gui", |
| "QtOpenGL" => "$basedir/src/opengl", |
| "QtOpenVG" => "$basedir/src/openvg", |
| "QtCore" => "$basedir/src/corelib", |
| "QtXml" => "$basedir/src/xml", |
| "QtXmlPatterns" => "$basedir/src/xmlpatterns", |
| "QtSql" => "$basedir/src/sql", |
| "QtNetwork" => "$basedir/src/network", |
| "QtSvg" => "$basedir/src/svg", |
| "QtDeclarative" => "$basedir/src/declarative", |
| "QtScript" => "$basedir/src/script", |
| "QtScriptTools" => "$basedir/src/scripttools", |
| "Qt3Support" => "$basedir/src/qt3support", |
| "ActiveQt" => "$basedir/src/activeqt", |
| "QtTest" => "$basedir/src/testlib", |
| "QtHelp" => "$basedir/tools/assistant/lib", |
| "QtDesigner" => "$basedir/tools/designer/src/lib", |
| "QtUiTools" => "$basedir/tools/designer/src/uitools", |
| "QtDBus" => "$basedir/src/dbus", |
| "QtWebKit" => "$basedir/src/3rdparty/webkit/WebCore", |
| "phonon" => "$basedir/src/phonon", |
| "QtMultimedia" => "$basedir/src/multimedia", |
| "QtMeeGoGraphicsSystemHelper" => "$basedir/tools/qmeegographicssystemhelper", |
| ); |
| my %moduleheaders = ( # restrict the module headers to those found in relative path |
| "QtWebKit" => "../WebKit/qt/Api", |
| "phonon" => "../3rdparty/phonon/phonon", |
| ); |
| |
| #$modules{"QtCore"} .= ";$basedir/mkspecs/" . $ENV{"MKSPEC"} if defined $ENV{"MKSPEC"}; |
| |
| # global variables (modified by options) |
| 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 = 1; |
| my $create_private_headers = 1; |
| my @modules_to_sync ; |
| $force_relative = 1 if ( -d "/System/Library/Frameworks" ); |
| my $out_basedir = $basedir; |
| $out_basedir =~ s=\\=/=g; |
| |
| # functions ---------------------------------------------------------- |
| |
| ###################################################################### |
| # Syntax: showUsage() |
| # Params: -none- |
| # |
| # Purpose: Show the usage of the script. |
| # Returns: -none- |
| ###################################################################### |
| sub showUsage |
| { |
| print "$0 usage:\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 " -quiet Only report problems, not activity (default: " . ($quiet ? "yes" : "no") . ")\n"; |
| print " -separate-module <NAME>:<PROFILEDIR>:<HEADERDIR> Create headers for <NAME> with original headers in <HEADERDIR> relative to <PROFILEDIR> \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) = @_; |
| if(basename($iheader) eq "qglobal.h") { |
| push @ret, "QtGlobal"; |
| } elsif(basename($iheader) eq "qendian.h") { |
| push @ret, "QtEndian"; |
| } elsif(basename($iheader) eq "qconfig.h") { |
| push @ret, "QtConfig"; |
| } elsif(basename($iheader) eq "qplugin.h") { |
| push @ret, "QtPlugin"; |
| } elsif(basename($iheader) eq "qalgorithms.h") { |
| push @ret, "QtAlgorithms"; |
| } elsif(basename($iheader) eq "qcontainerfwd.h") { |
| push @ret, "QtContainerFwd"; |
| } elsif(basename($iheader) eq "qdebug.h") { |
| push @ret, "QtDebug"; |
| } elsif(basename($iheader) eq "qevent.h") { |
| push @ret, "QtEvents"; |
| } elsif(basename($iheader) eq "qnamespace.h") { |
| push @ret, "Qt" |
| } elsif(basename($iheader) eq "qssl.h") { |
| push @ret, "QSsl"; |
| } elsif(basename($iheader) eq "qtest.h") { |
| push @ret, "QTest" |
| } elsif(basename($iheader) eq "qtconcurrentmap.h") { |
| push @ret, "QtConcurrentMap" |
| } elsif(basename($iheader) eq "qtconcurrentfilter.h") { |
| push @ret, "QtConcurrentFilter" |
| } elsif(basename($iheader) eq "qtconcurrentrun.h") { |
| push @ret, "QtConcurrentRun" |
| } elsif(basename($iheader) eq "qaudio.h") { |
| push @ret, "QAudio" |
| } |
| |
| 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) = @_; |
| $dir =~ s=^$basedir/=$out_basedir/= if(!($basedir eq $out_basedir)); |
| $file =~ s=\\=/=g; |
| $file =~ s/\+/\\+/g; |
| $dir =~ 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 |
| 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,^$tmp/,); |
| $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,^$match_dir,$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 =~ /^$basedir/)) { |
| my $t = getcwd(); |
| my $c = -1; |
| my $p = "../"; |
| $t =~ s-^$basedir/--; |
| $p .= "../" while( ($c = index( $t, "/", $c + 1)) != -1 ); |
| $file =~ s-^$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; |
| } |
| |
| # -------------------------------------------------------------------- |
| # "main" function |
| # -------------------------------------------------------------------- |
| |
| while ( @ARGV ) { |
| my $var = 0; |
| my $val = 0; |
| |
| #parse |
| my $arg = shift @ARGV; |
| if ($arg eq "-h" || $arg eq "-help" || $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 =~ /^-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 "-base-dir") { |
| # skip, it's been dealt with at the top of the file |
| shift @ARGV; |
| next; |
| } |
| |
| #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; |
| $create_private_headers = 0; |
| } 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; |
| } |
| } |
| @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; |
| |
| my @ignore_headers = (); |
| my $class_lib_map_contents = ""; |
| my @ignore_for_master_contents = ( "qt.h", "qpaintdevicedefs.h" ); |
| my @ignore_for_include_check = ( "qatomic.h" ); |
| my @ignore_for_qt_begin_header_check = ( "qiconset.h", "qconfig.h", "qconfig-dist.h", "qconfig-large.h", "qconfig-medium.h", "qconfig-minimal.h", "qconfig-small.h", "qfeatures.h", "qt_windows.h" ); |
| my @ignore_for_qt_begin_namespace_check = ( "qconfig.h", "qconfig-dist.h", "qconfig-large.h", "qconfig-medium.h", "qconfig-minimal.h", "qconfig-small.h", "qfeatures.h", "qatomic_arch.h", "qatomic_windowsce.h", "qt_windows.h", "qatomic_macosx.h" ); |
| my @ignore_for_qt_module_check = ( "$modules{QtCore}/arch", "$modules{QtCore}/global", "$modules{QtSql}/drivers", "$modules{QtTest}", "$modules{QtDesigner}", "$modules{QtUiTools}", "$modules{QtDBus}", "$modules{phonon}" ); |
| my %colliding_headers = (); |
| my %inject_headers = ( "$basedir/src/corelib/global" => ( "qconfig.h" ) ); # all from build dir |
| |
| foreach my $lib (@modules_to_sync) { |
| #iteration info |
| my $dir = $modules{$lib}; |
| 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)) { |
| $master_contents .= "#include <QtCore/QtCore>\n" if($_ eq "core"); |
| $master_contents .= "#include <QtGui/QtGui>\n" if($_ eq "gui"); |
| $master_contents .= "#include <QtNetwork/QtNetwork>\n" if($_ eq "network"); |
| $master_contents .= "#include <QtSvg/QtSvg>\n" if($_ eq "svg"); |
| $master_contents .= "#include <QtDeclarative/QtDeclarative>\n" if($_ eq "declarative"); |
| $master_contents .= "#include <QtScript/QtScript>\n" if($_ eq "script"); |
| $master_contents .= "#include <QtScriptTools/QtScriptTools>\n" if($_ eq "scripttools"); |
| $master_contents .= "#include <Qt3Support/Qt3Support>\n" if($_ eq "qt3support"); |
| $master_contents .= "#include <QtSql/QtSql>\n" if($_ eq "sql"); |
| $master_contents .= "#include <QtXml/QtXml>\n" if($_ eq "xml"); |
| $master_contents .= "#include <QtXmlPatterns/QtXmlPatterns>\n" if($_ eq "xmlpatterns"); |
| $master_contents .= "#include <QtOpenGL/QtOpenGL>\n" if($_ eq "opengl"); |
| $master_contents .= "#include <QtOpenVG/QtOpenVG>\n" if($_ eq "openvg"); |
| } |
| } |
| } |
| 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 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 =~ /^$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) { |
| @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; |
| } |
| } |
| } |
| 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; |