| #!/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; |