Simplify building with ASan
[WebKit-https.git] / Tools / Scripts / webkitdirs.pm
1 # Copyright (C) 2005-2007, 2010-2014 Apple Inc. All rights reserved.
2 # Copyright (C) 2009 Google Inc. All rights reserved.
3 # Copyright (C) 2011 Research In Motion Limited. All rights reserved.
4 # Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
5 #
6 # Redistribution and use in source and binary forms, with or without
7 # modification, are permitted provided that the following conditions
8 # are met:
9 #
10 # 1.  Redistributions of source code must retain the above copyright
11 #     notice, this list of conditions and the following disclaimer. 
12 # 2.  Redistributions in binary form must reproduce the above copyright
13 #     notice, this list of conditions and the following disclaimer in the
14 #     documentation and/or other materials provided with the distribution. 
15 # 3.  Neither the name of Apple Inc. ("Apple") nor the names of
16 #     its contributors may be used to endorse or promote products derived
17 #     from this software without specific prior written permission. 
18 #
19 # THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
20 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 # DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
23 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 # Module to share code to get to WebKit directories.
31
32 use strict;
33 use version;
34 use warnings;
35 use Config;
36 use Digest::MD5 qw(md5_hex);
37 use FindBin;
38 use File::Basename;
39 use File::Path qw(mkpath rmtree);
40 use File::Spec;
41 use File::stat;
42 use List::Util;
43 use POSIX;
44 use VCSUtils;
45
46 BEGIN {
47    use Exporter   ();
48    our ($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);
49    $VERSION     = 1.00;
50    @ISA         = qw(Exporter);
51    @EXPORT      = qw(
52        &XcodeCoverageSupportOptions
53        &XcodeOptionString
54        &XcodeOptionStringNoConfig
55        &XcodeOptions
56        &XcodeStaticAnalyzerOption
57        &appDisplayNameFromBundle
58        &baseProductDir
59        &chdirWebKit
60        &checkFrameworks
61        &cmakeBasedPortArguments
62        &cmakeBasedPortName
63        &currentSVNRevision
64        &debugSafari
65        &findOrCreateSimulatorForIOSDevice
66        &installAndLaunchIOSWebKitAppInSimulator
67        &iosSimulatorDeviceByName
68        &nmPath
69        &openIOSSimulator
70        &passedConfiguration
71        &printHelpAndExitForRunAndDebugWebKitAppIfNeeded
72        &productDir
73        &quitIOSSimulator
74        &runIOSWebKitApp
75        &runMacWebKitApp
76        &safariPath
77        &setConfiguration
78        &setupMacWebKitEnvironment
79        &sharedCommandLineOptions
80        &sharedCommandLineOptionsUsage
81        USE_OPEN_COMMAND
82    );
83    %EXPORT_TAGS = ( );
84    @EXPORT_OK   = ();
85 }
86
87 use constant USE_OPEN_COMMAND => 1; # Used in runMacWebKitApp().
88 use constant INCLUDE_OPTIONS_FOR_DEBUGGING => 1;
89
90 our @EXPORT_OK;
91
92 my $architecture;
93 my $asanIsEnabled;
94 my $numberOfCPUs;
95 my $maxCPULoad;
96 my $baseProductDir;
97 my @baseProductDirOption;
98 my $configuration;
99 my $xcodeSDK;
100 my $configurationForVisualStudio;
101 my $configurationProductDir;
102 my $sourceDir;
103 my $currentSVNRevision;
104 my $debugger;
105 my $didLoadIPhoneSimulatorNotification;
106 my $nmPath;
107 my $osXVersion;
108 my $generateDsym;
109 my $isGtk;
110 my $isWinCairo;
111 my $isWin64;
112 my $isEfl;
113 my $isInspectorFrontend;
114 my $isWK2;
115 my $shouldTargetWebProcess;
116 my $shouldUseXPCServiceForWebProcess;
117 my $shouldUseGuardMalloc;
118 my $xcodeVersion;
119
120 # Variables for Win32 support
121 my $programFilesPath;
122 my $vcBuildPath;
123 my $vsInstallDir;
124 my $vsVersion;
125 my $windowsSourceDir;
126 my $winVersion;
127 my $willUseVCExpressWhenBuilding = 0;
128
129 # Defined in VCSUtils.
130 sub exitStatus($);
131
132 sub findMatchingArguments($$);
133 sub hasArgument($$);
134
135 sub determineSourceDir
136 {
137     return if $sourceDir;
138     $sourceDir = $FindBin::Bin;
139     $sourceDir =~ s|/+$||; # Remove trailing '/' as we would die later
140
141     # walks up path checking each directory to see if it is the main WebKit project dir, 
142     # defined by containing Sources, WebCore, and WebKit
143     until ((-d "$sourceDir/Source" && -d "$sourceDir/Source/WebCore" && -d "$sourceDir/Source/WebKit") || (-d "$sourceDir/Internal" && -d "$sourceDir/OpenSource"))
144     {
145         if ($sourceDir !~ s|/[^/]+$||) {
146             die "Could not find top level webkit directory above source directory using FindBin.\n";
147         }
148     }
149
150     $sourceDir = "$sourceDir/OpenSource" if -d "$sourceDir/OpenSource";
151 }
152
153 sub currentPerlPath()
154 {
155     my $thisPerl = $^X;
156     if ($^O ne 'VMS') {
157         $thisPerl .= $Config{_exe} unless $thisPerl =~ m/$Config{_exe}$/i;
158     }
159     return $thisPerl;
160 }
161
162 # used for scripts which are stored in a non-standard location
163 sub setSourceDir($)
164 {
165     ($sourceDir) = @_;
166 }
167
168 sub determineNinjaVersion
169 {
170     chomp(my $ninjaVersion = `ninja --version`);
171     return $ninjaVersion;
172 }
173
174 sub determineXcodeVersion
175 {
176     return if defined $xcodeVersion;
177     my $xcodebuildVersionOutput = `xcodebuild -version`;
178     $xcodeVersion = ($xcodebuildVersionOutput =~ /Xcode ([0-9](\.[0-9]+)*)/) ? $1 : "3.0";
179 }
180
181 sub readXcodeUserDefault($)
182 {
183     my ($unprefixedKey) = @_;
184
185     determineXcodeVersion();
186
187     my $xcodeDefaultsDomain = (eval "v$xcodeVersion" lt v4) ? "com.apple.Xcode" : "com.apple.dt.Xcode";
188     my $xcodeDefaultsPrefix = (eval "v$xcodeVersion" lt v4) ? "PBX" : "IDE";
189     my $devnull = File::Spec->devnull();
190
191     my $value = `defaults read $xcodeDefaultsDomain ${xcodeDefaultsPrefix}${unprefixedKey} 2> ${devnull}`;
192     return if $?;
193
194     chomp $value;
195     return $value;
196 }
197
198 sub determineBaseProductDir
199 {
200     return if defined $baseProductDir;
201     determineSourceDir();
202
203     my $setSharedPrecompsDir;
204     $baseProductDir = $ENV{"WEBKIT_OUTPUTDIR"};
205
206     if (!defined($baseProductDir) and isAppleMacWebKit()) {
207         # Silently remove ~/Library/Preferences/xcodebuild.plist which can
208         # cause build failure. The presence of
209         # ~/Library/Preferences/xcodebuild.plist can prevent xcodebuild from
210         # respecting global settings such as a custom build products directory
211         # (<rdar://problem/5585899>).
212         my $personalPlistFile = $ENV{HOME} . "/Library/Preferences/xcodebuild.plist";
213         if (-e $personalPlistFile) {
214             unlink($personalPlistFile) || die "Could not delete $personalPlistFile: $!";
215         }
216
217         determineXcodeVersion();
218
219         if (eval "v$xcodeVersion" ge v4) {
220             my $buildLocationStyle = join '', readXcodeUserDefault("BuildLocationStyle");
221             if ($buildLocationStyle eq "Custom") {
222                 my $buildLocationType = join '', readXcodeUserDefault("CustomBuildLocationType");
223                 # FIXME: Read CustomBuildIntermediatesPath and set OBJROOT accordingly.
224                 $baseProductDir = readXcodeUserDefault("CustomBuildProductsPath") if $buildLocationType eq "Absolute";
225             }
226
227             # DeterminedByTargets corresponds to a setting of "Legacy" in Xcode.
228             # It is the only build location style for which SHARED_PRECOMPS_DIR is not
229             # overridden when building from within Xcode.
230             $setSharedPrecompsDir = 1 if $buildLocationStyle ne "DeterminedByTargets";
231         }
232
233         if (!defined($baseProductDir)) {
234             $baseProductDir = join '', readXcodeUserDefault("ApplicationwideBuildSettings");
235             $baseProductDir = $1 if $baseProductDir =~ /SYMROOT\s*=\s*\"(.*?)\";/s;
236         }
237
238         undef $baseProductDir unless $baseProductDir =~ /^\//;
239     }
240
241     if (!defined($baseProductDir)) { # Port-specific checks failed, use default
242         $baseProductDir = "$sourceDir/WebKitBuild";
243     }
244
245     if (isGit() && isGitBranchBuild()) {
246         my $branch = gitBranch();
247         $baseProductDir = "$baseProductDir/$branch";
248     }
249
250     if (isAppleMacWebKit()) {
251         $baseProductDir =~ s|^\Q$(SRCROOT)/..\E$|$sourceDir|;
252         $baseProductDir =~ s|^\Q$(SRCROOT)/../|$sourceDir/|;
253         $baseProductDir =~ s|^~/|$ENV{HOME}/|;
254         die "Can't handle Xcode product directory with a ~ in it.\n" if $baseProductDir =~ /~/;
255         die "Can't handle Xcode product directory with a variable in it.\n" if $baseProductDir =~ /\$/;
256         @baseProductDirOption = ("SYMROOT=$baseProductDir", "OBJROOT=$baseProductDir");
257         push(@baseProductDirOption, "SHARED_PRECOMPS_DIR=${baseProductDir}/PrecompiledHeaders") if $setSharedPrecompsDir;
258     }
259
260     if (isCygwin()) {
261         my $dosBuildPath = `cygpath --windows \"$baseProductDir\"`;
262         chomp $dosBuildPath;
263         $ENV{"WEBKIT_OUTPUTDIR"} = $dosBuildPath;
264         my $unixBuildPath = `cygpath --unix \"$baseProductDir\"`;
265         chomp $unixBuildPath;
266         $baseProductDir = $unixBuildPath;
267     }
268 }
269
270 sub setBaseProductDir($)
271 {
272     ($baseProductDir) = @_;
273 }
274
275 sub determineConfiguration
276 {
277     return if defined $configuration;
278     determineBaseProductDir();
279     if (open CONFIGURATION, "$baseProductDir/Configuration") {
280         $configuration = <CONFIGURATION>;
281         close CONFIGURATION;
282     }
283     if ($configuration) {
284         chomp $configuration;
285         # compatibility for people who have old Configuration files
286         $configuration = "Release" if $configuration eq "Deployment";
287         $configuration = "Debug" if $configuration eq "Development";
288     } else {
289         $configuration = "Release";
290     }
291
292     if ($configuration && isWinCairo()) {
293         unless ($configuration =~ /_WinCairo$/) {
294             $configuration .= "_WinCairo";
295         }
296     }
297 }
298
299 sub determineArchitecture
300 {
301     return if defined $architecture;
302     # make sure $architecture is defined in all cases
303     $architecture = "";
304
305     determineBaseProductDir();
306     determineXcodeSDK();
307
308     if (isAppleMacWebKit()) {
309         if (open ARCHITECTURE, "$baseProductDir/Architecture") {
310             $architecture = <ARCHITECTURE>;
311             close ARCHITECTURE;
312         }
313         if ($architecture) {
314             chomp $architecture;
315         } else {
316             if (not defined $xcodeSDK or $xcodeSDK =~ /^(\/$|macosx)/) {
317                 my $supports64Bit = `sysctl -n hw.optional.x86_64`;
318                 chomp $supports64Bit;
319                 $architecture = 'x86_64' if $supports64Bit;
320             } elsif ($xcodeSDK =~ /^iphonesimulator/) {
321                 $architecture = 'x86_64';
322             } elsif ($xcodeSDK =~ /^iphoneos/) {
323                 $architecture = 'armv7';
324             }
325         }
326     } elsif (isEfl() || isGtk()) {
327         my $host_processor = "";
328         $host_processor = `cmake --system-information | grep CMAKE_SYSTEM_PROCESSOR`;
329         if ($host_processor =~ m/^CMAKE_SYSTEM_PROCESSOR \"([^"]+)\"/) {
330             # We have a configured build tree; use it.
331             $architecture = $1;
332             $architecture = 'x86_64' if $architecture eq 'amd64';
333         }
334     }
335
336     if (!$architecture && (isGtk() || isAppleMacWebKit() || isEfl())) {
337         # Fall back to output of `arch', if it is present.
338         $architecture = `arch`;
339         chomp $architecture;
340     }
341
342     if (!$architecture && (isGtk() || isAppleMacWebKit() || isEfl())) {
343         # Fall back to output of `uname -m', if it is present.
344         $architecture = `uname -m`;
345         chomp $architecture;
346     }
347
348     $architecture = 'x86_64' if ($architecture =~ /amd64/ && isBSD());
349 }
350
351 sub determineASanIsEnabled
352 {
353     return if defined $asanIsEnabled;
354     determineBaseProductDir();
355
356     $asanIsEnabled = 0;
357     my $asanConfigurationValue;
358
359     if (open ASAN, "$baseProductDir/ASan") {
360         $asanConfigurationValue = <ASAN>;
361         close ASAN;
362         chomp $asanConfigurationValue;
363         $asanIsEnabled = 1 if $asanConfigurationValue eq "YES";
364     }
365 }
366
367 sub determineNumberOfCPUs
368 {
369     return if defined $numberOfCPUs;
370     if (defined($ENV{NUMBER_OF_PROCESSORS})) {
371         $numberOfCPUs = $ENV{NUMBER_OF_PROCESSORS};
372     } elsif (isLinux()) {
373         # First try the nproc utility, if it exists. If we get no
374         # results fall back to just interpretting /proc directly.
375         chomp($numberOfCPUs = `nproc --all 2> /dev/null`);
376         if ($numberOfCPUs eq "") {
377             $numberOfCPUs = (grep /processor/, `cat /proc/cpuinfo`);
378         }
379     } elsif (isWindows() || isCygwin()) {
380         # Assumes cygwin
381         $numberOfCPUs = `ls /proc/registry/HKEY_LOCAL_MACHINE/HARDWARE/DESCRIPTION/System/CentralProcessor | wc -w`;
382     } elsif (isDarwin() || isBSD()) {
383         chomp($numberOfCPUs = `sysctl -n hw.ncpu`);
384     }
385 }
386
387 sub determineMaxCPULoad
388 {
389     return if defined $maxCPULoad;
390     if (defined($ENV{MAX_CPU_LOAD})) {
391         $maxCPULoad = $ENV{MAX_CPU_LOAD};
392     }
393 }
394
395 sub jscPath($)
396 {
397     my ($productDir) = @_;
398     my $jscName = "jsc";
399     $jscName .= "_debug"  if configuration() eq "Debug_All";
400     $jscName .= ".exe" if (isWindows() || isCygwin());
401     return "$productDir/$jscName" if -e "$productDir/$jscName";
402     return "$productDir/JavaScriptCore.framework/Resources/$jscName";
403 }
404
405 sub argumentsForConfiguration()
406 {
407     determineConfiguration();
408     determineArchitecture();
409     determineXcodeSDK();
410
411     my @args = ();
412     # FIXME: Is it necessary to pass --debug, --release, --32-bit or --64-bit?
413     # These are determined automatically from stored configuration.
414     push(@args, '--debug') if ($configuration =~ "^Debug");
415     push(@args, '--release') if ($configuration =~ "^Release");
416     push(@args, '--device') if (defined $xcodeSDK && $xcodeSDK =~ /^iphoneos/);
417     push(@args, '--sim') if (defined $xcodeSDK && $xcodeSDK =~ /^iphonesimulator/);
418     push(@args, '--ios-simulator') if (defined $xcodeSDK && $xcodeSDK =~ /^iphonesimulator/);
419     push(@args, '--32-bit') if ($architecture ne "x86_64" and !isWin64());
420     push(@args, '--64-bit') if (isWin64());
421     push(@args, '--gtk') if isGtk();
422     push(@args, '--efl') if isEfl();
423     push(@args, '--wincairo') if isWinCairo();
424     push(@args, '--inspector-frontend') if isInspectorFrontend();
425     return @args;
426 }
427
428 sub determineXcodeSDK
429 {
430     return if defined $xcodeSDK;
431     my $sdk;
432     if (checkForArgumentAndRemoveFromARGVGettingValue("--sdk", \$sdk)) {
433         $xcodeSDK = $sdk;
434     }
435     if (checkForArgumentAndRemoveFromARGV("--device")) {
436         $xcodeSDK ||= 'iphoneos.internal';
437     }
438     if (checkForArgumentAndRemoveFromARGV("--sim") ||
439         checkForArgumentAndRemoveFromARGV("--simulator") ||
440         checkForArgumentAndRemoveFromARGV("--ios-simulator")) {
441         $xcodeSDK ||= 'iphonesimulator';
442     }
443 }
444
445 sub xcodeSDK
446 {
447     determineXcodeSDK();
448     return $xcodeSDK;
449 }
450
451 sub xcodeSDKPlatformName()
452 {
453     determineXcodeSDK();
454     return "" if !defined $xcodeSDK;
455     return "iphoneos" if $xcodeSDK =~ /iphoneos/i;
456     return "iphonesimulator" if $xcodeSDK =~ /iphonesimulator/i;
457     return "macosx" if $xcodeSDK =~ /macosx/i;
458     die "Couldn't determine platform name from Xcode SDK";
459 }
460
461 sub XcodeSDKPath
462 {
463     determineXcodeSDK();
464
465     die "Can't find the SDK path because no Xcode SDK was specified" if not $xcodeSDK;
466
467     my $sdkPath = `xcrun --sdk $xcodeSDK --show-sdk-path` if $xcodeSDK;
468     die 'Failed to get SDK path from xcrun' if $?;
469     chomp $sdkPath;
470
471     return $sdkPath;
472 }
473
474 sub xcodeSDKVersion
475 {
476     determineXcodeSDK();
477
478     die "Can't find the SDK version because no Xcode SDK was specified" if !$xcodeSDK;
479
480     chomp(my $sdkVersion = `xcrun --sdk $xcodeSDK --show-sdk-version`);
481     die "Failed to get SDK version from xcrun" if exitStatus($?);
482
483     return $sdkVersion;
484 }
485
486 sub programFilesPath
487 {
488     return $programFilesPath if defined $programFilesPath;
489
490     $programFilesPath = $ENV{'PROGRAMFILES(X86)'} || $ENV{'PROGRAMFILES'} || "C:\\Program Files";
491
492     return $programFilesPath;
493 }
494
495 sub visualStudioInstallDir
496 {
497     return $vsInstallDir if defined $vsInstallDir;
498
499     if ($ENV{'VSINSTALLDIR'}) {
500         $vsInstallDir = $ENV{'VSINSTALLDIR'};
501         $vsInstallDir =~ s|[\\/]$||;
502     } else {
503         $vsInstallDir = File::Spec->catdir(programFilesPath(), "Microsoft Visual Studio 12.0");
504     }
505     chomp($vsInstallDir = `cygpath "$vsInstallDir"`) if isCygwin();
506
507     return $vsInstallDir;
508 }
509
510 sub visualStudioVersion
511 {
512     return $vsVersion if defined $vsVersion;
513
514     my $installDir = visualStudioInstallDir();
515
516     $vsVersion = ($installDir =~ /Microsoft Visual Studio ([0-9]+\.[0-9]*)/) ? $1 : "12";
517
518     return $vsVersion;
519 }
520
521 sub determineConfigurationForVisualStudio
522 {
523     return if defined $configurationForVisualStudio;
524     determineConfiguration();
525     # FIXME: We should detect when Debug_All or Production has been chosen.
526     $configurationForVisualStudio = $configuration . (isWin64() ? "|x64" : "|Win32");
527 }
528
529 sub usesPerConfigurationBuildDirectory
530 {
531     # [Gtk] We don't have Release/Debug configurations in straight
532     # autotool builds (non build-webkit). In this case and if
533     # WEBKIT_OUTPUTDIR exist, use that as our configuration dir. This will
534     # allows us to run run-webkit-tests without using build-webkit.
535     return ($ENV{"WEBKIT_OUTPUTDIR"} && isGtk()) || isAppleWinWebKit();
536 }
537
538 sub determineConfigurationProductDir
539 {
540     return if defined $configurationProductDir;
541     determineBaseProductDir();
542     determineConfiguration();
543     if (isAppleWinWebKit() || isWinCairo()) {
544         my $binDir = isWin64() ? "bin64" : "bin32";
545         $configurationProductDir = File::Spec->catdir($baseProductDir, $configuration, $binDir);
546     } else {
547         if (usesPerConfigurationBuildDirectory()) {
548             $configurationProductDir = "$baseProductDir";
549         } else {
550             $configurationProductDir = "$baseProductDir/$configuration";
551             $configurationProductDir .= "-" . xcodeSDKPlatformName() if isIOSWebKit();
552         }
553     }
554 }
555
556 sub setConfigurationProductDir($)
557 {
558     ($configurationProductDir) = @_;
559 }
560
561 sub determineCurrentSVNRevision
562 {
563     # We always update the current SVN revision here, and leave the caching
564     # to currentSVNRevision(), so that changes to the SVN revision while the
565     # script is running can be picked up by calling this function again.
566     determineSourceDir();
567     $currentSVNRevision = svnRevisionForDirectory($sourceDir);
568     return $currentSVNRevision;
569 }
570
571
572 sub chdirWebKit
573 {
574     determineSourceDir();
575     chdir $sourceDir or die;
576 }
577
578 sub baseProductDir
579 {
580     determineBaseProductDir();
581     return $baseProductDir;
582 }
583
584 sub sourceDir
585 {
586     determineSourceDir();
587     return $sourceDir;
588 }
589
590 sub productDir
591 {
592     determineConfigurationProductDir();
593     return $configurationProductDir;
594 }
595
596 sub jscProductDir
597 {
598     my $productDir = productDir();
599     $productDir .= "/bin" if (isEfl() || isGtk());
600
601     return $productDir;
602 }
603
604 sub configuration()
605 {
606     determineConfiguration();
607     return $configuration;
608 }
609
610 sub asanIsEnabled()
611 {
612     determineASanIsEnabled();
613     return $asanIsEnabled;
614 }
615
616 sub configurationForVisualStudio()
617 {
618     determineConfigurationForVisualStudio();
619     return $configurationForVisualStudio;
620 }
621
622 sub currentSVNRevision
623 {
624     determineCurrentSVNRevision() if not defined $currentSVNRevision;
625     return $currentSVNRevision;
626 }
627
628 sub generateDsym()
629 {
630     determineGenerateDsym();
631     return $generateDsym;
632 }
633
634 sub determineGenerateDsym()
635 {
636     return if defined($generateDsym);
637     $generateDsym = checkForArgumentAndRemoveFromARGV("--dsym");
638 }
639
640 sub argumentsForXcode()
641 {
642     my @args = ();
643     push @args, "DEBUG_INFORMATION_FORMAT=dwarf-with-dsym" if generateDsym();
644     return @args;
645 }
646
647 sub XcodeOptions
648 {
649     determineBaseProductDir();
650     determineConfiguration();
651     determineArchitecture();
652     determineASanIsEnabled();
653     determineXcodeSDK();
654
655     my @sdkOption = ($xcodeSDK ? "SDKROOT=$xcodeSDK" : ());
656     my @architectureOption = ($architecture ? "ARCHS=$architecture" : ());
657     my @asanOption = ($asanIsEnabled ? ("-xcconfig", sourceDir() . "/Tools/asan/asan.xcconfig", "ASAN_IGNORE=" . sourceDir() . "/Tools/asan/webkit-asan-ignore.txt") : ());
658
659     return (@baseProductDirOption, "-configuration", $configuration, @architectureOption, @sdkOption, @asanOption, argumentsForXcode());
660 }
661
662 sub XcodeOptionString
663 {
664     return join " ", XcodeOptions();
665 }
666
667 sub XcodeOptionStringNoConfig
668 {
669     return join " ", @baseProductDirOption;
670 }
671
672 sub XcodeCoverageSupportOptions()
673 {
674     my @coverageSupportOptions = ();
675     push @coverageSupportOptions, "GCC_GENERATE_TEST_COVERAGE_FILES=YES";
676     push @coverageSupportOptions, "GCC_INSTRUMENT_PROGRAM_FLOW_ARCS=YES";
677     return @coverageSupportOptions;
678 }
679
680 sub XcodeStaticAnalyzerOption()
681 {
682     return "RUN_CLANG_STATIC_ANALYZER=YES";
683 }
684
685 my $passedConfiguration;
686 my $searchedForPassedConfiguration;
687 sub determinePassedConfiguration
688 {
689     return if $searchedForPassedConfiguration;
690     $searchedForPassedConfiguration = 1;
691     $passedConfiguration = undef;
692
693     if (checkForArgumentAndRemoveFromARGV("--debug")) {
694         $passedConfiguration = "Debug";
695     } elsif(checkForArgumentAndRemoveFromARGV("--release")) {
696         $passedConfiguration = "Release";
697     } elsif (checkForArgumentAndRemoveFromARGV("--profile") || checkForArgumentAndRemoveFromARGV("--profiling")) {
698         $passedConfiguration = "Profiling";
699     }
700
701     $passedConfiguration .= "_WinCairo" if (defined($passedConfiguration) && isWinCairo() && isCygwin());
702 }
703
704 sub passedConfiguration
705 {
706     determinePassedConfiguration();
707     return $passedConfiguration;
708 }
709
710 sub setConfiguration
711 {
712     setArchitecture();
713
714     if (my $config = shift @_) {
715         $configuration = $config;
716         return;
717     }
718
719     determinePassedConfiguration();
720     $configuration = $passedConfiguration if $passedConfiguration;
721 }
722
723
724 my $passedArchitecture;
725 my $searchedForPassedArchitecture;
726 sub determinePassedArchitecture
727 {
728     return if $searchedForPassedArchitecture;
729     $searchedForPassedArchitecture = 1;
730
731     $passedArchitecture = undef;
732     if (checkForArgumentAndRemoveFromARGV("--32-bit")) {
733         if (isAppleMacWebKit()) {
734             # PLATFORM_IOS: Don't run `arch` command inside Simulator environment
735             local %ENV = %ENV;
736             delete $ENV{DYLD_ROOT_PATH};
737             delete $ENV{DYLD_FRAMEWORK_PATH};
738
739             $passedArchitecture = `arch`;
740             chomp $passedArchitecture;
741         }
742     }
743 }
744
745 sub passedArchitecture
746 {
747     determinePassedArchitecture();
748     return $passedArchitecture;
749 }
750
751 sub architecture()
752 {
753     determineArchitecture();
754     return $architecture;
755 }
756
757 sub numberOfCPUs()
758 {
759     determineNumberOfCPUs();
760     return $numberOfCPUs;
761 }
762
763 sub maxCPULoad()
764 {
765     determineMaxCPULoad();
766     return $maxCPULoad;
767 }
768
769 sub setArchitecture
770 {
771     if (my $arch = shift @_) {
772         $architecture = $arch;
773         return;
774     }
775
776     determinePassedArchitecture();
777     $architecture = $passedArchitecture if $passedArchitecture;
778 }
779
780 sub skipSafariExecutableEntitlementChecks
781 {
782     return `defaults read /Library/Preferences/org.webkit.BuildConfiguration SkipSafariExecutableEntitlementChecks 2>/dev/null` eq "1\n";
783 }
784
785 sub executableHasEntitlements
786 {
787     my $executablePath = shift;
788     return (`codesign -d --entitlements - $executablePath 2>&1` =~ /<key>/);
789 }
790
791 sub safariPathFromSafariBundle
792 {
793     my ($safariBundle) = @_;
794
795     die "Safari path is only relevant on Apple Mac platform\n" unless isAppleMacWebKit();
796
797     my $safariPath = "$safariBundle/Contents/MacOS/Safari";
798     return $safariPath if skipSafariExecutableEntitlementChecks();
799
800     my $safariForWebKitDevelopmentPath = "$safariBundle/Contents/MacOS/SafariForWebKitDevelopment";
801     return $safariForWebKitDevelopmentPath if -f $safariForWebKitDevelopmentPath && executableHasEntitlements($safariPath);
802
803     return $safariPath;
804 }
805
806 sub installedSafariPath
807 {
808     return safariPathFromSafariBundle("/Applications/Safari.app");
809 }
810
811 # Locate Safari.
812 sub safariPath
813 {
814     die "Safari path is only relevant on Apple Mac platform\n" unless isAppleMacWebKit();
815
816     # Use WEBKIT_SAFARI environment variable if present.
817     my $safariBundle = $ENV{WEBKIT_SAFARI};
818     if (!$safariBundle) {
819         determineConfigurationProductDir();
820         # Use Safari.app in product directory if present (good for Safari development team).
821         if (-d "$configurationProductDir/Safari.app") {
822             $safariBundle = "$configurationProductDir/Safari.app";
823         }
824         if (!$safariBundle) {
825             return installedSafariPath();
826         }
827     }
828     my $safariPath = safariPathFromSafariBundle($safariBundle);
829     die "Can't find executable at $safariPath.\n" if !-x $safariPath;
830     return $safariPath;
831 }
832
833 sub builtDylibPathForName
834 {
835     my $libraryName = shift;
836     determineConfigurationProductDir();
837
838     if (isGtk()) {
839         my $extension = isDarwin() ? ".dylib" : ".so";
840         return "$configurationProductDir/lib/libwebkit2gtk-4.0" . $extension;
841     }
842     if (isEfl()) {
843         return "$configurationProductDir/lib/libewebkit2.so";
844     }
845     if (isIOSWebKit()) {
846         return "$configurationProductDir/$libraryName.framework/$libraryName";
847     }
848     if (isAppleMacWebKit()) {
849         return "$configurationProductDir/$libraryName.framework/Versions/A/$libraryName";
850     }
851     if (isAppleWinWebKit()) {
852         if ($libraryName eq "JavaScriptCore") {
853             return "$baseProductDir/lib/$libraryName.lib";
854         } else {
855             return "$baseProductDir/$libraryName.intermediate/$configuration/$libraryName.intermediate/$libraryName.lib";
856         }
857     }
858
859     die "Unsupported platform, can't determine built library locations.\nTry `build-webkit --help` for more information.\n";
860 }
861
862 # Check to see that all the frameworks are built.
863 sub checkFrameworks # FIXME: This is a poor name since only the Mac calls built WebCore a Framework.
864 {
865     return if isCygwin() || isWindows();
866     my @frameworks = ("JavaScriptCore", "WebCore");
867     push(@frameworks, "WebKit") if isAppleMacWebKit(); # FIXME: This seems wrong, all ports should have a WebKit these days.
868     for my $framework (@frameworks) {
869         my $path = builtDylibPathForName($framework);
870         die "Can't find built framework at \"$path\".\n" unless -e $path;
871     }
872 }
873
874 sub isInspectorFrontend()
875 {
876     determineIsInspectorFrontend();
877     return $isInspectorFrontend;
878 }
879
880 sub determineIsInspectorFrontend()
881 {
882     return if defined($isInspectorFrontend);
883     $isInspectorFrontend = checkForArgumentAndRemoveFromARGV("--inspector-frontend");
884 }
885
886 sub commandExists($)
887 {
888     my $command = shift;
889     my $devnull = File::Spec->devnull();
890     return `$command --version 2> $devnull`;
891 }
892
893 sub checkForArgumentAndRemoveFromARGV($)
894 {
895     my $argToCheck = shift;
896     return checkForArgumentAndRemoveFromArrayRef($argToCheck, \@ARGV);
897 }
898
899 sub checkForArgumentAndRemoveFromArrayRefGettingValue($$$)
900 {
901     my ($argToCheck, $valueRef, $arrayRef) = @_;
902     my $argumentStartRegEx = qr#^$argToCheck(?:=\S|$)#;
903     my $i = 0;
904     for (; $i < @$arrayRef; ++$i) {
905         last if $arrayRef->[$i] =~ $argumentStartRegEx;
906     }
907     if ($i >= @$arrayRef) {
908         return $$valueRef = undef;
909     }
910     my ($key, $value) = split("=", $arrayRef->[$i]);
911     splice(@$arrayRef, $i, 1);
912     if (defined($value)) {
913         # e.g. --sdk=iphonesimulator
914         return $$valueRef = $value;
915     }
916     return $$valueRef = splice(@$arrayRef, $i, 1); # e.g. --sdk iphonesimulator
917 }
918
919 sub checkForArgumentAndRemoveFromARGVGettingValue($$)
920 {
921     my ($argToCheck, $valueRef) = @_;
922     return checkForArgumentAndRemoveFromArrayRefGettingValue($argToCheck, $valueRef, \@ARGV);
923 }
924
925 sub findMatchingArguments($$)
926 {
927     my ($argToCheck, $arrayRef) = @_;
928     my @matchingIndices;
929     foreach my $index (0 .. $#$arrayRef) {
930         my $opt = $$arrayRef[$index];
931         if ($opt =~ /^$argToCheck$/i ) {
932             push(@matchingIndices, $index);
933         }
934     }
935     return @matchingIndices; 
936 }
937
938 sub hasArgument($$)
939 {
940     my ($argToCheck, $arrayRef) = @_;
941     my @matchingIndices = findMatchingArguments($argToCheck, $arrayRef);
942     return scalar @matchingIndices > 0;
943 }
944
945 sub checkForArgumentAndRemoveFromArrayRef
946 {
947     my ($argToCheck, $arrayRef) = @_;
948     my @indicesToRemove = findMatchingArguments($argToCheck, $arrayRef);
949     my $removeOffset = 0;
950     foreach my $index (@indicesToRemove) {
951         splice(@$arrayRef, $index - $removeOffset++, 1);
952     }
953     return scalar @indicesToRemove > 0;
954 }
955
956 sub isWK2()
957 {
958     if (defined($isWK2)) {
959         return $isWK2;
960     }
961     if (checkForArgumentAndRemoveFromARGV("-2")) {
962         $isWK2 = 1;
963     } else {
964         $isWK2 = 0;
965     }
966     return $isWK2;
967 }
968
969 sub determineIsEfl()
970 {
971     return if defined($isEfl);
972     $isEfl = checkForArgumentAndRemoveFromARGV("--efl");
973 }
974
975 sub isEfl()
976 {
977     determineIsEfl();
978     return $isEfl;
979 }
980
981 sub determineIsGtk()
982 {
983     return if defined($isGtk);
984     $isGtk = checkForArgumentAndRemoveFromARGV("--gtk");
985 }
986
987 sub isGtk()
988 {
989     determineIsGtk();
990     return $isGtk;
991 }
992
993 # Determine if this is debian, ubuntu, linspire, or something similar.
994 sub isDebianBased()
995 {
996     return -e "/etc/debian_version";
997 }
998
999 sub isFedoraBased()
1000 {
1001     return -e "/etc/fedora-release";
1002 }
1003
1004 sub isWinCairo()
1005 {
1006     determineIsWinCairo();
1007     return $isWinCairo;
1008 }
1009
1010 sub determineIsWinCairo()
1011 {
1012     return if defined($isWinCairo);
1013     $isWinCairo = checkForArgumentAndRemoveFromARGV("--wincairo");
1014 }
1015
1016 sub isWin64()
1017 {
1018     determineIsWin64();
1019     return $isWin64;
1020 }
1021
1022 sub determineIsWin64()
1023 {
1024     return if defined($isWin64);
1025     $isWin64 = checkForArgumentAndRemoveFromARGV("--64-bit");
1026 }
1027
1028 sub isCygwin()
1029 {
1030     return ($^O eq "cygwin") || 0;
1031 }
1032
1033 sub isAnyWindows()
1034 {
1035     return isWindows() || isCygwin();
1036 }
1037
1038 sub determineWinVersion()
1039 {
1040     return if $winVersion;
1041
1042     if (!isAnyWindows()) {
1043         $winVersion = -1;
1044         return;
1045     }
1046
1047     my $versionString = `cmd /c ver`;
1048     $versionString =~ /(\d)\.(\d)\.(\d+)/;
1049
1050     $winVersion = {
1051         major => $1,
1052         minor => $2,
1053         build => $3,
1054     };
1055 }
1056
1057 sub winVersion()
1058 {
1059     determineWinVersion();
1060     return $winVersion;
1061 }
1062
1063 sub isWindows7SP0()
1064 {
1065     return isAnyWindows() && winVersion()->{major} == 6 && winVersion()->{minor} == 1 && winVersion()->{build} == 7600;
1066 }
1067
1068 sub isWindowsVista()
1069 {
1070     return isAnyWindows() && winVersion()->{major} == 6 && winVersion()->{minor} == 0;
1071 }
1072
1073 sub isWindowsXP()
1074 {
1075     return isAnyWindows() && winVersion()->{major} == 5 && winVersion()->{minor} == 1;
1076 }
1077
1078 sub isDarwin()
1079 {
1080     return ($^O eq "darwin") || 0;
1081 }
1082
1083 sub isWindows()
1084 {
1085     return ($^O eq "MSWin32") || 0;
1086 }
1087
1088 sub isLinux()
1089 {
1090     return ($^O eq "linux") || 0;
1091 }
1092
1093 sub isBSD()
1094 {
1095     return ($^O eq "freebsd") || ($^O eq "openbsd") || ($^O eq "netbsd") || 0;
1096 }
1097
1098 sub isARM()
1099 {
1100     return ($Config{archname} =~ /^arm[v\-]/) || ($Config{archname} =~ /^aarch64[v\-]/);
1101 }
1102
1103 sub isCrossCompilation()
1104 {
1105   my $compiler = "";
1106   $compiler = $ENV{'CC'} if (defined($ENV{'CC'}));
1107   if ($compiler =~ /gcc/) {
1108       my $compiler_options = `$compiler -v 2>&1`;
1109       my @host = $compiler_options =~ m/--host=(.*?)\s/;
1110       my @target = $compiler_options =~ m/--target=(.*?)\s/;
1111
1112       return ($host[0] ne "" && $target[0] ne "" && $host[0] ne $target[0]);
1113   }
1114   return 0;
1115 }
1116
1117 sub isAppleWebKit()
1118 {
1119     return isAppleMacWebKit() || isAppleWinWebKit();
1120 }
1121
1122 sub isAppleMacWebKit()
1123 {
1124     return isDarwin() && !isGtk();
1125 }
1126
1127 sub isAppleWinWebKit()
1128 {
1129     return (isCygwin() || isWindows()) && !isWinCairo() && !isGtk();
1130 }
1131
1132 sub iOSSimulatorDevicesPath
1133 {
1134     return "$ENV{HOME}/Library/Developer/CoreSimulator/Devices";
1135 }
1136
1137 sub iOSSimulatorDevices
1138 {
1139     eval "require Foundation";
1140     my $devicesPath = iOSSimulatorDevicesPath();
1141     opendir(DEVICES, $devicesPath);
1142     my @udids = grep {
1143         $_ =~ m/[0-9A-F]{8}-([0-9A-F]{4}-){3}[0-9A-F]{12}/;
1144     } readdir(DEVICES);
1145     close(DEVICES);
1146
1147     my @devices = map {
1148         Foundation::perlRefFromObjectRef(NSDictionary->dictionaryWithContentsOfFile_("$devicesPath/$_/device.plist"));
1149     } @udids;
1150
1151     return @devices;
1152 }
1153
1154 sub createiOSSimulatorDevice
1155 {
1156     my $name = shift;
1157     my $deviceTypeId = shift;
1158     my $runtimeId = shift;
1159
1160     my $created = system("xcrun", "--sdk", "iphonesimulator", "simctl", "create", $name, $deviceTypeId, $runtimeId) == 0;
1161     die "Couldn't create simulator device: $name $deviceTypeId $runtimeId" if not $created;
1162
1163     system("xcrun", "--sdk", "iphonesimulator", "simctl", "list");
1164
1165     print "Waiting for device to be created ...\n";
1166     sleep 5;
1167     for (my $tries = 0; $tries < 5; $tries++){
1168         my @devices = iOSSimulatorDevices();
1169         foreach my $device (@devices) {
1170             return $device if $device->{name} eq $name and $device->{deviceType} eq $deviceTypeId and $device->{runtime} eq $runtimeId;
1171         }
1172         sleep 5;
1173     }
1174     die "Device $name $deviceTypeId $runtimeId wasn't found in " . iOSSimulatorDevicesPath();
1175 }
1176
1177 sub deleteiOSSimulatorDevice
1178 {
1179     my $udid = shift;
1180     return system("xcrun", "--sdk", "iphonesimulator", "simctl", "delete", $udid);
1181 }
1182
1183 sub willUseIOSDeviceSDKWhenBuilding()
1184 {
1185     return xcodeSDKPlatformName() eq "iphoneos";
1186 }
1187
1188 sub willUseIOSSimulatorSDKWhenBuilding()
1189 {
1190     return xcodeSDKPlatformName() eq "iphonesimulator";
1191 }
1192
1193 sub isIOSWebKit()
1194 {
1195     determineXcodeSDK();
1196     return isAppleMacWebKit() && (willUseIOSDeviceSDKWhenBuilding() || willUseIOSSimulatorSDKWhenBuilding());
1197 }
1198
1199 sub determineNmPath()
1200 {
1201     return if $nmPath;
1202
1203     if (isAppleMacWebKit()) {
1204         $nmPath = `xcrun -find nm`;
1205         chomp $nmPath;
1206     }
1207     $nmPath = "nm" if !$nmPath;
1208 }
1209
1210 sub nmPath()
1211 {
1212     determineNmPath();
1213     return $nmPath;
1214 }
1215
1216 sub determineOSXVersion()
1217 {
1218     return if $osXVersion;
1219
1220     if (!isDarwin()) {
1221         $osXVersion = -1;
1222         return;
1223     }
1224
1225     my $version = `sw_vers -productVersion`;
1226     my @splitVersion = split(/\./, $version);
1227     @splitVersion >= 2 or die "Invalid version $version";
1228     $osXVersion = {
1229             "major" => $splitVersion[0],
1230             "minor" => $splitVersion[1],
1231             "subminor" => (defined($splitVersion[2]) ? $splitVersion[2] : 0),
1232     };
1233 }
1234
1235 sub osXVersion()
1236 {
1237     determineOSXVersion();
1238     return $osXVersion;
1239 }
1240
1241 sub isWindowsNT()
1242 {
1243     return $ENV{'OS'} eq 'Windows_NT';
1244 }
1245
1246 sub shouldTargetWebProcess
1247 {
1248     determineShouldTargetWebProcess();
1249     return $shouldTargetWebProcess;
1250 }
1251
1252 sub determineShouldTargetWebProcess
1253 {
1254     return if defined($shouldTargetWebProcess);
1255     $shouldTargetWebProcess = checkForArgumentAndRemoveFromARGV("--target-web-process");
1256 }
1257
1258 sub shouldUseXPCServiceForWebProcess
1259 {
1260     determineShouldUseXPCServiceForWebProcess();
1261     return $shouldUseXPCServiceForWebProcess;
1262 }
1263
1264 sub determineShouldUseXPCServiceForWebProcess
1265 {
1266     return if defined($shouldUseXPCServiceForWebProcess);
1267     $shouldUseXPCServiceForWebProcess = checkForArgumentAndRemoveFromARGV("--use-web-process-xpc-service");
1268 }
1269
1270 sub debugger
1271 {
1272     determineDebugger();
1273     return $debugger;
1274 }
1275
1276 sub determineDebugger
1277 {
1278     return if defined($debugger);
1279
1280     determineXcodeVersion();
1281     if (eval "v$xcodeVersion" ge v4.5) {
1282         $debugger = "lldb";
1283     } else {
1284         $debugger = "gdb";
1285     }
1286
1287     if (checkForArgumentAndRemoveFromARGV("--use-lldb")) {
1288         $debugger = "lldb";
1289     }
1290
1291     if (checkForArgumentAndRemoveFromARGV("--use-gdb")) {
1292         $debugger = "gdb";
1293     }
1294 }
1295
1296 sub appendToEnvironmentVariableList
1297 {
1298     my ($environmentVariableName, $value) = @_;
1299
1300     if (defined($ENV{$environmentVariableName})) {
1301         $ENV{$environmentVariableName} .= ":" . $value;
1302     } else {
1303         $ENV{$environmentVariableName} = $value;
1304     }
1305 }
1306
1307 sub sharedCommandLineOptions()
1308 {
1309     return (
1310         "g|guard-malloc" => \$shouldUseGuardMalloc,
1311     );
1312 }
1313
1314 sub sharedCommandLineOptionsUsage
1315 {
1316     my %opts = @_;
1317
1318     my %switches = (
1319         '-g|--guard-malloc' => 'Use guardmalloc when running executable',
1320     );
1321
1322     my $indent = " " x ($opts{indent} || 2);
1323     my $switchWidth = List::Util::max(int($opts{switchWidth}), List::Util::max(map { length($_) } keys %switches) + ($opts{brackets} ? 2 : 0));
1324
1325     my $result = "Common switches:\n";
1326
1327     for my $switch (keys %switches) {
1328         my $switchName = $opts{brackets} ? "[" . $switch . "]" : $switch;
1329         $result .= sprintf("%s%-" . $switchWidth . "s %s\n", $indent, $switchName, $switches{$switch});
1330     }
1331
1332     return $result;
1333 }
1334
1335 sub setUpGuardMallocIfNeeded
1336 {
1337     if (!isDarwin()) {
1338         return;
1339     }
1340
1341     if (!defined($shouldUseGuardMalloc)) {
1342         $shouldUseGuardMalloc = checkForArgumentAndRemoveFromARGV("-g") || checkForArgumentAndRemoveFromARGV("--guard-malloc");
1343     }
1344
1345     if ($shouldUseGuardMalloc) {
1346         appendToEnvironmentVariableList("DYLD_INSERT_LIBRARIES", "/usr/lib/libgmalloc.dylib");
1347     }
1348 }
1349
1350 sub relativeScriptsDir()
1351 {
1352     my $scriptDir = File::Spec->catpath("", File::Spec->abs2rel($FindBin::Bin, getcwd()), "");
1353     if ($scriptDir eq "") {
1354         $scriptDir = ".";
1355     }
1356     return $scriptDir;
1357 }
1358
1359 sub launcherPath()
1360 {
1361     my $relativeScriptsPath = relativeScriptsDir();
1362     if (isGtk() || isEfl()) {
1363         return "$relativeScriptsPath/run-launcher";
1364     } elsif (isAppleWebKit()) {
1365         return "$relativeScriptsPath/run-safari";
1366     }
1367 }
1368
1369 sub launcherName()
1370 {
1371     if (isGtk() || isEfl()) {
1372         return "MiniBrowser";
1373     } elsif (isAppleMacWebKit()) {
1374         return "Safari";
1375     } elsif (isAppleWinWebKit()) {
1376         return "WinLauncher";
1377     }
1378 }
1379
1380 sub checkRequiredSystemConfig
1381 {
1382     if (isDarwin()) {
1383         chomp(my $productVersion = `sw_vers -productVersion`);
1384         if (eval "v$productVersion" lt v10.7.5) {
1385             print "*************************************************************\n";
1386             print "Mac OS X Version 10.7.5 or later is required to build WebKit.\n";
1387             print "You have " . $productVersion . ", thus the build will most likely fail.\n";
1388             print "*************************************************************\n";
1389         }
1390         my $xcodebuildVersionOutput = `xcodebuild -version`;
1391         my $xcodeVersion = ($xcodebuildVersionOutput =~ /Xcode ([0-9](\.[0-9]+)*)/) ? $1 : undef;
1392         if (!$xcodeVersion || $xcodeVersion && eval "v$xcodeVersion" lt v4.6) {
1393             print "*************************************************************\n";
1394             print "Xcode Version 4.6 or later is required to build WebKit.\n";
1395             print "You have an earlier version of Xcode, thus the build will\n";
1396             print "most likely fail. The latest Xcode is available from the App Store.\n";
1397             print "*************************************************************\n";
1398         }
1399     } elsif (isGtk() or isEfl() or isWindows()) {
1400         my @cmds = qw(bison gperf flex);
1401         my @missing = ();
1402         my $oldPath = $ENV{PATH};
1403         foreach my $cmd (@cmds) {
1404             push @missing, $cmd if not commandExists($cmd);
1405         }
1406
1407         if (@missing) {
1408             my $list = join ", ", @missing;
1409             die "ERROR: $list missing but required to build WebKit.\n";
1410         }
1411     }
1412     # Win32 and other platforms may want to check for minimum config
1413 }
1414
1415 sub determineWindowsSourceDir()
1416 {
1417     return if $windowsSourceDir;
1418     $windowsSourceDir = sourceDir();
1419     chomp($windowsSourceDir = `cygpath -w '$windowsSourceDir'`) if isCygwin();
1420 }
1421
1422 sub windowsSourceDir()
1423 {
1424     determineWindowsSourceDir();
1425     return $windowsSourceDir;
1426 }
1427
1428 sub windowsSourceSourceDir()
1429 {
1430     return windowsSourceDir() . "\\Source";
1431 }
1432
1433 sub windowsLibrariesDir()
1434 {
1435     return windowsSourceDir() . "\\WebKitLibraries\\win";
1436 }
1437
1438 sub windowsOutputDir()
1439 {
1440     return windowsSourceDir() . "\\WebKitBuild";
1441 }
1442
1443 sub fontExists($)
1444 {
1445     my $font = shift;
1446     my $val = system qw(regtool get), '\\HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts\\' . $font . ' (TrueType)';
1447     return 0 == $val;
1448 }
1449
1450 sub checkInstalledTools()
1451 {
1452     # SVN 1.7.10 is known to be compatible with current servers. SVN 1.8.x seems to be missing some authentication
1453     # protocols we use for svn.webkit.org:
1454     my $svnVersion = `svn --version | grep "\\sversion"`;
1455     chomp($svnVersion);
1456     if (!$? and $svnVersion =~ /1\.8\./) {
1457         print "svn 1.7.10 is known to be compatible with our servers. You are running $svnVersion,\nwhich may not work properly.\n"
1458     }
1459
1460     # environment variables. Avoid until this is corrected.
1461     my $pythonVer = `python --version 2>&1`;
1462     die "You must have Python installed to build WebKit.\n" if ($?);
1463
1464     # cURL 7.34.0 has a bug that prevents authentication with opensource.apple.com (and other things using SSL3).
1465     my $curlVer = `curl --version | grep "curl"`;
1466     chomp($curlVer);
1467     if (!$? and $curlVer =~ /libcurl\/7\.34\.0/) {
1468         print "cURL version 7.34.0 has a bug that prevents authentication with SSL v2 or v3.\n";
1469         print "cURL 7.33.0 is known to work. The cURL projects is preparing an update to\n";
1470         print "correct this problem.\n\n";
1471         die "Please install a working cURL and try again.\n";
1472     }
1473
1474     # MathML requires fonts that do not ship with Windows (at least through Windows 8). Warn the user if they are missing
1475     my @fonts = qw(STIXGeneral-Regular MathJax_Main-Regular);
1476     my @missing = ();
1477     foreach my $font (@fonts) {
1478         push @missing, $font if not fontExists($font);
1479     }
1480
1481     if (scalar @missing > 0) {
1482         print "*************************************************************\n";
1483         print "Mathematical fonts, such as STIX and MathJax, are needed to\n";
1484         print "use the MathML feature.  You do not appear to have these fonts\n";
1485         print "on your system.\n\n";
1486         print "You can download a suitable set of fonts from the following URL:\n";
1487         print "https://developer.mozilla.org/Mozilla/MathML_Projects/Fonts\n";
1488         print "*************************************************************\n";
1489     }
1490
1491     print "Installed tools are correct for the WebKit build.\n";
1492 }
1493
1494 sub setupAppleWinEnv()
1495 {
1496     return unless isAppleWinWebKit();
1497
1498     checkInstalledTools();
1499
1500     if (isWindowsNT()) {
1501         my $restartNeeded = 0;
1502         my %variablesToSet = ();
1503
1504         # FIXME: We should remove this explicit version check for cygwin once we stop supporting Cygwin 1.7.9 or older versions. 
1505         # https://bugs.webkit.org/show_bug.cgi?id=85791
1506         my $uname_version = (POSIX::uname())[2];
1507         $uname_version =~ s/\(.*\)//;  # Remove the trailing cygwin version, if any.
1508         if (version->parse($uname_version) < version->parse("1.7.10")) {
1509             # Setting the environment variable 'CYGWIN' to 'tty' makes cygwin enable extra support (i.e., termios)
1510             # for UNIX-like ttys in the Windows console
1511             $variablesToSet{CYGWIN} = "tty" unless $ENV{CYGWIN};
1512         }
1513         
1514         # Those environment variables must be set to be able to build inside Visual Studio.
1515         $variablesToSet{WEBKIT_LIBRARIES} = windowsLibrariesDir() unless $ENV{WEBKIT_LIBRARIES};
1516         $variablesToSet{WEBKIT_OUTPUTDIR} = windowsOutputDir() unless $ENV{WEBKIT_OUTPUTDIR};
1517         $variablesToSet{MSBUILDDISABLENODEREUSE} = "1" unless $ENV{MSBUILDDISABLENODEREUSE};
1518
1519         foreach my $variable (keys %variablesToSet) {
1520             print "Setting the Environment Variable '" . $variable . "' to '" . $variablesToSet{$variable} . "'\n\n";
1521             system qw(regtool -s set), '\\HKEY_CURRENT_USER\\Environment\\' . $variable, $variablesToSet{$variable};
1522             $restartNeeded ||=  $variable eq "WEBKIT_LIBRARIES" || $variable eq "WEBKIT_OUTPUTDIR";
1523         }
1524
1525         if ($restartNeeded) {
1526             print "Please restart your computer before attempting to build inside Visual Studio.\n\n";
1527         }
1528     } else {
1529         if (!defined $ENV{'WEBKIT_LIBRARIES'} || !$ENV{'WEBKIT_LIBRARIES'}) {
1530             print "Warning: You must set the 'WebKit_Libraries' environment variable\n";
1531             print "         to be able build WebKit from within Visual Studio 2013 and newer.\n";
1532             print "         Make sure that 'WebKit_Libraries' points to the\n";
1533             print "         'WebKitLibraries/win' directory, not the 'WebKitLibraries/' directory.\n\n";
1534         }
1535         if (!defined $ENV{'WEBKIT_OUTPUTDIR'} || !$ENV{'WEBKIT_OUTPUTDIR'}) {
1536             print "Warning: You must set the 'WebKit_OutputDir' environment variable\n";
1537             print "         to be able build WebKit from within Visual Studio 2013 and newer.\n\n";
1538         }
1539         if (!defined $ENV{'MSBUILDDISABLENODEREUSE'} || !$ENV{'MSBUILDDISABLENODEREUSE'}) {
1540             print "Warning: You should set the 'MSBUILDDISABLENODEREUSE' environment variable to '1'\n";
1541             print "         to avoid periodic locked log files when building.\n\n";
1542         }
1543     }
1544     # FIXME (125180): Remove the following temporary 64-bit support once official support is available.
1545     if (isWin64() and !$ENV{'WEBKIT_64_SUPPORT'}) {
1546         print "Warning: You must set the 'WEBKIT_64_SUPPORT' environment variable\n";
1547         print "         to be able run WebKit or JavaScriptCore tests.\n\n";
1548     }
1549 }
1550
1551 sub setupCygwinEnv()
1552 {
1553     return if !isCygwin() && !isWindows();
1554     return if $vcBuildPath;
1555
1556     my $programFilesPath = programFilesPath();
1557     $vcBuildPath = File::Spec->catfile(visualStudioInstallDir(), qw(Common7 IDE devenv.com));
1558     if (-e $vcBuildPath) {
1559         # Visual Studio is installed;
1560         if (visualStudioVersion() eq "12") {
1561             $vcBuildPath = File::Spec->catfile(visualStudioInstallDir(), qw(Common7 IDE devenv.exe));
1562         }
1563     } else {
1564         # Visual Studio not found, try VC++ Express
1565         $vcBuildPath = File::Spec->catfile(visualStudioInstallDir(), qw(Common7 IDE WDExpress.exe));
1566         if (! -e $vcBuildPath) {
1567             print "*************************************************************\n";
1568             print "Cannot find '$vcBuildPath'\n";
1569             print "Please execute the file 'vcvars32.bat' from\n";
1570             print "'$programFilesPath\\Microsoft Visual Studio 12.0\\VC\\bin\\'\n";
1571             print "to setup the necessary environment variables.\n";
1572             print "*************************************************************\n";
1573             die;
1574         }
1575         $willUseVCExpressWhenBuilding = 1;
1576     }
1577
1578     print "Building results into: ", baseProductDir(), "\n";
1579     print "WEBKIT_OUTPUTDIR is set to: ", $ENV{"WEBKIT_OUTPUTDIR"}, "\n";
1580     print "WEBKIT_LIBRARIES is set to: ", $ENV{"WEBKIT_LIBRARIES"}, "\n";
1581     # FIXME (125180): Remove the following temporary 64-bit support once official support is available.
1582     print "WEBKIT_64_SUPPORT is set to: ", $ENV{"WEBKIT_64_SUPPORT"}, "\n" if isWin64();
1583 }
1584
1585 sub dieIfWindowsPlatformSDKNotInstalled
1586 {
1587     my $registry32Path = "/proc/registry/";
1588     my $registry64Path = "/proc/registry64/";
1589     my @windowsPlatformSDKRegistryEntries = (
1590         "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Microsoft SDKs/Windows/v8.0A",
1591         "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Microsoft SDKs/Windows/v8.0",
1592         "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Microsoft SDKs/Windows/v7.1A",
1593         "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Microsoft SDKs/Windows/v7.0A",
1594         "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/MicrosoftSDK/InstalledSDKs/D2FF9F89-8AA2-4373-8A31-C838BF4DBBE1",
1595     );
1596
1597     # FIXME: It would be better to detect whether we are using 32- or 64-bit Windows
1598     # and only check the appropriate entry. But for now we just blindly check both.
1599     my $recommendedPlatformSDK = $windowsPlatformSDKRegistryEntries[0];
1600
1601     while (@windowsPlatformSDKRegistryEntries) {
1602         my $windowsPlatformSDKRegistryEntry = shift @windowsPlatformSDKRegistryEntries;
1603         return if (-e $registry32Path . $windowsPlatformSDKRegistryEntry) || (-e $registry64Path . $windowsPlatformSDKRegistryEntry);
1604     }
1605
1606     print "*************************************************************\n";
1607     print "Cannot find registry entry '$recommendedPlatformSDK'.\n";
1608     print "Please download and install the Microsoft Windows SDK\n";
1609     print "from <http://www.microsoft.com/en-us/download/details.aspx?id=8279>.\n\n";
1610     print "Then follow step 2 in the Windows section of the \"Installing Developer\n";
1611     print "Tools\" instructions at <http://www.webkit.org/building/tools.html>.\n";
1612     print "*************************************************************\n";
1613     die;
1614 }
1615
1616 sub buildXCodeProject($$@)
1617 {
1618     my ($project, $clean, @extraOptions) = @_;
1619
1620     if ($clean) {
1621         push(@extraOptions, "-alltargets");
1622         push(@extraOptions, "clean");
1623     }
1624
1625     push(@extraOptions, ("-sdk", "iphonesimulator")) if willUseIOSSimulatorSDKWhenBuilding();
1626     push(@extraOptions, ("-sdk", "iphoneos.internal")) if willUseIOSDeviceSDKWhenBuilding();
1627
1628     chomp($ENV{DSYMUTIL_NUM_THREADS} = `sysctl -n hw.activecpu`);
1629     return system "xcodebuild", "-project", "$project.xcodeproj", @extraOptions;
1630 }
1631
1632 sub usingVisualStudioExpress()
1633 {
1634     setupCygwinEnv();
1635     return $willUseVCExpressWhenBuilding;
1636 }
1637
1638 sub buildVisualStudioProject
1639 {
1640     my ($project, $clean) = @_;
1641     setupCygwinEnv();
1642
1643     my $config = configurationForVisualStudio();
1644
1645     dieIfWindowsPlatformSDKNotInstalled() if $willUseVCExpressWhenBuilding;
1646
1647     chomp($project = `cygpath -w "$project"`) if isCygwin();
1648
1649     my $action = "/build";
1650     if ($clean) {
1651         $action = "/clean";
1652     }
1653
1654     my @command = ($vcBuildPath, $project, $action, $config);
1655
1656     print join(" ", @command), "\n";
1657     return system @command;
1658 }
1659
1660 sub getJhbuildPath()
1661 {
1662     my @jhbuildPath = File::Spec->splitdir(baseProductDir());
1663     if (isGit() && isGitBranchBuild() && gitBranch()) {
1664         pop(@jhbuildPath);
1665     }
1666     if (isEfl()) {
1667         push(@jhbuildPath, "DependenciesEFL");
1668     } elsif (isGtk()) {
1669         push(@jhbuildPath, "DependenciesGTK");
1670     } else {
1671         die "Cannot get JHBuild path for platform that isn't GTK+ or EFL.\n";
1672     }
1673     return File::Spec->catdir(@jhbuildPath);
1674 }
1675
1676 sub isCachedArgumentfileOutOfDate($@)
1677 {
1678     my ($filename, $currentContents) = @_;
1679
1680     if (! -e $filename) {
1681         return 1;
1682     }
1683
1684     open(CONTENTS_FILE, $filename);
1685     chomp(my $previousContents = <CONTENTS_FILE>);
1686     close(CONTENTS_FILE);
1687
1688     if ($previousContents ne $currentContents) {
1689         print "Contents for file $filename have changed.\n";
1690         print "Previous contents were: $previousContents\n\n";
1691         print "New contents are: $currentContents\n";
1692         return 1;
1693     }
1694
1695     return 0;
1696 }
1697
1698 sub jhbuildWrapperPrefixIfNeeded()
1699 {
1700     if (-e getJhbuildPath()) {
1701         my @prefix = (File::Spec->catfile(sourceDir(), "Tools", "jhbuild", "jhbuild-wrapper"));
1702         if (isEfl()) {
1703             push(@prefix, "--efl");
1704         } elsif (isGtk()) {
1705             push(@prefix, "--gtk");
1706         }
1707         push(@prefix, "run");
1708
1709         return @prefix;
1710     }
1711
1712     return ();
1713 }
1714
1715 sub cmakeCachePath()
1716 {
1717     return File::Spec->catdir(baseProductDir(), configuration(), "CMakeCache.txt");
1718 }
1719
1720 sub shouldRemoveCMakeCache(@)
1721 {
1722     my ($cacheFilePath, @buildArgs) = @_;
1723
1724     # We check this first, because we always want to create this file for a fresh build.
1725     my $productDir = File::Spec->catdir(baseProductDir(), configuration());
1726     my $optionsCache = File::Spec->catdir($productDir, "build-webkit-options.txt");
1727     my $joinedBuildArgs = join(" ", @buildArgs);
1728     if (isCachedArgumentfileOutOfDate($optionsCache, $joinedBuildArgs)) {
1729         File::Path::mkpath($productDir) unless -d $productDir;
1730         open(CACHED_ARGUMENTS, ">", $optionsCache);
1731         print CACHED_ARGUMENTS $joinedBuildArgs;
1732         close(CACHED_ARGUMENTS);
1733
1734         return 1;
1735     }
1736
1737     my $cmakeCache = cmakeCachePath();
1738     unless (-e $cmakeCache) {
1739         return 0;
1740     }
1741
1742     my $cacheFileModifiedTime = stat($cmakeCache)->mtime;
1743     my $platformConfiguration = File::Spec->catdir(sourceDir(), "Source", "cmake", "Options" . cmakeBasedPortName() . ".cmake");
1744     if ($cacheFileModifiedTime < stat($platformConfiguration)->mtime) {
1745         return 1;
1746     }
1747
1748     my $globalConfiguration = File::Spec->catdir(sourceDir(), "Source", "cmake", "OptionsCommon.cmake");
1749     if ($cacheFileModifiedTime < stat($globalConfiguration)->mtime) {
1750         return 1;
1751     }
1752
1753     return 0;
1754 }
1755
1756 sub removeCMakeCache(@)
1757 {
1758     my (@buildArgs) = @_;
1759     if (shouldRemoveCMakeCache(@buildArgs)) {
1760         my $cmakeCache = cmakeCachePath();
1761         unlink($cmakeCache) if -e $cmakeCache;
1762     }
1763 }
1764
1765 sub canUseNinja(@)
1766 {
1767     # Test both ninja and ninja-build. Fedora uses ninja-build and has patched CMake to also call ninja-build.
1768     system('which ninja > /dev/null || which ninja-build > /dev/null');
1769     return $? == 0;
1770 }
1771
1772 sub canUseEclipse(@)
1773 {
1774     system('which eclipse > /dev/null');
1775     return $? == 0;
1776 }
1777
1778 sub cmakeGeneratedBuildfile(@)
1779 {
1780     my ($willUseNinja) = @_;
1781     if ($willUseNinja) {
1782         return File::Spec->catfile(baseProductDir(), configuration(), "build.ninja")
1783     } else {
1784         return File::Spec->catfile(baseProductDir(), configuration(), "Makefile")
1785     }
1786 }
1787
1788 sub generateBuildSystemFromCMakeProject
1789 {
1790     my ($port, $prefixPath, @cmakeArgs, $additionalCMakeArgs) = @_;
1791     my $config = configuration();
1792     my $buildPath = File::Spec->catdir(baseProductDir(), $config);
1793     File::Path::mkpath($buildPath) unless -d $buildPath;
1794     my $originalWorkingDirectory = getcwd();
1795     chdir($buildPath) or die;
1796
1797     # We try to be smart about when to rerun cmake, so that we can have faster incremental builds.
1798     my $willUseNinja = canUseNinja();
1799     if (-e cmakeCachePath() && -e cmakeGeneratedBuildfile($willUseNinja)) {
1800         return 0;
1801     }
1802
1803     my @args;
1804     push @args, "-DPORT=\"$port\"";
1805     push @args, "-DCMAKE_INSTALL_PREFIX=\"$prefixPath\"" if $prefixPath;
1806     push @args, "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON" if isGtk();
1807     if ($config =~ /release/i) {
1808         push @args, "-DCMAKE_BUILD_TYPE=Release";
1809     } elsif ($config =~ /debug/i) {
1810         push @args, "-DCMAKE_BUILD_TYPE=Debug";
1811     }
1812
1813     if ($willUseNinja) {
1814         push @args, "-G";
1815         if (canUseEclipse()) {
1816             push @args, "'Eclipse CDT4 - Ninja'";
1817         } else {
1818             push @args, "Ninja";
1819         }
1820     }
1821
1822     # GTK+ has a production mode, but build-webkit should always use developer mode.
1823     push @args, "-DDEVELOPER_MODE=ON" if isEfl() || isGtk();
1824
1825     # Don't warn variables which aren't used by cmake ports.
1826     push @args, "--no-warn-unused-cli";
1827     push @args, @cmakeArgs if @cmakeArgs;
1828     push @args, $additionalCMakeArgs if $additionalCMakeArgs;
1829
1830     push @args, '"' . sourceDir() . '"';
1831
1832     # Compiler options to keep floating point values consistent
1833     # between 32-bit and 64-bit architectures.
1834     determineArchitecture();
1835     if ($architecture ne "x86_64" && !isARM() && !isCrossCompilation()) {
1836         $ENV{'CXXFLAGS'} = "-march=pentium4 -msse2 -mfpmath=sse " . ($ENV{'CXXFLAGS'} || "");
1837     }
1838
1839     # We call system("cmake @args") instead of system("cmake", @args) so that @args is
1840     # parsed for shell metacharacters.
1841     my $wrapper = join(" ", jhbuildWrapperPrefixIfNeeded()) . " ";
1842     my $returnCode = system($wrapper . "cmake @args");
1843
1844     chdir($originalWorkingDirectory);
1845     return $returnCode;
1846 }
1847
1848 sub buildCMakeGeneratedProject($)
1849 {
1850     my ($makeArgs) = @_;
1851     my $config = configuration();
1852     my $buildPath = File::Spec->catdir(baseProductDir(), $config);
1853     if (! -d $buildPath) {
1854         die "Must call generateBuildSystemFromCMakeProject() before building CMake project.";
1855     }
1856
1857     my $command = "cmake";
1858     my @args = ("--build", $buildPath, "--config", $config);
1859     push @args, ("--", $makeArgs) if $makeArgs;
1860
1861     # GTK can use a build script to preserve colors and pretty-printing.
1862     if (isGtk() && -e "$buildPath/build.sh") {
1863         chdir "$buildPath" or die;
1864         $command = "$buildPath/build.sh";
1865         @args = ($makeArgs);
1866     }
1867
1868     if ($ENV{VERBOSE} && canUseNinja()) {
1869         push @args, "-v";
1870         push @args, "-d keeprsp" if (version->parse(determineNinjaVersion()) >= version->parse("1.4.0"));
1871     }
1872
1873     # We call system("cmake @args") instead of system("cmake", @args) so that @args is
1874     # parsed for shell metacharacters. In particular, $makeArgs may contain such metacharacters.
1875     my $wrapper = join(" ", jhbuildWrapperPrefixIfNeeded()) . " ";
1876     return system($wrapper . "$command @args");
1877
1878 }
1879
1880 sub cleanCMakeGeneratedProject()
1881 {
1882     my $config = configuration();
1883     my $buildPath = File::Spec->catdir(baseProductDir(), $config);
1884     if (-d $buildPath) {
1885         return system("cmake", "--build", $buildPath, "--config", $config, "--target", "clean");
1886     }
1887     return 0;
1888 }
1889
1890 sub buildCMakeProjectOrExit($$$$@)
1891 {
1892     my ($clean, $port, $prefixPath, $makeArgs, @cmakeArgs) = @_;
1893     my $returnCode;
1894
1895     exit(exitStatus(cleanCMakeGeneratedProject())) if $clean;
1896
1897     if (isEfl() && checkForArgumentAndRemoveFromARGV("--update-efl")) {
1898         system("perl", "$sourceDir/Tools/Scripts/update-webkitefl-libs") == 0 or die $!;
1899     }
1900
1901     if (isGtk() && checkForArgumentAndRemoveFromARGV("--update-gtk")) {
1902         system("perl", "$sourceDir/Tools/Scripts/update-webkitgtk-libs") == 0 or die $!;
1903     }
1904
1905     $returnCode = exitStatus(generateBuildSystemFromCMakeProject($port, $prefixPath, @cmakeArgs));
1906     exit($returnCode) if $returnCode;
1907
1908     $returnCode = exitStatus(buildCMakeGeneratedProject($makeArgs));
1909     exit($returnCode) if $returnCode;
1910     return 0;
1911 }
1912
1913 sub cmakeBasedPortArguments()
1914 {
1915     return ();
1916 }
1917
1918 sub cmakeBasedPortName()
1919 {
1920     return "Efl" if isEfl();
1921     return "GTK" if isGtk();
1922     return "";
1923 }
1924
1925 sub isCMakeBuild()
1926 {
1927     return isEfl() || isGtk();
1928 }
1929
1930 sub promptUser
1931 {
1932     my ($prompt, $default) = @_;
1933     my $defaultValue = $default ? "[$default]" : "";
1934     print "$prompt $defaultValue: ";
1935     chomp(my $input = <STDIN>);
1936     return $input ? $input : $default;
1937 }
1938
1939 sub appleApplicationSupportPath
1940 {
1941     open INSTALL_DIR, "</proc/registry/HKEY_LOCAL_MACHINE/SOFTWARE/Apple\ Inc./Apple\ Application\ Support/InstallDir";
1942     my $path = <INSTALL_DIR>;
1943     $path =~ s/[\r\n\x00].*//;
1944     close INSTALL_DIR;
1945
1946     my $unixPath = `cygpath -u '$path'`;
1947     chomp $unixPath;
1948     return $unixPath;
1949 }
1950
1951 sub setPathForRunningWebKitApp
1952 {
1953     my ($env) = @_;
1954
1955     if (isAppleWinWebKit()) {
1956         $env->{PATH} = join(':', productDir(), appleApplicationSupportPath(), $env->{PATH} || "");
1957     } elsif (isWinCairo()) {
1958         my $winCairoBin = sourceDir() . "/WebKitLibraries/win/" . (isWin64() ? "bin64/" : "bin32/");
1959         my $gstreamerBin = isWin64() ? $ENV{"GSTREAMER_1_0_ROOT_X86_64"} . "bin" : $ENV{"GSTREAMER_1_0_ROOT_X86"} . "bin";
1960         $env->{PATH} = join(':', productDir(), $winCairoBin, $gstreamerBin, $env->{PATH} || "");
1961     }
1962 }
1963
1964 sub printHelpAndExitForRunAndDebugWebKitAppIfNeeded
1965 {
1966     return unless checkForArgumentAndRemoveFromARGV("--help");
1967
1968     my ($includeOptionsForDebugging) = @_;
1969
1970     print STDERR <<EOF;
1971 Usage: @{[basename($0)]} [options] [args ...]
1972   --help                            Show this help message
1973   --no-saved-state                  Launch the application without state restoration (OS X 10.7 and later)
1974   -g|--guard-malloc                 Enable Guard Malloc (OS X only)
1975   --use-web-process-xpc-service     Launch the Web Process as an XPC Service (OS X only)
1976 EOF
1977
1978     if ($includeOptionsForDebugging) {
1979         print STDERR <<EOF;
1980   --target-web-process              Debug the web process
1981   --use-gdb                         Use GDB (this is the default when using Xcode 4.4 or earlier)
1982   --use-lldb                        Use LLDB (this is the default when using Xcode 4.5 or later)
1983 EOF
1984     }
1985
1986     exit(1);
1987 }
1988
1989 sub argumentsForRunAndDebugMacWebKitApp()
1990 {
1991     my @args = ();
1992     if (checkForArgumentAndRemoveFromARGV("--no-saved-state")) {
1993         push @args, ("-ApplePersistenceIgnoreStateQuietly", "YES");
1994         # FIXME: Don't set ApplePersistenceIgnoreState once all supported OS versions respect ApplePersistenceIgnoreStateQuietly (rdar://15032886).
1995         push @args, ("-ApplePersistenceIgnoreState", "YES");
1996     }
1997     push @args, ("-WebKit2UseXPCServiceForWebProcess", "YES") if shouldUseXPCServiceForWebProcess();
1998     unshift @args, @ARGV;
1999
2000     return @args;
2001 }
2002
2003 sub setupMacWebKitEnvironment($)
2004 {
2005     my ($dyldFrameworkPath) = @_;
2006
2007     $dyldFrameworkPath = File::Spec->rel2abs($dyldFrameworkPath);
2008
2009     $ENV{DYLD_FRAMEWORK_PATH} = $ENV{DYLD_FRAMEWORK_PATH} ? join(":", $dyldFrameworkPath, $ENV{DYLD_FRAMEWORK_PATH}) : $dyldFrameworkPath;
2010     $ENV{__XPC_DYLD_FRAMEWORK_PATH} = $dyldFrameworkPath;
2011     $ENV{WEBKIT_UNSET_DYLD_FRAMEWORK_PATH} = "YES";
2012
2013     setUpGuardMallocIfNeeded();
2014 }
2015
2016 sub setupIOSWebKitEnvironment($)
2017 {
2018     my ($dyldFrameworkPath) = @_;
2019     $dyldFrameworkPath = File::Spec->rel2abs($dyldFrameworkPath);
2020
2021     $ENV{DYLD_FRAMEWORK_PATH} = $dyldFrameworkPath;
2022     $ENV{DYLD_LIBRARY_PATH} = $dyldFrameworkPath;
2023
2024     setUpGuardMallocIfNeeded();
2025 }
2026
2027 sub installedMobileSafariBundle()
2028 {
2029     return File::Spec->catfile(XcodeSDKPath(), "Applications", "MobileSafari.app");
2030 }
2031
2032 sub mobileSafariBundle()
2033 {
2034     determineConfigurationProductDir();
2035
2036     # Use MobileSafari.app in product directory if present.
2037     if (isAppleMacWebKit() && -d "$configurationProductDir/MobileSafari.app") {
2038         return "$configurationProductDir/MobileSafari.app";
2039     }
2040     return installedMobileSafariBundle();
2041 }
2042
2043 sub plistPathFromBundle($)
2044 {
2045     my ($appBundle) = @_;
2046     return "$appBundle/Info.plist" if -f "$appBundle/Info.plist"; # iOS app bundle
2047     return "$appBundle/Contents/Info.plist" if "$appBundle/Contents/Info.plist"; # Mac app bundle
2048     return "";
2049 }
2050
2051 sub appIdentiferFromBundle($)
2052 {
2053     my ($appBundle) = @_;
2054     my $plistPath = plistPathFromBundle($appBundle);
2055     chomp(my $bundleIdentifer = `defaults read '$plistPath' CFBundleIdentifier 2> /dev/null`);
2056     return $bundleIdentifer;
2057 }
2058
2059 sub appDisplayNameFromBundle($)
2060 {
2061     my ($appBundle) = @_;
2062     my $plistPath = plistPathFromBundle($appBundle);
2063     chomp(my $bundleDisplayName = `defaults read '$plistPath' CFBundleDisplayName 2> /dev/null`);
2064     return $bundleDisplayName;
2065 }
2066
2067 sub loadIPhoneSimulatorNotificationIfNeeded()
2068 {
2069     return if $didLoadIPhoneSimulatorNotification;
2070     push(@INC, productDir() . "/lib/perl5/darwin-thread-multi-2level");
2071     require IPhoneSimulatorNotification;
2072     $didLoadIPhoneSimulatorNotification = 1;
2073 }
2074
2075 sub openIOSSimulator()
2076 {
2077     chomp(my $developerDirectory = $ENV{DEVELOPER_DIR} || `xcode-select --print-path`);
2078     my $iosSimulatorPath = File::Spec->catfile($developerDirectory, "Applications", "iOS Simulator.app");
2079
2080     loadIPhoneSimulatorNotificationIfNeeded();
2081
2082     my $iPhoneSimulatorNotification = new IPhoneSimulatorNotification;
2083     $iPhoneSimulatorNotification->startObservingReadyNotification();
2084     system("open", "-a", $iosSimulatorPath, "--args", "-SessionOnLaunch", "NO") == 0 or die "Failed to open $iosSimulatorPath: $!";
2085     while (!$iPhoneSimulatorNotification->hasReceivedReadyNotification()) {
2086         my $date = NSDate->alloc()->initWithTimeIntervalSinceNow_(0.1);
2087         NSRunLoop->currentRunLoop->runUntilDate_($date);
2088         $date->release();
2089     }
2090     $iPhoneSimulatorNotification->stopObservingReadyNotification();
2091 }
2092
2093 sub iosSimulatorDeviceByName($)
2094 {
2095     my ($simulatorName) = @_;
2096     my @devices = grep {$_->{name} eq $simulatorName} iOSSimulatorDevices();
2097     my $deviceToUse = $devices[0];
2098     if (@devices > 1) {
2099         print "Warning: Found more than one simulator device named '$simulatorName'.\n";
2100         print "         Using simulator device with UDID: $deviceToUse->{UDID}.\n";
2101         print "         To see the list of simulator devices, run:\n";
2102         print "         xcrun --sdk iphonesimulator simctl list\n";
2103     }
2104     return $deviceToUse;
2105 }
2106
2107 sub iosSimulatorRuntime()
2108 {
2109     my $xcodeSDKVersion = xcodeSDKVersion();
2110     $xcodeSDKVersion =~ s/\./-/;
2111     return "com.apple.CoreSimulator.SimRuntime.iOS-$xcodeSDKVersion";
2112 }
2113
2114 sub findOrCreateSimulatorForIOSDevice($)
2115 {
2116     my ($simulatorNameSuffix) = @_;
2117     my $simulatorName;
2118     my $simulatorDeviceType;
2119     if (architecture() eq "x86_64") {
2120         $simulatorName = "iPhone 5s " . $simulatorNameSuffix;
2121         $simulatorDeviceType = "com.apple.CoreSimulator.SimDeviceType.iPhone-5s";
2122     } else {
2123         $simulatorName = "iPhone 5 " . $simulatorNameSuffix;
2124         $simulatorDeviceType = "com.apple.CoreSimulator.SimDeviceType.iPhone-5";
2125     }
2126     my $simulatedDevice = iosSimulatorDeviceByName($simulatorName);
2127     return $simulatedDevice if $simulatedDevice;
2128     return createiOSSimulatorDevice($simulatorName, $simulatorDeviceType, iosSimulatorRuntime());
2129 }
2130
2131 sub runIOSWebKitAppInSimulator($;$)
2132 {
2133     my ($appBundle, $simulatorOptions) = @_;
2134     my $productDir = productDir();
2135     my $appDisplayName = appDisplayNameFromBundle($appBundle);
2136     print "Starting $appDisplayName with DYLD_FRAMEWORK_PATH set to point to built WebKit in $productDir.\n";
2137
2138     $simulatorOptions = {} unless $simulatorOptions;
2139
2140     my %simulatorENV;
2141     %simulatorENV = %{$simulatorOptions->{applicationEnvironment}} if $simulatorOptions->{applicationEnvironment};
2142     {
2143         local %ENV; # Shadow global-scope %ENV so that changes to it will not be seen outside of this scope.
2144         setupIOSWebKitEnvironment($productDir);
2145         %simulatorENV = %ENV;
2146     }
2147     $simulatorOptions->{applicationEnvironment} = \%simulatorENV;
2148     return installAndLaunchIOSWebKitAppInSimulator($appBundle, findOrCreateSimulatorForIOSDevice("For WebKit Development"), $simulatorOptions) <= 0;
2149 }
2150
2151 # Launches the iOS WebKit-based application in the specified simulator device and dynamically
2152 # linked against the built WebKit. The application will be installed if applicable.
2153 #
2154 # Args:
2155 #   $appBundle: the path to the app bundle to launch.
2156 #   $simulatedDevice: the simulator device to use to run the app.
2157 #   $simulatorOptions: a hash reference representing optional simulator options.
2158 #     sessionUUID: a unique identifer to use for the iOS Simulator session. Defaults to an identifer
2159 #                  of the form "theAwesomeUniqueSessionIdentifierForX" where X is the display name of
2160 #                  the specified app.
2161 #     applicationArguments: an array reference representing the arguments to pass to the app (defaults to \@ARGV).
2162 #     applicationEnvironment: a hash reference representing the environment variables to use when launching the app (defaults to {}).
2163 #
2164 # Returns the process identifier of the launched app.
2165 sub installAndLaunchIOSWebKitAppInSimulator($$;$)
2166 {
2167     my ($appBundle, $simulatedDevice, $simulatorOptions) = @_;
2168
2169     loadIPhoneSimulatorNotificationIfNeeded();
2170
2171     my $makeNSDictionaryFromHash = sub {
2172         my ($dict) = @_;
2173         my $result = NSMutableDictionary->alloc()->initWithCapacity_(scalar(keys %{$dict}));
2174         for my $key (keys %{$dict}) {
2175             $result->setObject_forKey_(NSString->stringWithCString_($dict->{$key}), NSString->stringWithCString_($key));
2176         }
2177         return $result->autorelease();
2178     };
2179     my $makeNSArrayFromArray = sub {
2180         my ($array) = @_;
2181         my $result = NSMutableArray->alloc()->initWithCapacity_(scalar(@{$array}));
2182         for my $item (@{$array}) {
2183             $result->addObject_(NSString->stringWithCString_($item));
2184         }
2185         return $result->autorelease();
2186     };
2187
2188     my $simulatorENVHashRef = {};
2189     $simulatorENVHashRef = $simulatorOptions->{applicationEnvironment} if $simulatorOptions && $simulatorOptions->{applicationEnvironment};
2190     my $applicationArguments = \@ARGV;
2191     $applicationArguments = $simulatorOptions->{applicationArguments} if $simulatorOptions && $simulatorOptions->{applicationArguments};
2192     my $sessionUUID;
2193     if ($simulatorOptions && $simulatorOptions->{sessionUUID}) {
2194         $sessionUUID = $simulatorOptions->{sessionUUID};
2195     } else {
2196         $sessionUUID = "theAwesomeUniqueSessionIdentifierFor" . appDisplayNameFromBundle($appBundle);
2197     }
2198     # FIXME: We should have the iOS application adopt the files descriptors for our standard output and error streams.
2199     my $sessionInfo = {
2200         applicationArguments => &$makeNSArrayFromArray($applicationArguments),
2201         applicationEnvironment => &$makeNSDictionaryFromHash($simulatorENVHashRef),
2202         applicationIdentifier => NSString->stringWithCString_(appIdentiferFromBundle($appBundle)),
2203         applicationPath => NSString->stringWithCString_($appBundle),
2204         deviceUDID => NSString->stringWithCString_($simulatedDevice->{UDID}),
2205         sessionUUID => NSString->stringWithCString_($sessionUUID),
2206     };
2207
2208     openIOSSimulator();
2209
2210     my $iPhoneSimulatorNotification = new IPhoneSimulatorNotification;
2211     $iPhoneSimulatorNotification->startObservingApplicationLaunchedNotification();
2212     $iPhoneSimulatorNotification->postStartSessionNotification($sessionInfo);
2213     while (!$iPhoneSimulatorNotification->hasReceivedApplicationLaunchedNotification()) {
2214         my $date = NSDate->alloc()->initWithTimeIntervalSinceNow_(0.1);
2215         NSRunLoop->currentRunLoop->runUntilDate_($date);
2216         $date->release();
2217     }
2218     $iPhoneSimulatorNotification->stopObservingApplicationLaunchedNotification();
2219     return $iPhoneSimulatorNotification->applicationLaunchedApplicationPID();
2220 }
2221
2222 sub runIOSWebKitApp($)
2223 {
2224     my ($appBundle) = @_;
2225     if (willUseIOSDeviceSDKWhenBuilding()) {
2226         die "Only running Safari in iOS Simulator is supported now.";
2227     }
2228     if (willUseIOSSimulatorSDKWhenBuilding()) {
2229         return runIOSWebKitAppInSimulator($appBundle);
2230     }
2231     die "Not using an iOS SDK."
2232 }
2233
2234 sub runMacWebKitApp($;$)
2235 {
2236     my ($appPath, $useOpenCommand) = @_;
2237     my $productDir = productDir();
2238     print "Starting @{[basename($appPath)]} with DYLD_FRAMEWORK_PATH set to point to built WebKit in $productDir.\n";
2239
2240     local %ENV = %ENV;
2241     setupMacWebKitEnvironment($productDir);
2242
2243     if (defined($useOpenCommand) && $useOpenCommand == USE_OPEN_COMMAND) {
2244         return system("open", "-W", "-a", $appPath, "--args", argumentsForRunAndDebugMacWebKitApp());
2245     }
2246     if (architecture()) {
2247         return system "arch", "-" . architecture(), $appPath, argumentsForRunAndDebugMacWebKitApp();
2248     }
2249     return system { $appPath } $appPath, argumentsForRunAndDebugMacWebKitApp();
2250 }
2251
2252 sub execMacWebKitAppForDebugging($)
2253 {
2254     my ($appPath) = @_;
2255     my $architectureSwitch;
2256     my $argumentsSeparator;
2257
2258     if (debugger() eq "lldb") {
2259         $architectureSwitch = "--arch";
2260         $argumentsSeparator = "--";
2261     } elsif (debugger() eq "gdb") {
2262         $architectureSwitch = "-arch";
2263         $argumentsSeparator = "--args";
2264     } else {
2265         die "Unknown debugger $debugger.\n";
2266     }
2267
2268     my $debuggerPath = `xcrun -find $debugger`;
2269     chomp $debuggerPath;
2270     die "Can't find the $debugger executable.\n" unless -x $debuggerPath;
2271
2272     my $productDir = productDir();
2273     setupMacWebKitEnvironment($productDir);
2274
2275     my @architectureFlags = ($architectureSwitch, architecture());
2276     if (!shouldTargetWebProcess()) {
2277         print "Starting @{[basename($appPath)]} under $debugger with DYLD_FRAMEWORK_PATH set to point to built WebKit in $productDir.\n";
2278         exec { $debuggerPath } $debuggerPath, @architectureFlags, $argumentsSeparator, $appPath, argumentsForRunAndDebugMacWebKitApp() or die;
2279     } else {
2280         if (shouldUseXPCServiceForWebProcess()) {
2281             die "Targetting the Web Process is not compatible with using an XPC Service for the Web Process at this time.";
2282         }
2283         
2284         my $webProcessShimPath = File::Spec->catfile($productDir, "SecItemShim.dylib");
2285         my $webProcessPath = File::Spec->catdir($productDir, "WebProcess.app");
2286         my $webKit2ExecutablePath = File::Spec->catfile($productDir, "WebKit2.framework", "WebKit2");
2287
2288         appendToEnvironmentVariableList("DYLD_INSERT_LIBRARIES", $webProcessShimPath);
2289
2290         print "Starting WebProcess under $debugger with DYLD_FRAMEWORK_PATH set to point to built WebKit in $productDir.\n";
2291         exec { $debuggerPath } $debuggerPath, @architectureFlags, $argumentsSeparator, $webProcessPath, $webKit2ExecutablePath, "-type", "webprocess", "-client-executable", $appPath or die;
2292     }
2293 }
2294
2295 sub debugSafari
2296 {
2297     if (isAppleMacWebKit()) {
2298         checkFrameworks();
2299         execMacWebKitAppForDebugging(safariPath());
2300     }
2301
2302     return 1; # Unsupported platform; can't debug Safari on this platform.
2303 }
2304
2305 sub runSafari
2306 {
2307     if (isIOSWebKit()) {
2308         return runIOSWebKitApp(mobileSafariBundle());
2309     }
2310
2311     if (isAppleMacWebKit()) {
2312         return runMacWebKitApp(safariPath());
2313     }
2314
2315     if (isAppleWinWebKit()) {
2316         my $result;
2317         my $productDir = productDir();
2318         my $webKitLauncherPath = File::Spec->catfile(productDir(), "WinLauncher.exe");
2319         return system { $webKitLauncherPath } $webKitLauncherPath, @ARGV;
2320     }
2321
2322     return 1; # Unsupported platform; can't run Safari on this platform.
2323 }
2324
2325 sub runMiniBrowser
2326 {
2327     if (isAppleMacWebKit()) {
2328         return runMacWebKitApp(File::Spec->catfile(productDir(), "MiniBrowser.app", "Contents", "MacOS", "MiniBrowser"));
2329     }
2330
2331     return 1;
2332 }
2333
2334 sub debugMiniBrowser
2335 {
2336     if (isAppleMacWebKit()) {
2337         execMacWebKitAppForDebugging(File::Spec->catfile(productDir(), "MiniBrowser.app", "Contents", "MacOS", "MiniBrowser"));
2338     }
2339     
2340     return 1;
2341 }
2342
2343 sub runWebKitTestRunner
2344 {
2345     if (isAppleMacWebKit()) {
2346         return runMacWebKitApp(File::Spec->catfile(productDir(), "WebKitTestRunner"));
2347     }
2348
2349     return 1;
2350 }
2351
2352 sub debugWebKitTestRunner
2353 {
2354     if (isAppleMacWebKit()) {
2355         execMacWebKitAppForDebugging(File::Spec->catfile(productDir(), "WebKitTestRunner"));
2356     }
2357
2358     return 1;
2359 }
2360
2361 sub readRegistryString
2362 {
2363     my ($valueName) = @_;
2364     chomp(my $string = `regtool --wow32 get "$valueName"`);
2365     return $string;
2366 }
2367
2368 sub writeRegistryString
2369 {
2370     my ($valueName, $string) = @_;
2371
2372     my $error = system "regtool", "--wow32", "set", "-s", $valueName, $string;
2373
2374     # On Windows Vista/7 with UAC enabled, regtool will fail to modify the registry, but will still
2375     # return a successful exit code. So we double-check here that the value we tried to write to the
2376     # registry was really written.
2377     return !$error && readRegistryString($valueName) eq $string;
2378 }
2379
2380 sub formatBuildTime($)
2381 {
2382     my ($buildTime) = @_;
2383
2384     my $buildHours = int($buildTime / 3600);
2385     my $buildMins = int(($buildTime - $buildHours * 3600) / 60);
2386     my $buildSecs = $buildTime - $buildHours * 3600 - $buildMins * 60;
2387
2388     if ($buildHours) {
2389         return sprintf("%dh:%02dm:%02ds", $buildHours, $buildMins, $buildSecs);
2390     }
2391     return sprintf("%02dm:%02ds", $buildMins, $buildSecs);
2392 }
2393
2394 sub runSvnUpdateAndResolveChangeLogs(@)
2395 {
2396     my @svnOptions = @_;
2397     open UPDATE, "-|", "svn", "update", @svnOptions or die;
2398     my @conflictedChangeLogs;
2399     while (my $line = <UPDATE>) {
2400         print $line;
2401         $line =~ m/^C\s+(.+?)[\r\n]*$/;
2402         if ($1) {
2403           my $filename = normalizePath($1);
2404           push @conflictedChangeLogs, $filename if basename($filename) eq "ChangeLog";
2405         }
2406     }
2407     close UPDATE or die;
2408
2409     if (@conflictedChangeLogs) {
2410         print "Attempting to merge conflicted ChangeLogs.\n";
2411         my $resolveChangeLogsPath = File::Spec->catfile(sourceDir(), "Tools", "Scripts", "resolve-ChangeLogs");
2412         (system($resolveChangeLogsPath, "--no-warnings", @conflictedChangeLogs) == 0)
2413             or die "Could not open resolve-ChangeLogs script: $!.\n";
2414     }
2415 }
2416
2417 sub runGitUpdate()
2418 {
2419     # Doing a git fetch first allows setups with svn-remote.svn.fetch = trunk:refs/remotes/origin/master
2420     # to perform the rebase much much faster.
2421     system("git", "fetch");
2422     if (isGitSVN()) {
2423         system("git", "svn", "rebase") == 0 or die;
2424     } else {
2425         # This will die if branch.$BRANCHNAME.merge isn't set, which is
2426         # almost certainly what we want.
2427         system("git", "pull") == 0 or die;
2428     }
2429 }
2430
2431 1;