pull from the static tag

git-svn-id: svn://10.0.0.236/branches/NETSCAPE_7_0_RTM_MINIBRANCH@128184 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/build/mac/build_scripts/BuildMozilla.pl

@@ -0,0 +1,80 @@
+#!perl
+
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#   Simon Fraser <sfraser@netscape.com>
+#
+
+require 5.004;
+
+use strict;
+
+use Cwd;
+use Moz::BuildUtils;
+use Moz::BuildCore;
+
+#-------------------------------------------------------------
+# Where have the build options gone?
+# 
+# The various build flags have been centralized into one place. 
+# The master list of options is in MozBuildFlags.txt. However, 
+# you should never need to edit that file, or this one.
+# 
+# To customize what gets built, or where to start the build, 
+# edit the $prefs_file_name file in
+# System Folder:Preferences:Mozilla build prefs:
+# Documentation is provided in that file.
+#-------------------------------------------------------------
+
+my($prefs_file_name) = "Mozilla opt build prefs";
+my($config_header_file_name) = ":mozilla:config:mac:DefinesOptions.h";
+
+#-------------------------------------------------------------
+# hashes to hold build options
+#-------------------------------------------------------------
+my(%build);
+my(%options);
+my(%filepaths);
+my(%optiondefines);
+
+# Hash of input files for this build. Eventually, there will be
+# input files for manifests, and projects too.
+my(%inputfiles) = (
+  "buildflags",     "MozillaBuildFlags.txt",
+  "checkoutdata",   "MozillaCheckoutList.txt",
+  "buildprogress",  "¥ Mozilla opt progress",
+  "buildmodule",    "MozillaBuildList.pm",
+  "checkouttime",   "Mozilla last checkout"
+);
+#-------------------------------------------------------------
+# end build hashes
+#-------------------------------------------------------------
+
+# set the build root directory, which is the the dir above mozilla
+SetupBuildRootDir(":mozilla:build:mac:build_scripts");
+
+# Set up all the flags on $main::, like DEBUG, CARBON etc.
+# Override the defaults using the preferences files.
+SetupDefaultBuildOptions(0, ":mozilla:dist:viewer:", $config_header_file_name);
+
+my($do_checkout)    = 0;
+my($do_build)       = 1;
+
+RunBuild($do_checkout, $do_build, \%inputfiles, $prefs_file_name);

mozilla/build/mac/build_scripts/BuildMozillaDebug.pl

@@ -0,0 +1,80 @@
+#!perl
+
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#   Simon Fraser <sfraser@netscape.com>
+#
+
+require 5.004;
+
+use strict;
+
+use Cwd;
+use Moz::BuildUtils;
+use Moz::BuildCore;
+
+#-------------------------------------------------------------
+# Where have the build options gone?
+# 
+# The various build flags have been centralized into one place. 
+# The master list of options is in MozBuildFlags.txt. However, 
+# you should never need to edit that file, or this one.
+# 
+# To customize what gets built, or where to start the build, 
+# edit the $prefs_file_name file in
+# System Folder:Preferences:Mozilla build prefs:
+# Documentation is provided in that file.
+#-------------------------------------------------------------
+
+my($prefs_file_name) = "Mozilla debug build prefs";
+my($config_header_file_name) = ":mozilla:config:mac:DefinesOptionsDebug.h";
+
+#-------------------------------------------------------------
+# hashes to hold build options
+#-------------------------------------------------------------
+my(%build);
+my(%options);
+my(%filepaths);
+my(%optiondefines);
+
+# Hash of input files for this build. Eventually, there will be
+# input files for manifests, and projects too.
+my(%inputfiles) = (
+  "buildflags",     "MozillaBuildFlags.txt",
+  "checkoutdata",   "MozillaCheckoutList.txt",
+  "buildprogress",  "¥ Mozilla debug progress",
+  "buildmodule",    "MozillaBuildList.pm",
+  "checkouttime",   "Mozilla last checkout"
+);
+#-------------------------------------------------------------
+# end build hashes
+#-------------------------------------------------------------
+
+# set the build root directory, which is the the dir above mozilla
+SetupBuildRootDir(":mozilla:build:mac:build_scripts");
+
+# Set up all the flags on $main::, like DEBUG, CARBON etc.
+# Override the defaults using the preferences files.
+SetupDefaultBuildOptions(1, ":mozilla:dist:viewer_debug:", $config_header_file_name);
+
+my($do_pull)        = 0;    # overridden by flags and prefs
+my($do_build)       = 1;
+
+RunBuild($do_pull, $do_build, \%inputfiles, $prefs_file_name);

mozilla/build/mac/build_scripts/Moz/BuildCore.pm

@@ -0,0 +1,595 @@
+#!perl -w
+package Moz::BuildCore;
+
+require 5.004;
+require Exporter;
+
+use strict;
+use vars qw( @ISA @EXPORT );
+
+# perl includes
+use Cwd;
+use POSIX;
+use Time::Local;
+use File::Basename;
+use LWP::Simple;
+
+# homegrown
+use Moz::Moz;
+use Moz::Jar;
+use Moz::BuildFlags;
+use Moz::BuildUtils;
+use Moz::CodeWarriorLib;
+
+# use MozillaBuildList;   # eventually, this should go away, and be replaced by data input
+
+
+@ISA        = qw(Exporter);
+@EXPORT     = qw(
+                    RunBuild
+                );
+
+
+#//--------------------------------------------------------------------------------------------------
+#// DoPrebuildCheck
+#//
+#// Check the build tools etc before running the build.
+#//--------------------------------------------------------------------------------------------------
+sub DoPrebuildCheck()
+{
+    SanityCheckBuildOptions();
+
+    # launch codewarrior and persist its location. Have to call this before first
+    # call to getCodeWarriorPath().
+    my($ide_path_file) = $main::filepaths{"idepath"};
+    $ide_path_file = full_path_to($ide_path_file);
+    LaunchCodeWarrior($ide_path_file);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// SanityCheckBuildOptions
+#//--------------------------------------------------------------------------------------------------
+sub SanityCheckBuildOptions()
+{
+    my($bad_options) = 0;
+
+    # Jar options
+    if (!$main::options{chrome_jars} && !$main::options{chrome_files})
+    {
+        print "Warning: Both \$options{chrome_jars} and \$options{chrome_files} are off. You won't get any chrome.\n";
+        $bad_options = 1;
+    }
+
+    if (!$main::options{chrome_jars} && $main::options{use_jars})
+    {
+        print "Warning: \$options{chrome_jars} is off but \$options{use_jars} is on. Your build won't run (expects jars, got files).\n";
+        $bad_options = 1;
+    }
+
+    if (!$main::options{chrome_files} && !$main::options{use_jars})
+    {
+        print "Warning: \$options{chrome_jars} is off but \$options{chrome_files} is on. Your build won't run (expects files, got jars).\n";
+        $bad_options = 1;
+    }
+
+    if ($main::options{ldap_experimental} && !$main::options{ldap})
+    {
+        print "Warning: \$options{ldap_experimental} is on but \$options{ldap} is off. LDAP experimental features will not be built.\n";
+        $bad_options = 1;
+    }
+
+    if ($main::options{wsp} && !$main::options{xmlextras})
+    {
+        print "Warning: \$options{wsp} is on but \$options{xmlextras} is off. wsp will not be built.\n";
+        $bad_options = 1;
+    }
+
+    if ($bad_options) {
+        print "Build will start in 5 seconds. Press command-. to stop\n";
+        
+        DelayFor(5);
+    }
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// GenBuildSystemInfo
+#//--------------------------------------------------------------------------------------------------
+
+sub GenBuildSystemInfo()
+{
+    # always rebuild the configuration program.
+    BuildProjectClean(":mozilla:build:mac:tools:BuildSystemInfo:BuildSystemInfo.mcp", "BuildSystemInfo");
+
+    # delete the configuration file.
+    unlink(":mozilla:build:mac:BuildSystemInfo.pm");
+    
+    # run the program.
+    system(":mozilla:build:mac:BuildSystemInfo");
+
+    # wait for the file to be created.
+    while (!(-e ":mozilla:build:mac:BuildSystemInfo.pm")) { WaitNextEvent(); }
+    
+    # wait for BuildSystemInfo to finish, so that we see correct results.
+    while (IsProcessRunning("BuildSystemInfo")) { WaitNextEvent(); }
+
+    # now, evaluate the contents of the file.
+    open(F, ":mozilla:build:mac:BuildSystemInfo.pm");
+    while (<F>) { eval; }
+    close(F);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// Make library aliases
+#//--------------------------------------------------------------------------------------------------
+
+sub MakeLibAliases()
+{
+    my($dist_dir) = GetBinDirectory();
+
+    #// ProfilerLib
+    if ($main::PROFILE)
+    {
+        my($profilerlibpath) = Moz::CodeWarriorLib::getCodeWarriorPath("MacOS Support:Profiler:Profiler Common:ProfilerLib");
+        MakeAlias("$profilerlibpath", "$dist_dir"."Essential Files:");
+    }
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// ConfigureBuildSystem
+#//
+#// defines some build-system configuration variables.
+#//--------------------------------------------------------------------------------------------------
+sub ConfigureBuildSystem()
+{
+    #// In the future, we may want to do configurations based on the actual build system itself.
+    #// GenBuildSystemInfo();
+        
+    #// For now, if we discover a newer header file than existed in Universal Interfaces 3.2,
+    #// we'll assume that 3.3 or later is in use.
+    my($universal_interfaces) = Moz::CodeWarriorLib::getCodeWarriorPath("MacOS Support:Universal:Interfaces:CIncludes:");
+    if (-e ($universal_interfaces . "ControlDefinitions.h")) {
+        $main::UNIVERSAL_INTERFACES_VERSION = 0x0330;
+    }
+
+    #// Rename IC SDK folder in the Mac OS Support folder
+    my($ic_sdk_folder) = Moz::CodeWarriorLib::getCodeWarriorPath("MacOS Support:ICProgKit2.0.2");
+    if( -e $ic_sdk_folder)
+    {
+        my($new_ic_folder_name) = Moz::CodeWarriorLib::getCodeWarriorPath("MacOS Support:(ICProgKit2.0.2)");
+        rename ($ic_sdk_folder, $new_ic_folder_name);
+        # note that CodeWarrior doesn't descend into folders with () the name
+        print "Mozilla no longer needs the Internet Config SDK to build:\n  Renaming the 'ICProgKit2.0.2' folder to '(ICProgKit2.0.2)'\n";
+    }
+
+    printf("UNIVERSAL_INTERFACES_VERSION = 0x%04X\n", $main::UNIVERSAL_INTERFACES_VERSION);
+
+    # alias required CodeWarrior libs into the Essential Files folder (only the Profiler lib now)
+    MakeLibAliases();
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// CheckOutModule. Takes variable number of args; first two are required
+#//--------------------------------------------------------------------------------------------------
+sub CheckOutModule($$$$)
+{
+    my($session, $module, $revision, $date) = @_;
+
+    my($result) = $session->checkout($module, $revision, $date);
+    
+    # result of 1 is success
+    if ($result) { return; }
+    
+    my($checkout_err) = $session->getLastError();
+    if ($checkout_err == 708) {
+        die "Error: Checkout was cancelled.\n";
+    } elsif ($checkout_err == 911) {
+        die "Error: CVS session settings are incorrect. Check your password, and the CVS root settings.\n";
+    } elsif ($checkout_err == 703) {
+        die "Error: CVS checkout failed. Unknown module, unknown tag, bad username, or other CVS error.\n";
+    } elsif ($checkout_err == 711) {
+        print "Checkout of '$module' failed.\n";
+    }
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// getScriptFolder
+#//--------------------------------------------------------------------------------------------------
+sub getScriptFolder()
+{
+    return dirname($0);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// getScriptFolder
+#//--------------------------------------------------------------------------------------------------
+sub get_url_contents($)
+{
+    my($url) = @_;
+
+    my($url_contents) = LWP::Simple::get($url);
+    $url_contents =~ s/\r\n/\n/g;     # normalize linebreaks
+    $url_contents =~ s/\r/\n/g;       # normalize linebreaks
+    return $url_contents;
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// get_files_from_content
+#//--------------------------------------------------------------------------------------------------
+sub uniq
+{
+    my $lastval;
+    grep(($_ ne $lastval, $lastval = $_)[$[], @_);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// get_files_from_content
+#//--------------------------------------------------------------------------------------------------
+sub get_files_from_content($)
+{
+    my($content) = @_;
+  
+    my(@jscalls) = grep (/return js_file_menu[^{]*/, split(/\n/, $content));
+    my $i;
+  
+    for ($i = 0; $i < @jscalls ; $i++)
+    {
+        $jscalls[$i] =~ s/.*\(|\).*//g;
+        my(@callparams) = split(/,/, $jscalls[$i]);
+        my ($repos, $dir, $file, $rev) = grep(s/['\s]//g, @callparams);
+        $jscalls[$i] = "$dir/$file";
+    }
+
+  &uniq(sort(@jscalls));
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// getLastUpdateTime
+#// 
+#// Get the last time we updated. Return 0 on failure
+#//--------------------------------------------------------------------------------------------------
+sub getLastUpdateTime($)
+{
+    my($timestamp_file) = @_;
+ 
+    my($time_string);
+    
+    local(*TIMESTAMP_FILE);  
+    unless (open(TIMESTAMP_FILE, "< $timestamp_file")) { return 0; }
+
+    while (<TIMESTAMP_FILE>)
+    {
+        my($line) = $_;
+        chomp($line);
+
+        # ignore comments and empty lines
+        if ($line =~ /^\#/ || $line =~ /^\s*$/) {
+            next;
+        }
+        
+        $time_string = $line;
+    }
+
+    # get the epoch seconds
+    my($last_update_secs) = $time_string;
+    $last_update_secs =~ s/\s#.+$//;
+    
+    print "FAST_UPDATE found that you last updated at ".localtime($last_update_secs)."\n";
+    
+    # how long ago was this, in hours?
+    my($gm_now) = time();
+    my($update_hours) = 1 + ceil(($gm_now - $last_update_secs) / (60 * 60));
+    
+    return $update_hours;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// saveCheckoutTimestamp
+#// 
+#// Create a file on disk containing the current time. Param is time(), which is an Epoch seconds
+#// (and therefore in GMT).
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub saveCheckoutTimestamp($$)
+{
+    my($gm_secs, $timestamp_file) = @_;
+        
+    local(*TIMESTAMP_FILE);
+    open(TIMESTAMP_FILE, ">$timestamp_file") || die "Failed to open $timestamp_file\n";
+    print(TIMESTAMP_FILE "# time of last checkout or update, in GMT. Used by FAST_UPDATE\n");
+    print(TIMESTAMP_FILE "$gm_secs \# around ".localtime()." local time\n");
+    close(TIMESTAMP_FILE);
+
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// FastUpdate
+#// 
+#// Use Bonsai url data to update only those dirs which have new files
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub FastUpdate($$)
+{
+    my($modules, $timestamp_file) = @_;          # list of modules to check out
+
+    my($num_hours) = getLastUpdateTime($timestamp_file);
+    if ($num_hours == 0 || $num_hours > 170) {
+        print "Can't fast_update; last update was too long ago, or never. Doing normal checkout.\n";
+        return 0;
+    }
+
+    print "Doing fast update, pulling files changed in the last $num_hours hours\n";
+
+    my($cvsfile) = AskAndPersistFile($main::filepaths{"sessionpath"});
+    my($session) = Moz::MacCVS->new( $cvsfile );
+    unless (defined($session)) { die "Error: Checkout aborted. Cannot create session file: $session" }
+
+    # activate MacCVS
+    ActivateApplication('Mcvs');
+    
+    my($checkout_start_time) = time();
+
+    #print "Time now is $checkout_start_time ($checkout_start_time + 0)\n";
+    
+    my($this_co);
+    foreach $this_co (@$modules)
+    {
+        my($module, $revision, $date) = ($this_co->[0], $this_co->[1], $this_co->[2]);        
+        
+        # assume that things pulled by date wont change
+        if ($date ne "") {
+            print "$module is pulled by date, so ignoring in FastUpdate.\n";
+            next;
+        }
+
+        my($search_type) = "hours";
+        my($min_date) = "";
+        my($max_date) = "";
+        my($url) = "http://bonsai.mozilla.org/cvsquery.cgi?treeid=default&module=${module}&branch=${revision}&branchtype=match&dir=&file=&filetype=match&who=&whotype=match&sortby=Date&hours=${num_hours}&date=${search_type}&mindate=${min_date}&maxdate=${max_date}&cvsroot=%2Fcvsroot";
+
+        if ($revision eq "") {
+            print "Getting list of checkins to $module from Bonsai...\n";
+        } else {
+            print "Getting list of checkins to $module on branch $revision from Bonsai...\n";
+        }
+        my(@files) = &get_files_from_content(&get_url_contents($url));
+
+        if ($#files > 0)
+        {
+           my(@cvs_co_list);
+        
+           my($co_file);
+           foreach $co_file (@files)
+           {
+               print "Updating $co_file\n";
+               push(@cvs_co_list, $co_file);
+           }
+
+            my($result) = $session->update($revision, \@cvs_co_list);
+            # result of 1 is success
+            if (!$result) { die "Error: Fast update failed\n"; }
+        } else {
+            print "No files in this module changed\n";        
+        }
+    }
+    
+    saveCheckoutTimestamp($checkout_start_time, $timestamp_file);
+    return 1;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// Checkout
+#//--------------------------------------------------------------------------------------------------
+sub CheckoutModules($$$)
+{
+    my($modules, $pull_date, $timestamp_file) = @_;          # list of modules to check out
+
+    my($start_time) = TimeStart();
+
+#    assertRightDirectory();
+    my($cvsfile) = AskAndPersistFile($main::filepaths{"sessionpath"});
+    my($session) = Moz::MacCVS->new( $cvsfile );
+    unless (defined($session)) { die "Error: Checkout aborted. Cannot create session file: $session" }
+
+    my($checkout_start_time) = time();
+    
+    # activate MacCVS
+    ActivateApplication('Mcvs');
+
+    my($this_co);
+    foreach $this_co (@$modules)
+    {
+        my($module, $revision, $date) = ($this_co->[0], $this_co->[1], $this_co->[2]);
+        if ($date eq "") {
+            $date = $pull_date;
+        }
+        CheckOutModule($session, $module, $revision, $date);
+        # print "Checking out $module with ref $revision, date $date\n";
+    }
+
+    saveCheckoutTimestamp($checkout_start_time, $timestamp_file);
+    TimeEnd($start_time, "Checkout");
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// ReadCheckoutModulesFile
+#//--------------------------------------------------------------------------------------------------
+sub ReadCheckoutModulesFile($$)
+{
+    my($modules_file, $co_list) = @_;
+
+    my($checkout_file) = getScriptFolder().":".$modules_file;
+    local(*CHECKOUT_FILE);  
+    open(CHECKOUT_FILE, "< $checkout_file") || die "Error: failed to open checkout list $checkout_file\n";
+    while (<CHECKOUT_FILE>)
+    {
+        my($line) = $_;
+        chomp($line);
+    
+        # ignore comments and empty lines
+        if ($line =~ /^\#/ || $line =~ /^\s*$/) {
+            next;
+        }
+    
+        my(@cvs_co) = ["", "", ""];
+        
+        my($module, $revision, $date) = (0, 1, 2);
+        
+        if ($line =~ /\s*([^#,\s]+)\s*\,\s*([^#,\s]+)\s*\,\s*([^#]+)/)
+        {
+            @cvs_co[$module] = $1;
+            @cvs_co[$revision] = $2;
+            @cvs_co[$date] = $3;
+        }
+        elsif ($line =~ /\s*([^#,\s]+)\s*\,\s*([^#,\s]+)\s*(#.+)?/)
+        {
+            @cvs_co[$module] = $1;
+            @cvs_co[$revision] = $2;
+        }
+        elsif ($line =~ /\s*([^#,\s]+)\s*\,\s*,\s*([^#,]+)/)       
+        {
+            @cvs_co[$module] = $1;
+            @cvs_co[$date] = $2;
+        }
+        elsif ($line =~ /\s*([^#,\s]+)/)
+        {
+            @cvs_co[$module] = $1;
+        }
+        else
+        {
+            die "Error: unrecognized line '$line' in $modules_file\n";
+        }
+        
+        # strip surrounding space from date
+        @cvs_co[$date] =~ s/^\s*|\s*$//g;
+        
+        # print "Going to check out '@cvs_co[$module]', '@cvs_co[$revision]', '@cvs_co[$date]'\n";
+        push(@$co_list, \@cvs_co);
+    }
+
+    close(CHECKOUT_FILE);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// PullFromCVS
+#//--------------------------------------------------------------------------------------------------
+sub PullFromCVS($$)
+{
+    unless ( $main::build{pull} ) { return; }
+    
+    my($modules_file, $timestamp_file) = @_;
+
+    StartBuildModule("pull");
+    
+    my(@cvs_co_list);
+    ReadCheckoutModulesFile($modules_file, \@cvs_co_list);
+
+    if ($main::FAST_UPDATE && $main::options{pull_by_date})
+    {
+        die "Error: you can't use FAST_UPDATE if you are pulling by date.\n";
+    }
+
+    my($did_fast_update) = $main::FAST_UPDATE && FastUpdate(\@cvs_co_list, $timestamp_file);
+    if (!$did_fast_update)
+    {
+        my($pull_date) = "";
+        if ($main::options{pull_by_date})
+        {
+            # acceptable CVS date formats are (in local time):
+            # ISO8601 (e.g. "1972-09-24 20:05") and Internet (e.g. "24 Sep 1972 20:05").
+            # Perl's localtime() string format also seems to work.
+            $pull_date = localtime().""; # force string interp.
+            print "Pulling by date $pull_date\n";
+        }
+
+        CheckoutModules(\@cvs_co_list, $pull_date, $timestamp_file);
+    }
+
+    EndBuildModule("pull");
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// RunBuild
+#//--------------------------------------------------------------------------------------------------
+sub RunBuild($$$$)
+{
+    my($do_pull, $do_build, $input_files, $build_prefs) = @_;
+
+    InitBuildProgress($input_files->{"buildprogress"});
+    
+    # if we are pulling, we probably want to do a full build, so clear the build progress
+    if ($do_pull) {
+        ClearBuildProgress();    
+    }
+    
+    # read local prefs, and the build progress file, and set flags to say what to build
+    SetupBuildParams(\%main::build,
+                     \%main::options,
+                     \%main::optiondefines,
+                     \%main::filepaths,
+                     $input_files->{"buildflags"},
+                     $build_prefs);
+    
+    # If we were told to pull, make sure we do, overriding prefs etc.
+    if ($do_pull)
+    {
+        $main::build{"pull"} = 1;
+    }
+    
+    # transfer this flag
+    $CodeWarriorLib::CLOSE_PROJECTS_FIRST = $main::CLOSE_PROJECTS_FIRST;
+    
+    # setup the build log
+    SetupBuildLog($main::filepaths{"buildlogfilepath"}, $main::USE_TIMESTAMPED_LOGS);
+    StopForErrors();
+    
+    if ($main::LOG_TO_FILE) {
+        RedirectOutputToFile($main::filepaths{"scriptlogfilepath"});
+    }
+        
+    # run a pre-build check to see that the tools etc are in order
+    DoPrebuildCheck();
+    
+    # do the pull
+    PullFromCVS($input_files->{"checkoutdata"}, $input_files->{"checkouttime"});
+    
+    unless ($do_build) { return; }
+
+    my($build_start) = TimeStart();
+
+    # check the build environment
+    ConfigureBuildSystem();
+
+    # here we load and call methods in the build module indirectly.
+    # we have to use indirection because the build module can be named
+    # differently for different builds.
+    chdir(dirname($0));     # change to the script dir
+    my($build_module) = $input_files->{"buildmodule"};
+    # load the build module
+    require $build_module;
+    {   # scope for no strict 'refs'
+        no strict 'refs';
+        
+        my($package_name) = $build_module;
+        $package_name =~ s/\.pm$//;
+        
+        chdir($main::MOZ_SRC);
+        &{$package_name."::BuildDist"}();
+        
+        chdir($main::MOZ_SRC);
+        &{$package_name."::BuildProjects"}();
+    }
+    
+    # the build finished, so clear the build progress state
+    ClearBuildProgress();
+    
+    TimeEnd($build_start, "Build");
+    print "Build complete\n";
+}
+
+1;

mozilla/build/mac/build_scripts/Moz/BuildFlags.pm

@@ -0,0 +1,425 @@
+#!perl -w
+package Moz::BuildFlags;
+
+require 5.004;
+require Exporter;
+
+# Package that attempts to read a file from the Preferences folder,
+# and get build settings out of it
+
+use strict;
+use Exporter;
+
+use Cwd;
+use File::Basename;
+
+use Moz::Moz;
+use Moz::Prefs;
+
+use vars qw(@ISA @EXPORT);
+
+@ISA      = qw(Exporter);
+@EXPORT   = qw(
+                SetupBuildParams
+                InitBuildProgress
+                WriteBuildProgress
+                ClearBuildProgress
+                ReadBuildProgress
+              );
+
+
+my(@build_flags);
+my(@options_flags);
+my(@filepath_flags);
+
+my(%arrays_list) = (
+  "build_flags",    \@build_flags,
+  "options_flags",  \@options_flags,
+  "filepath_flags", \@filepath_flags
+);
+
+my($progress_file) = "¥ÊBuild progress";
+
+#-------------------------------------------------------------------------------
+# appendArrayFlag
+# 
+# Set a flag in the array
+#-------------------------------------------------------------------------------
+sub appendArrayFlag(@)
+{
+  my($array_name) = shift;
+  my($setting) = shift;
+  my($value) = shift;
+  
+  my(@optional_values);
+  foreach (@_) {
+    push(@optional_values, $_);
+  }
+
+  my(@this_flag) = [$setting, $value, @optional_values];
+  my($flags_array) = $arrays_list{$array_name};
+  if ($flags_array)
+  {
+    push(@{$flags_array}, @this_flag) || die "Failed to append\n";
+  }
+  else
+  {
+    die "Error: unknown build flags array $array_name\n";
+  }
+}
+
+#-------------------------------------------------------------------------------
+# readFlagsFile
+# 
+# Read the file of build flags from disk. File path is relative to the
+# script directory.
+#-------------------------------------------------------------------------------
+sub readFlagsFile($)
+{
+  my($flags_file) = @_;
+
+  my($file_path) = $0;
+  $file_path =~ s/[^:]+$/$flags_file/;
+  
+  print "Reading build flags from '$file_path'\n";
+
+  local(*FLAGS_FILE);
+  open(FLAGS_FILE, "< $file_path") || die "Error: failed to open flags file $file_path\n";
+
+  my($cur_array) = "";
+  
+  while(<FLAGS_FILE>)
+  {
+      my($line) = $_;
+      chomp($line);
+      
+      # ignore comments and empty lines  
+      if ($line =~ /^\#/ || $line =~ /^\s*$/) {
+        next;
+      }
+
+      # 1-word line, probably array name
+      if ($line =~ /^([^#\s]+)\s*$/)
+      {
+        $cur_array = $1;
+        next;  
+      }
+      elsif ($line =~ /^([^#\s]+)\s+\"(.+)\"(\s+#.+)?$/)    # quoted option, possible comment
+      {
+        my($flag) = $1;
+        my($setting) = $2;
+        
+        appendArrayFlag($cur_array, $flag, $setting);
+      }
+      elsif ($line =~ /^([^#\s]+)((\s+[^#\s]+)+)(\s+#.+)?$/)  # multiple word line, possible comment
+      {
+        my($flag) = $1;
+        
+        appendArrayFlag($cur_array, $flag, split(' ', $2));
+      }
+      else
+      {
+        die "Error: unknown build flag at '$line'\n";
+      }
+  
+  }
+  
+  close(FLAGS_FILE);
+}
+
+
+
+#-------------------------------------------------------------------------------
+# flagsArrayToHash
+# 
+# Utility routine to migrate flag from a 2D array to a hash, where
+# item[n][0] is the hash entry name, and item[n][1] is the hash entry value.
+#-------------------------------------------------------------------------------
+
+sub flagsArrayToHash($$)
+{
+  my($src_array, $dest_hash) = @_;
+  
+  my($item);
+  foreach $item (@$src_array)
+  {
+    $dest_hash->{$item->[0]} = $item->[1];
+  }
+}
+
+#-----------------------------------------------
+# printHash
+#
+# Utility routine to print a hash
+#-----------------------------------------------
+sub printHash($)
+{
+  my($hash_ref) = @_;
+ 
+  print "Printing hash:\n";
+  
+  my($key, $value);
+  
+  while (($key, $value) = each (%$hash_ref))
+  {
+    print "  $key $value\n";
+  }
+}
+
+
+#-----------------------------------------------
+# printBuildArray
+#
+# Utility routine to print a 2D array
+#-----------------------------------------------
+sub printBuildArray($)
+{
+  my($build_array) = @_;
+  
+  my($entry);
+  foreach $entry (@$build_array)
+  {  
+    print "$entry->[0] = $entry->[1]\n";
+  }
+
+}
+
+#-------------------------------------------------------------------------------
+# SetBuildFlags
+#-------------------------------------------------------------------------------
+sub SetBuildFlags($)
+{
+  my($build) = @_;
+
+  flagsArrayToHash(\@build_flags, $build);
+}
+
+#-------------------------------------------------------------------------------
+# SetBuildOptions
+#-------------------------------------------------------------------------------
+sub SetBuildOptions($)
+{
+  my($options) = @_;
+
+  flagsArrayToHash(\@options_flags, $options);
+}
+
+#-------------------------------------------------------------------------------
+# SetFilepathFlags
+#-------------------------------------------------------------------------------
+sub SetFilepathFlags($)
+{
+  my($filepath) = @_;
+
+  flagsArrayToHash(\@filepath_flags, $filepath);
+}
+
+#-------------------------------------------------------------------------------
+# SetOptionDefines
+#-------------------------------------------------------------------------------
+sub SetOptionDefines($)
+{
+  my($optiondefines) = @_;
+
+  foreach my $entry (@options_flags)
+  {
+    if (defined($entry->[2])) {
+      $optiondefines->{$entry->[0]}{$entry->[2]} = 1;
+    }
+  }
+}
+
+
+#-------------------------------------------------------------------------------
+# PropagateAllFlags
+#-------------------------------------------------------------------------------
+sub PropagateAllFlags($)
+{
+  my($build_array) = @_;
+  
+  # if "all" is set, set all the flags to 1
+  unless ($build_array->[0][0] eq "all") { die "Error: 'all' must come first in the flags array\n"; }
+  
+  if ($build_array->[0][1] == 1)
+  {
+    my($index);
+    foreach $index (@$build_array)
+    {
+      $index->[1] = 1;
+    }
+  }
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// _getBuildProgressFile
+#//--------------------------------------------------------------------------------------------------
+sub _getBuildProgressFile()
+{
+  return $progress_file;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// setBuildProgressStart
+#// 
+#// This automagically sets $build{"all"} to 0
+#//--------------------------------------------------------------------------------------------------
+sub setBuildProgressStart($$)
+{
+  my($build_array, $name) = @_;
+
+  my($index);
+  foreach $index (@$build_array)
+  {
+    $index->[1] = 0;
+    if ($index->[0] eq $name) {
+      last;
+    }    
+  }
+
+  print "Building from module after $name, as specified by build progress\n";
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// InitBuildProgress
+#//--------------------------------------------------------------------------------------------------
+sub InitBuildProgress($)
+{
+  my($prog_file) = @_;
+  if ($prog_file ne "") {
+    $progress_file = full_path_to($prog_file);
+    print "Writing build progress to $progress_file\n";
+  }
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// WriteBuildProgress
+#//--------------------------------------------------------------------------------------------------
+sub WriteBuildProgress($)
+{
+  my($module_built) = @_;
+
+  my($progress_file) = _getBuildProgressFile();
+  
+  if ($progress_file ne "")
+  {
+    open(PROGRESS_FILE, ">>$progress_file") || die "Failed to open $progress_file\n";
+    print(PROGRESS_FILE "$module_built\n");
+    close(PROGRESS_FILE);
+  }
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// ClearBuildProgress
+#//--------------------------------------------------------------------------------------------------
+sub ClearBuildProgress()
+{
+  my($progress_file) = _getBuildProgressFile();
+  if ($progress_file ne "") {
+    unlink $progress_file;
+  }
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// WipeBuildProgress
+#//--------------------------------------------------------------------------------------------------
+sub WipeBuildProgress()
+{
+  print "Ignoring build progress\n";
+  ClearBuildProgress();
+  $progress_file = "";
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// ReadBuildProgress
+#//--------------------------------------------------------------------------------------------------
+sub ReadBuildProgress($)
+{
+  my($build_array) = @_;
+  my($progress_file) = _getBuildProgressFile();
+
+  my($last_module);
+  
+  if (open(PROGRESS_FILE, "< $progress_file"))
+  {
+    print "Getting build progress from $progress_file\n";
+    
+    while (<PROGRESS_FILE>)
+    {
+      my($line) = $_;
+      chomp($line);
+      $last_module = $line;
+    }
+    
+    close(PROGRESS_FILE);
+  }
+  
+  if ($last_module)
+  {
+    setBuildProgressStart($build_array, $last_module);
+  }
+}
+
+#-------------------------------------------------------------------------------
+# clearOldBuildSettings
+#-------------------------------------------------------------------------------
+sub clearOldBuildSettings($$$$)
+{
+  my($build, $options, $optiondefines, $filepaths) = @_;
+
+  # empty the arrays in case we're being called twice
+  @build_flags = ();
+  @options_flags = ();
+  @filepath_flags = ();
+  
+  # and empty the hashes
+  %$build = ();
+  %$options = ();
+  %$optiondefines = ();
+  %$filepaths = ();
+}
+
+#-------------------------------------------------------------------------------
+# SetupBuildParams
+#-------------------------------------------------------------------------------
+sub SetupBuildParams($$$$$$)
+{
+  my($build, $options, $optiondefines, $filepaths, $flags_file, $prefs_file) = @_;
+  
+  # Empty the hashes and arrays, to wipe out any stale data.
+  # Needed because these structures persist across two build scripts
+  # called using 'do' from a parent script.
+  clearOldBuildSettings($build, $options, $optiondefines, $filepaths);
+  
+  # Read from the flags file, which sets up the various arrays
+  readFlagsFile($flags_file);
+  
+  # If 'all' is set in the build array, propagate that to all entries
+  PropagateAllFlags(\@build_flags);
+  
+  # read the user pref file, that can change values in the array
+  ReadMozUserPrefs($prefs_file, \@build_flags, \@options_flags, \@filepath_flags);
+
+  # If build progress exists, this clears flags in the array up to a certain point
+  if ($main::USE_BUILD_PROGRESS) {
+    ReadBuildProgress(\@build_flags);
+  } else {
+    WipeBuildProgress();
+  }
+  
+#  printBuildArray(\@build_flags);
+#  printBuildArray(\@options_flags);
+  
+  SetBuildFlags($build);
+  SetBuildOptions($options);
+  SetOptionDefines($optiondefines);
+  SetFilepathFlags($filepaths);
+  
+#  printHash($build);
+#  printHash($options);
+}
+
+
+1;

mozilla/build/mac/build_scripts/Moz/BuildUtils.pm

@@ -0,0 +1,786 @@
+
+package Moz::BuildUtils;
+
+require 5.004;
+require Exporter;
+
+# Package that contains build util functions specific to the Mozilla build
+# process.
+
+use strict;
+use Exporter;
+
+use Cwd;
+use File::Path;
+use File::Basename;
+
+use Mac::Events;
+use Mac::StandardFile;
+
+use Moz::Moz;
+use Moz::BuildFlags;
+use Moz::MacCVS;
+#use Moz::ProjectXML;  #optional; required for static build only
+
+use vars qw(@ISA @EXPORT);
+
+@ISA      = qw(Exporter);
+@EXPORT   = qw(
+                SetupDefaultBuildOptions
+                SetupBuildRootDir
+                StartBuildModule
+                EndBuildModule
+                GetBinDirectory
+                BuildOneProjectWithOutput
+                BuildOneProject
+                BuildProject
+                BuildProjectClean
+                BuildIDLProject
+                BuildFolderResourceAliases
+                AskAndPersistFile
+                DelayFor
+                TimeStart
+                TimeEnd
+                EmptyTree
+                SetupBuildLog
+                SetBuildNumber
+                SetTimeBomb
+                UpdateConfigHeader
+              );
+
+#//--------------------------------------------------------------------------------------------------
+#// SetupDefaultBuildOptions
+#//--------------------------------------------------------------------------------------------------
+sub SetupDefaultBuildOptions($$$)
+{
+    my($debug, $bin_dir, $config_header_file_name) = @_;
+
+    # Here we set up defaults for the various build flags.
+    # If you want to override any of these, it's best to do
+    # so via the relevant preferences file, which lives in
+    # System Folder:Preferences:Mozilla build prefs:{build prefs file}.
+    # For the name of the prefs file, see the .pl script that you
+    # run to start this build. The prefs files are created when
+    # you run the build, and contain some documentation.
+    
+    #-------------------------------------------------------------
+    # configuration variables that globally affect what is built
+    #-------------------------------------------------------------
+    $main::DEBUG                  = $debug;
+    $main::PROFILE                = 0;
+    $main::RUNTIME                = 0;    # turn on to just build runtime support and NSPR projects
+    $main::GC_LEAK_DETECTOR       = 0;    # turn on to use GC leak detection
+    $main::MOZILLA_OFFICIAL       = 0;    # generate build number
+    $main::LOG_TO_FILE            = 0;    # write perl output to a file
+    
+    #-------------------------------------------------------------
+    # configuration variables that affect the manner of building, 
+    # but possibly affecting the outcome.
+    #-------------------------------------------------------------    
+    $main::ALIAS_SYM_FILES        = $main::DEBUG;
+    $main::CLOBBER_LIBS           = 1;      # turn on to clobber existing libs and .xSYM files before
+                                            # building each project                         
+    # The following two options will delete all dist files (if you have $main::build{dist} turned on),
+    # but leave the directory structure intact.
+    $main::CLOBBER_DIST_ALL       = 1;    # turn on to clobber all aliases/files inside dist (headers/xsym/libs)
+    $main::CLOBBER_DIST_LIBS      = 0;    # turn on to clobber only aliases/files for libraries/sym files in dist
+    $main::CLOBBER_IDL_PROJECTS   = 0;    # turn on to clobber all IDL projects.
+    $main::CLOBBER_PROJECTS       = 0;    # turn on to remove object code from each project before building it
+    
+    $main::UNIVERSAL_INTERFACES_VERSION = 0x0320;
+    
+    #-------------------------------------------------------------
+    # configuration variables that are preferences for the build,
+    # style and do not affect what is built.
+    #-------------------------------------------------------------
+    $main::CLOSE_PROJECTS_FIRST   = 0;
+                                    # 1 = close then make (for development),
+                                    # 0 = make then close (for tinderbox).
+    $main::USE_TIMESTAMPED_LOGS   = 0;
+    $main::USE_BUILD_PROGRESS     = 1;    # track build progress for restartable builds
+    #-------------------------------------------------------------
+    # END OF CONFIG SWITCHES
+    #-------------------------------------------------------------
+    
+    $main::BIN_DIRECTORY = $bin_dir;
+    $main::DEFINESOPTIONS_FILE = $config_header_file_name;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// SetupBuildRootDir
+#//--------------------------------------------------------------------------------------------------
+sub SetupBuildRootDir($)
+{
+    my($rel_path_to_script) = @_;
+
+    my($cur_dir) = cwd();
+    $cur_dir =~ s/$rel_path_to_script$//;
+    chdir($cur_dir) || die "Error: failed to set build root directory to '$cur_dir'.\nYou probably need to put 'mozilla' one level down (in a folder).\n";
+    $main::MOZ_SRC = cwd();
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// StartBuildModule
+#//--------------------------------------------------------------------------------------------------
+sub StartBuildModule($)
+{
+    my($module) = @_;
+
+    print("---- Start of $module ----\n");
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// EndBuildModule
+#//--------------------------------------------------------------------------------------------------
+sub EndBuildModule($)
+{
+    my($module) = @_;
+    WriteBuildProgress($module);
+    print("---- End of $module ----\n");
+}
+
+#--------------------------------------------------------------------------------------------------
+# GetBinDirectory
+#--------------------------------------------------------------------------------------------------
+sub GetBinDirectory()
+{
+    if ($main::BIN_DIRECTORY eq "") { die "Dist directory not set\n"; }
+    return $main::BIN_DIRECTORY;
+}
+
+#--------------------------------------------------------------------------------------------------
+# AskAndPersistFile stores the information about the user pick inside
+# the file $session_storage
+#--------------------------------------------------------------------------------------------------
+sub AskAndPersistFile($)
+{
+    my ($sessionStorage) = @_;
+    my $cvsfile;
+
+    if (( -e $sessionStorage) &&
+        open( SESSIONFILE, $sessionStorage ))
+    {
+    # Read in the path if available
+        $cvsfile = <SESSIONFILE>;
+        chomp $cvsfile;
+        close SESSIONFILE;
+        if ( ! -e $cvsfile )
+        {
+            print STDERR "$cvsfile has disappeared\n";
+            undef $cvsfile;
+        }
+    }
+    unless (defined ($cvsfile))
+    {
+        # make sure that MacPerl is a front process
+        ActivateApplication('McPL');
+        MacPerl::Answer("Could not find your MacCVS session file. Please choose one", "OK");
+        
+        # prompt user for the file name, and store it
+        my $macFile = StandardGetFile( 0, "McvD");  
+        if ( $macFile->sfGood() )
+        {
+            $cvsfile = $macFile->sfFile();
+            # save the choice if we can
+            if ( open (SESSIONFILE, ">" . $sessionStorage))
+            {
+                printf SESSIONFILE $cvsfile, "\n";
+                close SESSIONFILE;
+            }
+            else
+            {
+                print STDERR "Could not open storage file $sessionStorage for saving $cvsfile\n";
+            }
+        }
+    }
+    return $cvsfile;
+}
+
+
+#--------------------------------------------------------------------------------------------------
+# BuildIDLProject
+#
+#--------------------------------------------------------------------------------------------------
+
+sub BuildIDLProject($$)
+{
+    my ($project_path, $module_name) = @_;
+
+    if ($main::CLOBBER_IDL_PROJECTS)
+    {
+        my (@suffix_list) = (".mcp", ".xml");
+        my ($project_name, $project_dir, $suffix) = fileparse($project_path, @suffix_list);
+        if ($suffix eq "") { die "Error: Project, $project_path must end in .xml or .mcp\n"; }
+
+        my($datafolder_path);
+        if ($suffix eq ".xml")
+        {
+            $datafolder_path = $project_dir . "_" . $project_name . " Data:";
+        }
+        else {
+            $datafolder_path = $project_dir . $project_name . " Data:";
+        }
+
+        print STDERR "Deleting IDL data folder: $datafolder_path\n";
+        EmptyTree($datafolder_path);
+    }
+
+    BuildOneProject($project_path,  "headers", 0, 0, 0);
+    BuildOneProject($project_path,  $module_name.".xpt", 1, 0, 1);
+}
+
+
+#--------------------------------------------------------------------------------------------------
+# CreateStaticLibTargets
+#
+#--------------------------------------------------------------------------------------------------
+sub CreateXMLStaticLibTargets($)
+{
+    my($xml_path) = @_;
+
+    my (@suffix_list) = (".xml");
+    my ($project_name, $project_dir, $suffix) = fileparse($xml_path, @suffix_list);
+    if ($suffix eq "") { die "XML munging: $xml_path must end in .xml\n"; }
+
+    #sniff the file to see if we need to fix up broken Pro5-exported XML
+    print "Parsing $xml_path\n";
+    
+    my $ide_version = Moz::ProjectXML::SniffProjectXMLIDEVersion($xml_path);
+    if ($ide_version eq "4.0")
+    {
+        my $new_file = $project_dir.$project_name."2.xml";
+        
+        print "Cleaning up Pro 5 xml to $new_file\n";
+        
+        Moz::ProjectXML::CleanupPro5XML($xml_path, $new_file);
+
+        unlink $xml_path;
+        rename ($new_file, $xml_path);
+    }
+    
+    my $doc = Moz::ProjectXML::ParseXMLDocument($xml_path);
+    my @target_list = Moz::ProjectXML::GetTargetsList($doc);
+    my $target;
+    
+    my %target_hash;    # for easy lookups below
+    foreach $target (@target_list) { $target_hash{$target} = 1; }
+    
+    foreach $target (@target_list)
+    {
+        if ($target =~ /(.+).shlb$/)        # if this is a shared lib target
+        {
+            my $target_base = $1;
+            my $static_target = $target_base.".o";
+            
+            # ensure that this does not exist already
+            if ($target_hash{$static_target}) {
+                print "Static target $static_target already exists in project. Not making\n";
+                next;
+            }
+            
+            print "Making static target '$static_target' from target '$target'\n";
+
+            Moz::ProjectXML::CloneTarget($doc, $target, $static_target);
+            Moz::ProjectXML::SetAsStaticLibraryTarget($doc, $static_target, $static_target);
+        }
+    }
+    
+    print "Writing XML file to $xml_path\n";
+    my $temp_path = $project_dir."_".$project_name.".xml";
+    Moz::ProjectXML::WriteXMLDocument($doc, $temp_path, $ide_version);
+    Moz::ProjectXML::DisposeXMLDocument($doc);
+    
+    if (-e $temp_path)
+    {
+        unlink $xml_path;
+        rename ($temp_path, $xml_path);
+    }
+    else
+    {
+        die "Error: Failed to add new targets to XML project\n";
+    }
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// ProcessProjectXML
+#// 
+#// Helper routine to allow for XML pre-processing. This should read in the XML, process it,
+#// and replace the original file with the processed version.
+#//--------------------------------------------------------------------------------------------------
+sub ProcessProjectXML($)
+{
+    my($xml_path) = @_;
+  
+    # we need to manually load Moz::ProjectXML, becaues not everyone will have the
+    # required perl modules in their distro.
+    my($cur_dir) = cwd();
+    
+    chdir(dirname($0));     # change to the script dir
+    eval "require Moz::ProjectXML";
+    if ($@) { die "Error: could not do Project XML munging because you do not have the correct XML modules installed. Error is:\n################\n $@################"; }
+    
+    chdir($cur_dir);
+    
+    CreateXMLStaticLibTargets($xml_path);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// Build one project, and make the alias. Parameters are project path, target name, shared  library
+#// name, make shlb alias (boolean), make xSYM alias (boolean), and is component (boolean).
+#//--------------------------------------------------------------------------------------------------
+
+sub BuildOneProjectWithOutput($$$$$$)
+{
+    my ($project_path, $target_name, $output_name, $alias_lib, $alias_xSYM, $component) = @_;
+
+    unless ($project_path =~ m/^$main::BUILD_ROOT.+/) { return; }
+
+    my (@suffix_list) = (".mcp", ".xml");
+    my ($project_name, $project_dir, $suffix) = fileparse($project_path, @suffix_list);
+    if ($suffix eq "") { die "Error: Project, $project_path must end in .xml or .mcp\n"; }
+    
+    my($dist_dir) = GetBinDirectory();
+    
+    # Put libraries in "Essential Files" folder, Components in "Components" folder
+    my($output_dir)  = $component ? "Components:" : "Essential Files:";
+    my($output_path) = $dist_dir.$output_dir;
+
+    if ($main::options{static_build})
+    {      
+      if ($output_name =~ /\.o$/ || $output_name =~ /\.[Ll]ib$/)
+      {
+        $alias_xSYM = 0;
+        $alias_lib  = 1;
+        $output_path = $main::DEBUG ? ":mozilla:dist:static_libs_debug:" : ":mozilla:dist:static_libs:";
+      }
+    }
+
+    # if the flag is on to export projects to XML, export and munge them
+    if ($main::EXPORT_PROJECTS && !($project_path =~ /IDL\.mcp$/))
+    {
+        my $xml_out_path = $project_path;
+
+        $xml_out_path =~ s/\.mcp$/\.xml/;
+
+        # only do this if project is newer?
+        if (! -e $xml_out_path)
+        {
+          ExportProjectToXML(full_path_to($project_path), full_path_to($xml_out_path));
+          ProcessProjectXML($xml_out_path);
+        }
+    }
+        
+    # if the flag is set to use XML projects, default to XML if the file 
+    # is present.
+    if ($main::USE_XML_PROJECTS && !($project_path =~ /IDL\.mcp$/))
+    {
+      my $xml_project_path = $project_dir.$project_name.".xml";
+      if (-e $xml_project_path)
+      {
+        $project_path = $xml_project_path;
+        $suffix = ".xml";
+      }
+    }
+    
+    if ($suffix eq ".xml")
+    {
+        my($xml_path) = $project_path;
+        # Prepend an "_" onto the name of the generated project file so it doesn't conflict
+        $project_path = $project_dir . "_" . $project_name . ".mcp";
+        my($project_modtime) = (-e $project_path ? GetFileModDate($project_path) : 0);
+        my($xml_modtime) = (-e $xml_path ? GetFileModDate($xml_path) : 0);
+
+        if ($xml_modtime > $project_modtime)
+        {
+            print("Importing $project_path from $project_name.xml.\n");
+            unlink($project_path);
+            # Might want to delete the "xxx.mcp Data" dir ???
+            ImportXMLProject(full_path_to($xml_path), full_path_to($project_path));
+        }
+    }
+
+
+    if ($main::CLOBBER_LIBS)
+    {
+        unlink "$project_dir$output_name";              # it's OK if these fail
+        unlink "$project_dir$output_name.xSYM";
+    }
+    
+    DoBuildProject($project_path, $target_name, $main::CLOBBER_PROJECTS);
+    
+    $alias_lib  ? MakeAlias("$project_dir$output_name",      "$output_path") : 0;
+    $alias_xSYM ? MakeAlias("$project_dir$output_name.xSYM", "$output_path") : 0;
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// For compatiblity with existing scripts, BuildOneProject now just calls
+#// BuildOneProjectWithOutput, with the output name and target name identical.
+#// Note that this routine assumes that the target name and the shared libary name
+#// are the same.
+#//--------------------------------------------------------------------------------------------------
+
+sub BuildOneProject($$$$$)
+{
+    my ($project_path, $target_name, $alias_lib, $alias_xSYM, $component) = @_;
+    
+	BuildOneProjectWithOutput($project_path, $target_name, $target_name,
+							  $alias_lib, $alias_xSYM, $component);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// For compatiblity with existing scripts, BuildProject now just calls
+#// BuildOneProjectWithOutput, with the output name and target name identical.
+#// Note that this routine assumes that the target name and the shared libary name
+#// are the same. No aliases of the output are made.
+#//--------------------------------------------------------------------------------------------------
+
+sub BuildProject($$)
+{
+    my ($project_path, $target_name) = @_;
+    
+	BuildOneProjectWithOutput($project_path, $target_name, $target_name, 0, 0, 0);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// Identical to BuildProject but clobbers the project before building it.
+#//--------------------------------------------------------------------------------------------------
+
+sub BuildProjectClean($$)
+{
+    my ($project_path, $target_name) = @_;
+    my ($save_clobber_flag) = $main::CLOBBER_PROJECTS;
+    $main::CLOBBER_PROJECTS = 1;
+	BuildOneProjectWithOutput($project_path, $target_name, $target_name, 0, 0, 0);
+	$main::CLOBBER_PROJECTS = $save_clobber_flag;
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// Make resource aliases for one directory
+#//--------------------------------------------------------------------------------------------------
+
+sub BuildFolderResourceAliases($$)
+{
+    my($src_dir, $dest_dir) = @_;
+        
+    # get a list of all the resource files
+    opendir(SRCDIR, $src_dir) || die("can't open $src_dir");
+    my(@resource_files) = readdir(SRCDIR);
+    closedir(SRCDIR);
+    
+    # make aliases for each one into the dest directory
+    print("Placing aliases to all files from $src_dir in $dest_dir\n");
+    for ( @resource_files )
+    {
+        next if $_ eq "CVS";
+        #print("    Doing $_\n");
+        if (-l $src_dir.$_)
+        {
+            print("     $_ is an alias\n");
+            next;
+        }
+        my($file_name) = $src_dir . $_; 
+        MakeAlias($file_name, $dest_dir);
+    }
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// DelayFor
+#//
+#// Delay for the given number of seconds, allowing the script to be cancelled
+#//--------------------------------------------------------------------------------------------------
+
+sub DelayFor($)
+{
+  my($delay_secs) = @_;
+  
+  STDOUT->autoflush(1);
+  
+  my($end_time) = time() + $delay_secs;
+    
+  my($last_time) = 0;
+  my($cur_time) = time();
+  
+  while ($cur_time < $end_time)
+  {
+    $cur_time = time();
+    if ($cur_time > $last_time)
+    {
+      print ".";
+      $last_time = $cur_time;
+    }
+    
+    WaitNextEvent();
+  }
+
+  print "\n";
+  STDOUT->autoflush(0);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// TimeStart
+#//--------------------------------------------------------------------------------------------------
+sub TimeStart()
+{
+    return time();
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// TimeEnd
+#//--------------------------------------------------------------------------------------------------
+sub TimeEnd($$)
+{
+    use integer;
+    
+    my($start_time, $operation_name) = @_;
+    my($end_time) = time();
+    
+    my($tot_sec) = $end_time - $start_time;
+    
+    my($seconds) = $tot_sec;
+    
+    my($hours) = $seconds / (60 * 60);
+    $seconds -= $hours * (60 * 60);
+    
+    my($minutes) = $seconds / 60;
+    $seconds -= $minutes * 60;
+        
+    print "$operation_name took $hours hours $minutes minutes and $seconds seconds\n";
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// Remove all files from a tree, leaving directories intact (except "CVS").
+#//--------------------------------------------------------------------------------------------------
+
+sub EmptyTree($)
+{
+    my ($root) = @_; 
+    #print "EmptyTree($root)\n";
+    opendir(DIR, $root);
+    my $sub;
+    foreach $sub (readdir(DIR))
+    {
+        my $fullpathname = $root.$sub; # -f, -d only work on full paths
+
+        # Don't call empty tree for the alias of a directory.
+        # -d returns true for the alias of a directory, false for a broken alias)
+
+        if (-d $fullpathname)
+        {
+            if (-l $fullpathname)   # delete aliases
+            {
+                unlink $fullpathname;
+                next;
+            }
+            EmptyTree($fullpathname.":");
+            if ($sub eq "CVS")
+            {
+                #print "rmdir $fullpathname\n";
+                rmdir $fullpathname;
+            }
+        }
+        else
+        {
+            unless (unlink $fullpathname) { die "Failed to delete $fullpathname\n"; }
+        }
+    }
+    closedir(DIR);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// Recurse through a directory hierarchy, looking for MANIFEST files.
+#// Currently unused.
+#//--------------------------------------------------------------------------------------------------
+
+sub ScanForManifestFiles($$$$)
+{
+    my($dir, $theme_root, $theme_name, $dist_dir) = @_;
+
+    opendir(DIR, $dir) or die "Cannot open dir $dir\n";
+    my @files = readdir(DIR);
+    closedir DIR;
+
+    my $file;
+
+    foreach $file (@files)
+    {    
+        my $filepath = $dir.":".$file;
+
+        if (-d $filepath)
+        {
+            # print "Looking for MANIFEST files in $filepath\n";        
+            ScanForManifestFiles($filepath, $theme_root, $theme_name, $dist_dir);
+        }
+        elsif ($file eq "MANIFEST")
+        {
+            # print "Doing manifest file $filepath\n";
+
+            # Get the dest path from the first line of the file
+
+            open(MANIFEST, $filepath) || die "Could not open file $file";
+            # Read in the path if available
+            my($dest_line) = <MANIFEST>;
+            chomp $dest_line;
+            close MANIFEST;
+
+            $dest_line =~ s|^#!dest[\t ]+|| || die "No destination line found in $filepath\n";
+
+            my($dest_path) = $dist_dir."chrome:skins:$theme_name:$dest_line";
+            # print " Destination is $dest_path\n";
+
+            InstallResources($filepath, "$dest_path", 0);
+        }
+    }
+}
+
+
+#-----------------------------------------------
+# SetupBuildLog
+#-----------------------------------------------
+sub SetupBuildLog($$)
+{
+    my($logfile_path, $timestamped_log) = @_;
+    
+    my($logdir) = "";
+    my($logfile) = $logfile_path;
+    
+    if ($logfile_path =~ /(.+?:)([^:]+)$/)       # ? for non-greedy match
+    {
+        $logdir = $1;
+        $logfile = $2;
+        
+        mkpath($logdir);
+    }
+    
+    if ($timestamped_log)
+    {
+        #Use time-stamped names so that you don't clobber your previous log file!
+        my $now = localtime();
+        while ($now =~ s@:@.@) {} # replace all colons by periods
+        OpenErrorLog("${logdir}${now}");
+    }
+    else
+    {
+        OpenErrorLog("${logdir}${logfile}");
+    }
+}
+
+#-----------------------------------------------
+# SetBuildNumber
+#-----------------------------------------------
+sub SetBuildNumber($$)
+{
+    my($build_num_file, $files_to_touch) = @_;
+
+    # Make sure we add the config dir to search, to pick up mozBDate.pm
+    # Need to do this dynamically, because this module can be used before
+    # mozilla/config has been checked out.
+    
+    my ($inc_path) = $0;        # $0 is the path to the parent script
+    $inc_path =~ s/:build:mac:build_scripts:.+$/:config/;
+    push(@INC, $inc_path);
+
+    require mozBDate;
+    
+    mozBDate::UpdateBuildNumber($build_num_file, $main::MOZILLA_OFFICIAL);
+   
+    my($file);
+    foreach $file (@$files_to_touch)
+    {
+        print "Writing build number to $file from ${file}.in\n";
+        mozBDate::SubstituteBuildNumber($file, $build_num_file, "${file}.in");
+    }
+}
+
+#-----------------------------------------------
+# SetTimeBomb
+#-----------------------------------------------
+sub SetTimeBomb($$)		
+{
+  my ($warn_days, $bomb_days) = @_;
+  
+  system("perl :mozilla:config:mac-set-timebomb.pl $warn_days $bomb_days");
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// Regenerate a configuration header file if necessary
+#//--------------------------------------------------------------------------------------------------
+sub UpdateConfigHeader($)
+{
+    my($config_path) = @_;
+    
+    my($config, $oldconfig) = ("", "");
+    my($define, $definevalue, $defines);
+    my($k, $l,);
+
+    foreach $k (keys(%main::options))
+    {
+        if ($main::options{$k})
+        {
+            foreach $l (keys(%{$main::optiondefines{$k}}))
+            {
+                $my::defines{$l} = $main::optiondefines{$k}{$l};
+                print "Setting up my::defines{$l}\n";
+            }
+        }
+    }
+
+    my $config_headerfile = current_directory().$config_path;
+    if (-e $config_headerfile)
+    {
+        open(CONFIG_HEADER, "< $config_headerfile") || die "$config_headerfile: $!\n";
+        my($line);
+        while ($line = <CONFIG_HEADER>)
+        {
+            if ($line =~ m/#define\s+([^\s]*)\s+([^\s]*)\s*\n/)
+            {
+                $define = $1;
+                $definevalue = $2;
+                
+                #canonicalize so that whitespace changes are not significant
+                my $canon_value = "#define " . $define . " " . $definevalue . "\n";
+                $oldconfig .= $canon_value;
+                
+                if (exists ($my::defines{$define}) and ($my::defines{$define} == $definevalue))
+                {
+                    delete $my::defines{$define};
+                    $config .= $canon_value;
+                }
+            }
+        }
+        close(CONFIG_HEADER);
+    }
+
+    if (%my::defines)
+    {
+        foreach $k (keys(%my::defines))
+        {
+            $config .= "#define " . $k . " " . $my::defines{$k} . "\n";
+        }
+    }
+
+    my $file_name = basename($config_headerfile);
+    if (($config ne $oldconfig) || (!-e $config_headerfile))
+    {
+        printf("Writing new configuration header $file_name\n");
+        open(CONFIG_HEADER, "> $config_headerfile") || die "$config_headerfile: $!\n";
+        print(CONFIG_HEADER "/* This file is auto-generated based on build options. Do not edit. */\n");
+        print CONFIG_HEADER ($config);
+        close(CONFIG_HEADER);
+
+        MacPerl::SetFileInfo("CWIE", "TEXT", $config_headerfile);
+    }
+    else
+    {
+        printf("Configuration header $file_name is up-to-date\n");
+    }
+}
+
+
+1;
+

mozilla/build/mac/build_scripts/Moz/CodeWarriorLib.pm

@@ -0,0 +1,660 @@
+#!perl
+package Moz::CodeWarriorLib;
+
+=pod
+
+=head1 NAME
+
+CodeWarriorLib - supply interface to CodeWarrior
+
+=head1 SYNOPSIS
+
+	#!perl
+	use CodeWarriorLib;
+	CodeWarriorLib::activate();
+	$had_errors = CodeWarriorLib::build_project(
+		$project_path, $target_name, $recent_errors_file, $clean_build
+	);
+
+=head1 DESCRIPTION
+
+Replaces the AppleScript library I<CodeWarriorLib>.
+
+=over 4
+
+=cut
+
+use strict;
+
+use Cwd;
+use File::Basename;
+
+use Mac::Types;
+use Mac::Events;
+use Mac::AppleEvents;
+use Mac::AppleEvents::Simple;
+use Mac::Processes;
+use Mac::MoreFiles;
+use Mac::StandardFile;
+
+
+use vars qw($VERSION);
+$VERSION = '1.02';
+
+my($app)  = 'CWIE';
+my($scriptDir) = cwd();         # could use $0 for this
+my($ide_loc_file) = "";
+
+# 0 == don't switch CWIE to front app in do_event(), 1 == do switch
+# note: activate() still switches when called
+$Mac::AppleEvents::Simple::SWITCH = 0;
+# $Mac::AppleEvents::Simple::WARN = 1;
+
+# supply your own path to the source here
+#_test('PowerPudgeIV:mozilla:mozilla:');
+
+# If you want to understand the gobbldeygook that's used to build Apple Events,
+# you should start by reading the AEGizmos documentation.
+
+=pod
+
+=item _get_project($full_path)
+
+A private routine returning a reference to the open project with the given name,
+or else the empty string (when that project is not open)
+
+full_path is a string identifying the project to be built and is of the form, 
+e.g., "HD:ProjectFolder:MyProject.mcp".  It must be supplied.
+
+=cut
+
+sub _get_project ($) {
+	my(
+		$full_path, $candidate_projects
+	) = @_;
+	$candidate_projects = _doc_named(basename($full_path, '*'));
+	if ($candidate_projects) {
+		my($cps) = _get_dobj($candidate_projects);
+		my($num) = AECountItems($cps);
+		if ($num) {  # is a list
+			foreach (1 .. AECountItems($cps)) {
+				my($cp) = AEGetNthDesc($cps, $_);
+				if (lc $full_path eq lc _full_path($cp)) {
+					return($cp);
+				}
+			}
+		} else {     # is only one, not a list
+			if (lc $full_path eq lc _full_path($cps)) {
+				return($cps);
+			}
+		}
+	}
+	return;
+}
+
+=pod
+
+=item build_project
+
+Build a selected target of a project, saving any errors to a file, if supplied.
+	
+full_path is a string identifying the project to be built and is of the form, 
+e.g., "HD:ProjectFolder:MyProject.mcp".  It must be supplied.
+
+If target_name is the empty string, the current target of the selected project 
+will be built, else, target_name should be a string matching a target name in 
+the selected project.
+	
+If error_path is the empty string, errors will not be saved to a file,
+else, error_path should be the full path of a file to save error messages into.
+
+=cut
+
+$CodeWarriorLib::CLOSE_PROJECTS_FIRST = 0; # If true we close then make. If false, make then close.
+my $last_project_built = "";
+my $last_project_was_closed = 0;
+
+sub build_project ($;$$$) {
+	my(
+		$full_path, $target_name, $error_path,
+		$remove_object, $p, $project_was_closed, $had_errors
+	) = @_;
+	_close_errors_window();
+
+	if ($CodeWarriorLib::CLOSE_PROJECTS_FIRST && ($last_project_built ne $full_path))
+	{
+		# If we're in "close first" mode, we don't close if the current project
+		# is the same as the previous one.
+		if ($last_project_was_closed) {
+			$p = _get_project($last_project_built);
+			_close($p);
+		}
+		$last_project_built = $full_path;
+		$last_project_was_closed = 0; # now refers to the new project
+	}
+	$project_was_closed = 0;
+	while (1) {
+		$p = _get_project($full_path);
+		if (!$p) {
+			if ($project_was_closed) {
+				print "### Error - request for project document failed after opening\n";
+				die "### possibly CW Pro 4 bug: be sure to close your Find window\n";
+			}
+			$project_was_closed = 1;
+			$last_project_was_closed = 1;
+			_open_file($full_path);
+		} else {
+			last;
+		}
+	}
+
+	$had_errors = 0;
+	if ($target_name eq '') {
+		if ($remove_object) {_remove_object($p)}
+		_build($p);
+	} else {
+		if ($remove_object) {_remove_object($p, $target_name)}
+		_build($p, $target_name);
+	}
+
+	if ($error_path ne '') {
+		_save_errors_window($error_path);
+	}
+	$had_errors = _close_errors_window();
+
+	if (!$CodeWarriorLib::CLOSE_PROJECTS_FIRST)
+	{
+		if ($project_was_closed) {
+			$p = _get_project($full_path);
+			_close($p);
+		}
+	}
+
+	return($had_errors);
+}
+
+=pod
+
+=item appIsRunning()
+
+=cut
+sub _appIsRunning($)
+{
+	my ($appSignature) = @_;
+	my ($psi);
+	my ($found) = 0;
+	my ($appPSN);
+
+	foreach $psi (values(%Process))
+	{
+		if ($psi->processSignature() eq $appSignature)
+		{
+			$appPSN = $psi->processNumber();
+			$found = 1;
+            last;
+		}
+	}
+	
+	return $found;
+}
+
+=pod
+
+=item appIsFrontmost()
+
+=cut
+sub _appIsFrontmost($)
+{
+	my ($appSignature) = @_;
+	my ($psi);
+	my ($found) = 0;
+	my ($appPSN);
+
+	foreach $psi (values(%Process))
+	{
+		if ($psi->processSignature() eq $appSignature)
+		{
+			$appPSN = $psi->processNumber();
+			$found = 1;
+            last;
+		}
+	}
+	
+	return (GetFrontProcess() == $appPSN);
+}
+
+
+=pod
+
+=item activate()
+
+Launches CodeWarrior and brings it to the front.
+
+Once found, path will be saved in $idepath_file for future reference.
+Edit or delete this file to change the location of the IDE.  If app is
+moved, C<activate()> will prompt for a new location.
+
+First looks for an open CodeWarrior app.  Second, tries to open previously
+saved location in ':idepath.txt'.  Third, tries to find it and allow user
+to choose it with Navigation Services (if present).  Fourth, uses good old
+GUSI routines built-in to MacPerl for a Choose Directory dialog box.
+
+=cut
+
+sub activate ($) {
+
+    $ide_loc_file = $_[0];     # save in global
+        
+	my($filepath, $appath, $psi) = ($ide_loc_file);
+
+	foreach $psi (values(%Process)) {
+		if ($psi->processSignature() eq $app) {
+			$appath = $psi->processAppSpec();
+			_save_appath($filepath, $appath);
+			last;
+		}
+	}
+
+	if (!$appath || !-x $appath) {
+		$appath = _read_appath($filepath);
+	}
+	
+	if (!$appath || ! -x $appath)
+	{
+		# make sure that MacPerl is a front process
+		#ActivateApplication('McPL');
+		MacPerl::Answer("Please locate the CodeWarrior application.", "OK");
+		
+		# prompt user for the file name, and store it
+		my $macFile = StandardGetFile( 0, "APPL");
+		if ( $macFile->sfGood() )
+		{
+			$appath = $macFile->sfFile();
+		}
+		else
+		{
+			die "Operation canceled\n";
+		}
+	
+#		if (eval {require Mac::Navigation}) {
+#			my($options, $nav);
+#			Mac::Navigation->import();
+#			$options = NavGetDefaultDialogOptions();
+#			$options->message('Where is CodeWarrior IDE?');
+#			$options->windowTitle('Find CodeWarrior IDE');
+#			$nav = NavChooseObject($Application{$app}, $options);
+#			die "CodeWarrior IDE not found.\n" if (!$nav || !$nav->file(1));
+#			$appath = $nav->file(1);
+#		} else {
+#			local(*D);
+#			my $cwd = `pwd`;
+#			$appath = _get_folder(
+#                               'Where is the CW IDE folder?',
+#				dirname($Application{$app})
+#			);
+#			die "CodeWarrior IDE not found.\n" if !$appath;
+#			opendir(D, $appath) or die $!;
+#			chdir($appath);
+#			foreach my $file (sort readdir (D)) {
+#				my(@app) = MacPerl::GetFileInfo($file);
+#				if ($app[0] && $app[1] &&
+#					$app[1] eq 'APPL' && $app[0] eq $app
+#				) {
+#					$appath .= $file;
+#					last;
+#				}
+#			}
+#			chomp($cwd);
+#			chdir($cwd);
+#		}
+		_save_appath($filepath, $appath);
+	}
+
+	my($lp) = LaunchParam->new(
+		launchAppSpec => $appath,
+		launchControlFlags => launchContinue() + launchNoFileFlags()
+	);
+	
+	unless (LaunchApplication($lp)) {
+		unlink($filepath);
+		die $^E;
+	}
+	
+	# wait for CodeWarrior to show up in the list of processes
+	while (!_appIsRunning('CWIE'))
+	{
+		WaitNextEvent();
+	}
+
+	# wait for CodeWarrior to come to the front
+	while (!_appIsFrontmost('CWIE'))
+	{
+		WaitNextEvent();
+	}
+}
+
+=pod
+
+=item getCodeWarriorPath()
+
+Returns a file path relative to the CodeWarrior folder
+
+=cut
+
+sub getCodeWarriorPath($)
+{
+    my($subfolder)=@_;
+    
+    my($app_path) = _read_appath($ide_loc_file);
+    if ($app_path eq "") { die "Error: Failed to get CodeWarrior IDE path\n"; }
+    
+    my($codewarrior_root) = $app_path;
+    $codewarrior_root =~ s/[^:]*$//;
+    return ($codewarrior_root . $subfolder);
+}
+
+
+=pod
+
+=item getCodeWarriorIDEName()
+
+Returns the name of the CodeWarrior application
+
+=cut
+
+sub getCodeWarriorIDEName()
+{
+    my($subfolder)=@_;
+
+    my($app_path) = _read_appath($ide_loc_file);
+    if ($app_path eq "") { die "Error: Failed to get CodeWarrior IDE path\n"; }
+
+    my(@codewarrior_path) = split(/:/, $app_path);
+    return pop(@codewarrior_path);
+}
+
+
+=pod
+
+=item quit()
+
+Quits CodeWarrior.
+
+=cut
+
+sub quit() {
+
+	$last_project_built = "";
+	$last_project_was_closed = 0;
+
+	my($evt) = do_event(qw/aevt quit/, $app);
+}
+
+
+sub _build ($;$) {
+	my($evt);
+	if ($_[1]) {
+		my($prm) =
+			q"'----':obj {form:name, want:type(TRGT), seld:TEXT(@), from:" .
+			AEPrint($_[0]) . '}';
+		$evt = do_event(qw/CWIE MAKE/, $app, $prm, $_[1]);
+	} else {
+		my($prm) = q"'----':" . AEPrint($_[0]);
+		$evt = do_event(qw/CWIE MAKE/, $app, $prm);
+	}
+}
+
+sub _remove_object ($;$) {
+	my($evt);
+	if ($_[1]) {
+		my($prm) =
+			q"'----':obj {form:name, want:type(TRGT), seld:TEXT(@), from:" .
+			AEPrint($_[0]) . '}';
+		$evt = do_event(qw/CWIE RMOB/, $app, $prm, $_[1]);
+	} else {
+		my($prm) = q"'----':" . AEPrint($_[0]);
+		$evt = do_event(qw/CWIE RMOB/, $app, $prm);
+	}
+}
+
+sub _open_file ($) {
+	my($prm) =
+		q"'----':obj {form:name, want:type(alis), " .
+		q"seld:TEXT(@), from:'null'()}";
+
+	do_event(qw/aevt odoc/, $app, $prm, $_[0]);
+}
+
+sub import_project ($$) {
+	my($xml_file, $project_path) = @_;
+	
+	my($prm) = "kocl:type(PRJD), rtyp:TEXT(@), data:TEXT(@), &subj:'null'()";
+	
+	my($evt) = do_event(qw/core crel/, $app, $prm, $project_path, $xml_file);    
+	my($result) = _get_event_result($evt);
+	
+	if ($result eq "") {
+		_close(_get_project($project_path));
+	}
+	return $result;
+}
+
+sub export_project ($$) {
+	my($project_path, $xml_out_path) = @_;
+	my($p, $project_was_closed);
+	
+	$project_was_closed = 0;
+	while (1) {
+		$p = _get_project($project_path);
+		if (!$p) {
+			if ($project_was_closed) {
+				print "### Error - request for project document failed after opening\n";
+				die "### possibly CW bug: be sure to close your Find window\n";
+}
+			$project_was_closed = 1;
+			_open_file($project_path);
+		} else {
+			last;
+		}
+	}
+
+    # avoid problems with the Project Messages window
+    _close_named_window("Project Messages");
+    
+	my($prm) =
+		q"'----':obj {form:indx, want:type(PRJD), " .
+		q"seld:1, from:'null'()}, kfil:TEXT(@)";
+
+	my($evt) = do_event(qw/CWIE EXPT/, $app, $prm, $xml_out_path);    
+	
+	if ($project_was_closed) {
+		$p = _get_project($project_path);
+		_close($p);
+	}
+	
+	return _get_event_result($evt);
+}
+
+sub _doc_named ($) {
+	my($prm) =
+		q"'----':obj {form:test, want:type(docu), from:'null'(), " .
+		q"seld:cmpd{relo:'=   ', 'obj1':obj {form:prop, want:type" .
+		q"(prop), seld:type(pnam), from:'exmn'()}, 'obj2':TEXT(@)}}";
+
+	my($evt) = do_event(qw/core getd/, $app, $prm, $_[0]);
+	return($evt->{REPLY} eq 'aevt\ansr{}' ? undef : $evt);
+}
+
+sub _full_path ($) {
+	my($obj) = $_[0];
+	my($prm) =
+		q"'----':obj {form:prop, want:type(prop), seld:type(FILE), " .
+		q"from:" . AEPrint($_[0]) . q"}, rtyp:type(TEXT)";
+	my($evt) = do_event(qw/core getd/, $app, $prm);
+
+	return MacPerl::MakePath(
+		MacUnpack('fss ', (
+			AEGetParamDesc($evt->{REP}, keyDirectObject()))->data()->get()
+		)
+	);
+}
+
+sub _save_errors_window ($) {
+	my($prm) = 
+		q"'----':obj {form:name, want:type(alis), seld:TEXT(@), from:'null'()}";
+	do_event(qw/MMPR SvMs/, $app, $prm, $_[0]);
+}
+
+
+sub _close_errors_window () {
+    return _close_named_window('Errors & Warnings');
+}
+
+
+sub _close_named_window ($) {
+    my($window_name) = @_;
+    
+	my($prm) =
+		q"'----':obj {form:name, want:type(cwin), " .
+		q"seld:TEXT(@), from:'null'()}";
+
+	my($evt) = do_event(qw/core clos/, $app, $prm, $window_name);
+	return($evt->{REPLY} eq 'aevt\ansr{}' ? 1 : 0);
+}
+
+sub _close () {
+	my($prm) = q"'----':" . AEPrint($_[0]);
+	do_event(qw/core clos/, $app, $prm);
+}
+
+sub _get_dobj ($) {
+	return(AEGetParamDesc($_[0]->{REP}, keyDirectObject()));
+}
+
+sub _get_folder ($$) {
+    require 'GUSI.ph';
+    my($prompt, $default) = @_;
+    MacPerl::Choose(
+        GUSI::AF_FILE(), 0, $prompt, '',
+        GUSI::CHOOSE_DIR() + ($default ? &GUSI::CHOOSE_DEFAULT : 0),
+        $default
+    );
+}
+
+sub _get_event_result ($)
+{
+    my($evt) = @_;
+
+    my($result) = $evt->{ERROR};
+    
+    if ( $result eq "" && $evt->{ERRNO} != 0 )
+    {
+        $result = "unknown error (".$evt->{ERRNO}.")";
+    }
+    
+    return $result;
+}
+
+
+sub _save_appath ($$) {
+
+	my($cwd) = cwd();	# remember the current working dir
+	chdir($scriptDir);	# change dir to the script dir
+
+	local(*F);
+	open(F, '>' . $_[0]) or die $!;
+	print F $_[1];
+	close(F);
+		
+	chdir($cwd);		# restore the cwd
+}
+
+sub _read_appath ($) {
+
+	my($filepath) = @_;
+
+	my($cwd) = cwd();	# remember the current working dir
+	chdir($scriptDir);	# change dir to the script dir
+	
+	if (! -e $filepath) {
+		return "";
+	}
+
+	local(*F);
+	open(F, $filepath);
+	my($appath) = <F>;
+	close(F);
+		
+	chdir($cwd);		# restore the cwd
+	return($appath);
+}
+
+
+sub _test ($) {
+	activate($ide_loc_file);
+	my($path) = $_[0];
+	build_project(
+	  "${path}modules:xml:macbuild:XML.mcp", '',
+	  "${path}build:mac:Mozilla.BuildLog.part"
+	);
+}
+
+1;
+
+=pod
+
+=back
+
+=head1 HISTORY
+
+=over 4
+
+=item v1.02, September 23, 1998
+
+Made fixes in finding and saving location of CodeWarrior IDE.
+
+=item v1.01, June 1, 1998
+
+Made fixes to C<chdir()> in C<activate()>, made C<activate()> more robust 
+in finding CodeWarrior IDE, added global variable to NOT switch to IDE
+for each sent event, a few other fixes.
+
+=item v1.00, May 30, 1998
+
+First shot
+
+=back
+
+
+=head1 AUTHORS
+
+Chris Nandor F<E<lt>pudge@pobox.comE<gt>>, and the author of the
+original I<CodeWarriorLib>, Scott Collins F<E<lt>scc@netscape.comE<gt>>.
+
+=head1 SEE ALSO
+
+BuildProject L<Moz>.
+
+=head1 COPYRIGHT
+
+The contents of this file are subject to the Netscape Public
+License Version 1.1 (the "License"); you may not use this file
+except in compliance with the License. You may obtain a copy of
+the License at http://www.mozilla.org/NPL/
+
+Software distributed under the License is distributed on an "AS
+IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+implied. See the License for the specific language governing
+rights and limitations under the License.
+
+The Original Code is Mozilla Communicator client code, released
+March 31, 1998.
+
+The Initial Developer of the Original Code is Netscape
+Communications Corporation. Portions created by Netscape are
+Copyright (C) 1998-1999 Netscape Communications Corporation. All
+Rights Reserved.
+
+Contributor(s): 
+
+=cut

mozilla/build/mac/build_scripts/Moz/Jar.pm

@@ -0,0 +1,573 @@
+#!perl -w
+package Moz::Jar;
+
+#
+# Module for creating jar files, either using a jar manifest, or
+# simply jarring up folders on disk.
+#
+
+require 5.004;
+require Exporter;
+
+use strict;
+use Archive::Zip;
+use File::Path;
+
+use Mac::Files;
+
+use Moz::Moz;
+
+use vars qw( @ISA @EXPORT );
+
+@ISA        = qw(Exporter);
+@EXPORT     = qw(
+                    CreateJarFileFromDirectory
+                    CreateJarFromManifest
+                    WriteOutJarFiles
+                    SanityCheckJarOptions
+                );
+
+
+#-------------------------------------------------------------------------------
+# Add the contents of a directory to the zip file
+#
+#-------------------------------------------------------------------------------
+sub _addDirToJar($$$$)
+{
+    my($dir, $jar_root, $zip, $compress) = @_;
+
+    opendir(DIR, $dir) or die "Error: Cannot open dir $dir\n";
+    my @files = readdir(DIR);
+    closedir DIR;
+    
+    my $unix_jar_root = $jar_root;
+    $unix_jar_root =~ s|:|/|g;       # colon to slash conversion
+    
+    my $file;
+    
+    foreach $file (@files)
+    {        
+        my $filepath = $dir.":".$file;
+        
+        if (-d $filepath)
+        {
+            print "Adding files to jar from $filepath\n";            
+            _addDirToJar($filepath, $jar_root, $zip, $compress);
+        }
+        else
+        {
+            my $member = Archive::Zip::Member->newFromFile($filepath);
+            die "Error: Failed to create zip file member $filepath\n" unless $member;
+            
+            my $unixName = $filepath;
+            $unixName =~ s|:|/|g;               # colon to slash conversion
+            $unixName =~ s|^$unix_jar_root||;   # relativise
+            
+            $member->fileName($unixName);
+            
+            # print "Adding $file as $unixName\n";
+            
+            if ($compress) {
+                $member->desiredCompressionMethod(Archive::Zip::COMPRESSION_DEFLATED);            
+            } else {
+                $member->desiredCompressionMethod(Archive::Zip::COMPRESSION_STORED);
+            }
+            
+            $zip->addMember($member);
+        }
+    }
+}
+
+#-------------------------------------------------------------------------------
+# Add the contents of a directory to the zip file
+#
+#-------------------------------------------------------------------------------
+
+sub CreateJarFileFromDirectory($$$)
+{
+    my($srcdir, $jarpath, $compress) = @_;
+
+    my $zip = Archive::Zip->new();
+
+    _addDirToJar($srcdir, $srcdir, $zip, $compress);
+
+    print "Saving zip file...\n";
+    my $status = $zip->writeToFileNamed($jarpath);
+    if ($status == 0) {
+        print "Zipping completed successfully\n";
+    } else {
+        print "Error saving zip file\n";
+    }
+    
+    # set the file type/creator to something reasonable
+    MacPerl::SetFileInfo("ZIP ", "ZIP ", $jarpath);
+}
+
+
+#-------------------------------------------------------------------------------
+# printZipContents
+# 
+#-------------------------------------------------------------------------------
+sub printZipContents($)
+{
+    my($zip) = @_;
+
+    my(@members) = $zip->memberNames();
+    
+    print "Zip contains:\n";
+    
+    my($member);
+    foreach $member (@members)
+    {
+        print "  $member\n";
+    }
+}
+
+
+#-------------------------------------------------------------------------------
+# safeSaveJarFile
+# 
+# Archive::Zip has a problem where you cannot save a zip file on top of
+# an existing zip file that it has open, because it holds references
+# into that zip. So we have to save to a temp file, then do a swap.
+# 
+# Note that the zip will become invalid after this operation.
+# If you want to do further operations on it, you'll have to reread it.
+#-------------------------------------------------------------------------------
+sub safeSaveJarFile($$)
+{
+    my($zip, $full_dest_path) = @_;
+    
+    my($temp_file_name) = $full_dest_path."_temp";
+
+    ($zip->writeToFileNamed($temp_file_name) == Archive::Zip::AZ_OK) || die "Error: died writing jar to temp file $temp_file_name\n";
+    
+    unlink $full_dest_path;
+    
+    (rename $temp_file_name, $full_dest_path) || die "Error: Failed to rename $temp_file_name\n";
+    
+    MacPerl::SetFileInfo("ZIP ", "ZIP ", $full_dest_path);
+}
+
+
+#-------------------------------------------------------------------------------
+# addToJarFile
+# 
+# Add a file to a jar file
+#
+# Parameters:
+#   1. Jar ID. Unix path of jar file inside chrome.
+#   2. Abs path to jar.mn file (i.e. source)    (mac breaks)
+#   3. File source, relative to jar.mn path     (mac breaks)
+#   4. Abs path to the resulting .jar file      (mac breaks)
+#   5. Relative file path within the jar        (unix breaks)
+#   6. Reference to hash of jar files
+#
+#-------------------------------------------------------------------------------
+
+sub addToJarFile($$$$$$$)
+{
+    my($jar_id, $jar_man_dir, $file_src, $jar_path, $file_jar_path, $override, $jars) = @_;
+
+    # print "addToJarFile with:\n  $jar_man_dir\n  $file_src\n  $jar_path\n  $file_jar_path\n";
+
+    unless ($jar_path =~ m/(.+:)([^:]+)$/) { die "Error: Bad jar path $jar_path\n"; }
+    
+    my($target_dir) = $1;
+    my($jar_name) = $2;
+
+    $target_dir =~ s/[^:]+$//;
+    
+    # print "¥ $target_dir $jar_name\n";
+
+    # find the source file
+    my($src) = $jar_man_dir.":".$file_src;
+    if ((!-e $src) && ($file_src =~ m/.+:([^:]+)$/))    # src does not exist. Fall back to looking for src in jar.mn dir
+    {
+        $file_src = $1;
+        $src = $jar_man_dir.":".$file_src;
+        
+        if (!-e $src) {
+            die "Error: Can't find chrome file $src\n";
+        }
+    }
+    
+    if ($main::options{chrome_jars})
+    {
+        my($zip) = $jars->{$jar_id};
+        unless ($zip) { die "Error: Can't find Zip entry for $jar_id\n"; }
+        
+        # print "Adding $file_src to jar file $jar_path at $file_jar_path\n";
+        my($member) = Archive::Zip::Member->newFromFile($src);
+        unless ($member) { die "Error: Failed to create zip file member $src\n"; }
+
+        $member->fileName($file_jar_path);    
+    
+        my($compress) = 1;
+        if ($compress) {
+            $member->desiredCompressionMethod(Archive::Zip::COMPRESSION_DEFLATED);            
+            $member->desiredCompressionLevel(Archive::Zip::COMPRESSION_LEVEL_DEFAULT);   # defaults to 6
+        } else {
+            $member->desiredCompressionMethod(Archive::Zip::COMPRESSION_STORED);
+        }
+
+        my($old_member) = $zip->memberNamed($file_jar_path);
+        
+        if ($override)
+        {
+            if ($old_member)
+            {
+                # print "Overriding $file_jar_path in jar file $jar_id\n";
+                # need to compare mod dates or use the + here
+                $zip->removeMember($old_member);
+            }
+        
+            $zip->addMember($member);
+        }
+        else
+        {
+            if ($old_member)
+            {
+                #compare dates here
+                my($member_moddate) = $old_member->lastModTime();
+                my($file_moddate) = GetFileModDate($src);
+            
+                if ($file_moddate > $member_moddate)
+                {
+                    print "Updating older file $file_jar_path in $jar_id\n";
+                    $zip->removeMember($old_member);
+                    $zip->addMember($member);
+                }
+                else
+                {
+                    print "File $file_jar_path in $jar_id is more recent. Not updating.\n";
+                }
+            }
+            else
+            {
+                $zip->addMember($member);
+            }
+        }
+    }
+    
+    if ($main::options{chrome_files})  # we install raw files too
+    {
+        my($rel_path) = $file_jar_path;
+        $rel_path =~ s|/|:|g;       # slash to colons
+        
+        my($dir_name) = $jar_name;
+        $dir_name =~ s/\.jar$//;
+        
+        my($dst) = $target_dir.$dir_name.":".$rel_path;
+                
+        # print "Aliassing $src\n to\n$dst\n";        
+        if ($override)
+        {
+            unlink $dst;
+        MakeAlias($src, $dst);      # don't check errors, otherwise we fail on replacement
+    }
+        else
+        {
+            if (-e $dst)
+            {
+                #compare dates here
+                my($dst_moddate) = GetFileModDate($dst);
+                my($file_moddate) = GetFileModDate($src);
+            
+                if ($file_moddate > $dst_moddate)
+                {
+                    print "Updating older file $rel_path in $dir_name\n";
+                    unlink $dst;
+                    MakeAlias($src, $dst);
+                }
+                else
+                {
+                    print "File $file_jar_path in $jar_id is more recent. Not updating.\n";
+                }
+            
+            }
+            else
+            {
+                MakeAlias($src, $dst);
+            }
+        }
+        
+    }
+}
+
+
+#-------------------------------------------------------------------------------
+# setupJarFile
+# 
+# setup a zip for writing
+#-------------------------------------------------------------------------------
+
+sub setupJarFile($$$)
+{
+    my($jar_id, $dest_path, $jar_hash) = @_;
+
+    # print "Creating jar file $jar_id at $jar_path\n";
+    
+    my($jar_file) = $jar_id;
+    $jar_file =~ s|/|:|g;           # slash to colons
+    my($full_jar_path) = full_path_to($dest_path.":".$jar_file);
+
+    if ($main::options{chrome_jars})
+    {
+        my($zip) = $jar_hash->{$jar_id};
+        if (!$zip)      # if we haven't made it already, do so
+        {
+	        my($zip) = Archive::Zip->new();
+	        $jar_hash->{$jar_id} = $zip;
+
+            # does the jar file exist already? If so, read it in
+            if (-e $full_jar_path)
+            {
+                print "Reading in jar file $jar_id\n";
+                if ($zip->read($full_jar_path) != Archive::Zip::AZ_OK) { die "Error: Failed to re-read $full_jar_path\n"; }
+                
+                # printZipContents($zip);
+            }
+
+        }
+    }
+    else
+    {
+        # installing files.
+        # nothing to do. MakeAlias creates dirs as needed.
+
+	    # add this jar to the list
+	    $jar_hash->{$jar_id} = 1;
+    }
+}
+
+
+#-------------------------------------------------------------------------------
+# closeJarFile
+# 
+# We're done with this jar file _for this jar.mn_. We may add more entries
+# to it later, so keep it open in the hash.
+#-------------------------------------------------------------------------------
+sub closeJarFile($$)
+{
+    my($jar_path, $jar_hash) = @_;
+
+    # print "Closing jar file $jar_path\n";
+
+    if ($main::options{chrome_jars})
+    {
+    
+    }
+    else
+    {
+        # installing files.
+        # nothing to do
+    }
+}
+
+
+#-------------------------------------------------------------------------------
+# WriteOutJarFiles
+# 
+# Now we dump out the jars
+#-------------------------------------------------------------------------------
+sub WriteOutJarFiles($$)
+{
+    my($chrome_dir, $jars) = @_;
+
+    unless ($main::options{chrome_jars}) { return; }
+    
+    my($full_chrome_path) = full_path_to($chrome_dir);
+
+    my($key);
+    foreach $key (keys %$jars)
+    {
+        my($zip) = $jars->{$key};
+        
+        my($rel_path) = $key;
+        $rel_path =~ s/\//:/g;
+        
+        my($output_path) = $full_chrome_path.":".$rel_path;
+        
+        print "Writing zip file $key to $output_path\n";
+
+        # ensure the target dirs exist
+        my($path) = $output_path;
+        $path =~ s/[^:]+$//;
+        mkpath($path);
+        
+        # unlink $output_path;        # remove any existing jar
+        safeSaveJarFile($zip, $output_path);
+        # $zip is invalid after this operation, so nuke it here
+        $jars->{$key} = 0;
+    }
+}
+
+
+#-------------------------------------------------------------------------------
+# registerChromePackage
+# 
+# Enter a chrome package into the installed-chrome.txt file
+#-------------------------------------------------------------------------------
+sub registerChromePackage($$$$$$)
+{
+    my($jar_file, $file_path, $chrome_dir, $jar_hash, $chrome_type, $pkg_name) = @_;
+
+    my($manifest_subdir) = $jar_file;
+    $manifest_subdir =~ s/:/\//g;
+    
+    my($chrome_entry);
+    
+    if ($main::options{use_jars}) {
+        $chrome_entry = "$chrome_type,install,url,jar:resource:/chrome/$manifest_subdir!/$chrome_type/$pkg_name";
+    } else {
+        $manifest_subdir =~ s/\.jar$//;
+        $chrome_entry = "$chrome_type,install,url,resource:/chrome/$manifest_subdir/$chrome_type/$pkg_name";
+    }
+
+    # print "Entering $chrome_entry in installed-chrome.txt\n";
+    
+    # ensure chrome_dir exists
+    mkpath($chrome_dir);
+    
+    my($inst_chrome) = ${chrome_dir}.":installed-chrome.txt";
+    
+    if (open(CHROMEFILE, "<$inst_chrome")) {
+        while (<CHROMEFILE>) {
+            chomp;
+            if ($_ eq $chrome_entry) {
+                # $chrome_entry already appears in installed-chrome.txt file
+                # just update the mod date
+                my $now = time;
+                utime($now, $now, $inst_chrome) || die "Error: Couldn't touch $inst_chrome";
+                print "+++ updating chrome $inst_chrome\n+++\t\t$chrome_entry\n";
+                close(CHROMEFILE) || die "Error: can't close $inst_chrome: $!";
+                return 0;
+            }
+        }
+        close(CHROMEFILE) || die "Error: can't close $inst_chrome: $!";
+    }
+    open(CHROMEFILE, ">>${inst_chrome}") || die "Error: Failed to open $inst_chrome\n";
+    print(CHROMEFILE "${chrome_entry}\n");
+    close(CHROMEFILE) || die "Error: Failed to close $inst_chrome\n";
+    print "+++ adding chrome $inst_chrome\n+++\t\t$chrome_entry\n";
+}
+
+#-------------------------------------------------------------------------------
+# Create or add to a jar file from a jar.mn file.
+# Both arguments are relative to the mozilla root dir.
+#
+#
+#-------------------------------------------------------------------------------
+sub CreateJarFromManifest($$$)
+{
+    my($jar_man_path, $dest_path, $jars) = @_;
+    
+    if ($main::options{chrome_jars}) {
+        print "Jarring from $jar_man_path\n";
+    }
+    if ($main::options{chrome_files}) {
+        print "Installing files from $jar_man_path\n";
+    }
+
+    $jar_man_path = full_path_to($jar_man_path);
+    $dest_path = full_path_to($dest_path);
+
+    # if the jars hash is empty, nuke installed-chrome.txt
+    if (! scalar(%$jars))
+    {
+        print "Nuking installed-chrome.txt\n";
+	    my($installed_chrome) = $dest_path.":installed-chrome.txt";
+	    # unlink $installed_chrome;
+    }
+    
+    my $jar_man_dir = "";
+    my $jar_man_file = "";
+    
+    if ($jar_man_path =~ /(.+):([^:]+)$/)
+    {
+        $jar_man_dir = $1;      # no trailing :
+        $jar_man_file = $2;
+    }
+
+    # Keep a hash of jar files, keyed on relative jar path (e.g. "packages/core.jar")
+    # Entries are open Archive::Zips (if zipping), and installed-chrome entries.
+    
+    my($jar_id) = "";       # Current foo/bar.jar from jar.mn file
+    my($jar_file) = "";     # relative path to jar file (from $dest_path), with mac separators
+    my($full_jar_path);
+    
+    open(FILE, "<$jar_man_path") || die "Error: could not open \"$jar_man_path\": $!";
+    while (<FILE>)
+    {
+        my($line) = $_;
+        chomp($line);
+        
+        # print "$line\n";
+        
+        if ($line =~ /^\s*\#.*$/) {     # skip comments
+            next;
+        }
+        
+        if ($line =~/^([\w\d.\-\_\\\/]+)\:\s*$/)                                  # line start jar file entries
+        {
+            $jar_id = $1;
+            $jar_file = $jar_id;
+            $jar_file =~ s|/|:|g;           # slash to colons
+            $full_jar_path = $dest_path.":".$jar_file;
+                        
+            setupJarFile($jar_id, $dest_path, $jars);
+
+        }
+        elsif ($line =~ /^(\+?)\s+([\w\d.\-\_\\\/]+)\s*(\([\w\d.\-\_\\\/]+\))?$\s*/)     # jar file entry
+        {
+            my($override) = ($1 eq "+");
+            my($file_dest) = $2;
+            my($file_src) = $3;
+ 
+            if ($file_src) {  
+                $file_src = substr($file_src, 1, -1);      #strip the ()
+            } else {
+                $file_src = $file_dest;
+            }
+            
+            $file_src =~ s|/|:|g;
+            
+            if ($jar_file ne "")    # if jar is open, add to jar
+            {
+                if ($file_dest =~ /([\w\d.\-\_]+)\/([\w\d.\-\_\\\/]+)contents.rdf/)
+                {
+                    my $chrome_type = $1;
+                    my $pkg_name = $2;
+                    registerChromePackage($jar_file, $file_dest, $dest_path, $jars, $chrome_type, $pkg_name);
+                }
+                
+                addToJarFile($jar_id, $jar_man_dir, $file_src, $full_jar_path, $file_dest, $override, $jars);
+            }
+            else
+            {
+                die "Error: bad jar.mn format at $line\n";
+            }
+        }
+        elsif ($line =~ /^\s*$/ )                                               # blank line
+        {
+            if ($jar_file ne "")    #if a jar file is open, close it
+            {
+                closeJarFile($full_jar_path, $jars);
+                
+                $jar_file = "";
+                $full_jar_path = "";
+            }
+        }
+    }
+    
+    close(FILE);
+
+    if ($jar_file ne "")    #if a jar file is open, close it
+    {
+        closeJarFile($full_jar_path, $jars);
+    }
+
+}
+
+1;

mozilla/build/mac/build_scripts/Moz/MacCVS.pm

@@ -0,0 +1,228 @@
+#!perl -w
+package Moz::MacCVS;
+
+# package Mac::Apps::MacCVS; this should really be the name of the package
+# but due to our directory hierarchy in mozilla, I am not doing it
+
+require 5.004;
+require Exporter;
+
+use strict;
+use Exporter;
+
+use vars qw($VERSION @ISA @EXPORT);
+
+use Cwd;
+
+use File::Basename;
+
+use Mac::StandardFile;
+use Mac::AppleEvents;
+use Mac::AppleEvents::Simple;
+
+@ISA        = qw(Exporter);
+@EXPORT     = qw(new describe checkout update);
+$VERSION = "1.00";
+
+# If you want to understand the gobbldeygook that's used to build Apple Events,
+# you should start by reading the AEGizmos documentation.
+
+
+# Architecture:
+# cvs session object:
+# name - session name
+# session_file - session file
+# 
+# 
+
+my($last_error) = 0;
+my($gAppSig)    = 'Mcvs';   # MacCVS Pro
+
+#
+# utility routines
+#
+
+
+sub _checkForEventError($)
+{
+  my($evt) = @_;
+
+  if ($evt->{ERRNO} != 0)
+  {
+    print STDERR "Error. Script returned '$evt->{ERROR} (error $evt->{ERRNO})\n";
+    $last_error = $evt->{ERRNO};
+    return 0;
+  }
+  
+  return 1; # success
+}
+
+
+#
+# Session object methods
+#
+
+sub new
+{
+  my ( $proto, $session_file) = @_;
+  my $class = ref($proto) || $proto;
+  my $self = {};
+
+  if ( defined($session_file) && ( -e $session_file) )
+  {
+    $self->{"name"} = basename( $session_file );
+    $self->{"session_file"} = $session_file;
+    bless $self, $class;
+    return $self;
+  }
+  else
+  {
+    print STDERR "MacCVS->new cvs file < $session_file > does not exist\n";
+    return;
+  }
+}
+
+# makes sure that the session is open
+# assertSessionOpen()
+# returns 1 on success
+sub assertSessionOpen()
+{
+  my ($self) = shift;
+
+  $last_error = 0;
+
+  my($prm) =
+    q"'----':obj {form:name, want:type(alis), seld:TEXT(@), from:'null'()}";
+
+  my($evt) = do_event(qw/aevt odoc/, $gAppSig, $prm, $self->{session_file});
+  return _checkForEventError($evt);
+}
+
+# prints the cvs object, used mostly for debugging
+sub describe
+{
+  my($self) = shift;
+  $last_error = 0;
+  print "MacCVS:: name: ", $self->{name}, " session file: ", $self->{session_file}, "\n";
+}
+
+# checkout( self, module, revision, date)
+# MacCVS checkout command
+# returns 1 on success.
+sub checkout()
+{
+  my($self, $module, $revision, $date ) = @_;
+  unless( defined ($module) ) { $module = ""; } # get rid of the pesky undefined warnings
+  unless( defined ($revision) ) { $revision = ""; }
+  unless( defined ($date) ) { $date = ""; }
+
+  $last_error = 0;
+    
+  $self->assertSessionOpen() || die "Error: failed to open MacCVS session file at $self->{session_file}\n";
+  
+  my($revstring) = ($revision ne "") ? $revision : "(none)";
+  my($datestring) = ($date ne "") ? $date : "(none)";
+  
+  print "Checking out $module with revision $revstring, date $datestring\n";
+
+  my($prm) =
+    q"'----':obj {form:name, want:type(docu), seld:TEXT(@), from:'null'()}, ".
+    q"modl:'TEXT'(@), tagr:'TEXT'(@), tagd:'TEXT'(@) ";
+  
+  my($evt) = do_event(qw/MCvs cout/, $gAppSig, $prm, $self->{name}, $module, $revision, $date);
+  return _checkForEventError($evt);
+}
+
+
+# update( self, branch tag, list of paths)
+# MacCVS udate command
+# returns 1 on success.
+# NOTE: MacCVS Pro does not correctly support this stuff yet (as of version 2.7d5).
+sub update()
+{
+  my($self, $branch, $paths ) = @_;
+
+  $last_error = 0;
+    
+  $self->assertSessionOpen() || die "Error: failed to open MacCVS session file at $self->{session_file}\n";
+
+  if ($branch eq "HEAD") {
+    $branch = "";
+  }
+  
+  my($paths_list) = "";
+  
+  my($path);
+  foreach $path (@$paths)
+  {
+    if ($paths_list ne "") {
+      $paths_list = $paths_list.", ";
+    }
+    
+    $paths_list = $paths_list."Ò".$path."Ó";
+  }
+    
+  my($prm) =
+    q"'----':obj {form:name, want:type(docu), seld:TEXT(@), from:'null'()}, ".
+    q"tagr:'TEXT'(@), tFls:[";
+
+  $prm = $prm.$paths_list."]";
+    
+  my($evt) = do_event(qw/MCvs updt/, $gAppSig, $prm, $self->{name}, $branch);
+  return _checkForEventError($evt);
+};
+
+
+sub getLastError()
+{
+  return $last_error;
+}
+
+1;
+=pod
+
+=head1 NAME
+
+MacCVS - Interface to MacCVS
+
+=head1 SYNOPSIS
+
+  use MacCVS;
+  $session = MacCVS->new( <session_file_path>) || die "cannot create session";
+  $session->checkout([module] [revision] [date]) || die "Could not check out";
+    
+=head1 DESCRIPTION
+
+This is a MacCVS interface for talking to MacCVS Pro client.
+MacCVSSession is the class used to manipulate the session
+
+=item new
+  MacCVS->new( <cvs session file path>);
+  
+  Creates a new session. Returns undef on failure.
+
+=item checkout( <module> [revision] [date] )
+
+  cvs checkout command. Revision and date are optional
+  returns 0 on failure
+  
+=cut
+
+=head1 SEE ALSO
+
+=over
+
+=item MacCVS Home Page
+
+http://www.maccvs.org/
+
+=back 
+
+=head1 AUTHORS
+
+Aleks Totic atotic@netscape.com
+Simon Fraser sfraser@netscape.com
+
+=cut
+
+__END__

mozilla/build/mac/build_scripts/Moz/Moz.pm

@@ -0,0 +1,603 @@
+=head1 NAME
+
+B<Moz> - routines for automating CodeWarrior builds, and some extra-curricular
+activities related to building Mozilla
+
+=head1 SYNOPSIS
+
+    use Moz;
+
+    OpenErrorLog(":::BuildLog");
+    StopForErrors();
+
+		$Moz::QUIET = 1;
+		InstallFromManifest(":projects:MANIFEST", $dist_dir);
+
+    BuildProjectClean(":projects:SomeProject.mcp", "SomeTarget");
+    MakeAlias(":projects:SomeProject.shlb", $dist_dir);
+
+    DontStopForErrors();
+
+    BuildProject(":projects:SomeOtherProject.mcp", "SomeTarget");
+
+=head1 DESCRIPTION
+
+B<Moz> comprises the routines needed to slap CodeWarrior around, force it
+to build a sequence of projects, report the results, and a few other things.
+This module should only contain functions that are generic to any build,
+not just the Mozilla build.
+
+=cut
+
+
+package			Moz::Moz;
+require			Exporter;
+
+use Cwd;
+
+use File::Copy;
+use File::Path;
+use File::Basename;
+
+use Mac::Types;
+use Mac::Events;
+use Mac::Processes;
+
+use ExtUtils::Manifest 'maniread';
+
+use Moz::CodeWarriorLib;
+
+@ISA				= qw(Exporter);
+
+@EXPORT			= qw( LaunchCodeWarrior
+                  GetCodeWarriorRelativePath
+                  current_directory
+                  full_path_to
+                  DoBuildProject
+                  ImportXMLProject
+                  ExportProjectToXML
+                  OpenErrorLog
+                  MakeAlias
+                  GetFileModDate
+                  StopForErrors
+                  DontStopForErrors
+                  InstallFromManifest
+                  InstallResources
+                  RedirectOutputToFile
+                  Delay
+                  ActivateApplication
+                  IsProcessRunning);
+
+@EXPORT_OK	= qw(CloseErrorLog QUIET);
+
+
+sub current_directory()
+	{
+		my $current_directory = cwd();
+		chop($current_directory) if ( $current_directory =~ m/:$/ );
+		return $current_directory;
+	}
+
+sub full_path_to($)
+	{
+		my ($path) = @_;
+		if ( $path =~ m/^[^:]+$/ )
+			{
+				$path = ":" . $path;
+			}
+
+		if ( $path =~ m/^:/ )
+			{
+				$path = current_directory() . $path;
+			}
+
+		return $path;
+	}
+
+$logging								= 0;
+$recent_errors_file			= "";
+$stop_on_1st_error			= 1;
+$QUIET									= 0;
+
+
+
+=head2 Logging all the errors and warnings - C<OpenErrorLog($log_file)>, C<CloseErrorLog()>
+
+The warnings and errors generated in the course of building projects can be logged to a file.
+Tinderbox uses this facility to show why a remote build failed.
+
+Logging is off by default.
+  Start logging at any point in your build process with C<OpenErrorLog($log_file)>.
+  Stop with C<CloseErrorLog()>.
+  You never need to close the log explicitly, unless you want to just log a couple of projects in the middle of a big list.
+  C<CloseErrorLog()> is not exported by default. 
+
+=cut
+
+sub CloseErrorLog()
+	{
+		if ( $logging )
+			{
+				close(ERROR_LOG);
+				$logging = 0;
+				StopForErrors() if $stop_on_1st_error;
+			}
+	}
+
+
+
+sub OpenErrorLog($)
+	{
+		my ($log_file) = @_;
+
+		CloseErrorLog();
+		if ( $log_file )
+			{
+				$log_file = full_path_to($log_file);
+ 
+				open(ERROR_LOG, ">$log_file") || die "Error: Can't open $log_file\n";
+				MacPerl::SetFileInfo("CWIE", "TEXT", $log_file);
+
+				$log_file =~ m/.+:(.+)/;
+				$recent_errors_file = full_path_to("$1.part");
+				$logging = 1;
+			}
+	}
+
+
+=head2 Stopping before it's too late - C<StopForErrors()>, C<DontStopForErrors()>
+
+When building a long list of projects, you decide whether to continue building subsequent projects when one fails.
+  By default, your build script will C<die> after the first project that generates an error while building.
+  Change this behavior with C<DontStopForErrors()>.
+  Re-enable it with C<StopForErrors()>.
+
+=cut
+
+sub StopForErrors()
+	{
+		$stop_on_1st_error = 1;
+		
+			# Can't stop for errors unless we notice them.
+			# Can't notice them unless we are logging.
+			# If the user didn't explicitly request logging, log to a temporary file.
+
+		if ( ! $recent_errors_file )
+			{
+				OpenErrorLog("${TMPDIR}BuildResults");
+			}
+	}
+
+sub DontStopForErrors()
+	{
+		$stop_on_1st_error = 0;		
+	}
+
+sub log_message($)
+	{
+		if ( $logging )
+			{
+				my ($message) = @_;
+				print ERROR_LOG $message;
+			}
+	}
+
+sub log_message_with_time($)
+	{
+		if ( $logging )
+			{
+				my ($message) = @_;
+				my $time_stamp = localtime();
+				log_message("$message ($time_stamp)\n");
+			}
+	}
+
+sub log_recent_errors($)
+	{
+		my ($project_name) = @_;
+		my $found_errors = 0;
+	
+		if ( $logging )
+			{
+				open(RECENT_ERRORS, "<$recent_errors_file");
+
+				while( <RECENT_ERRORS> )
+					{
+						if ( /^Error/ || /^CouldnÕt find project file/ || /^Link Error/ )
+							{
+#								if (!$found_errors)
+#									print $_;
+								$found_errors = 1;
+							}
+						print ERROR_LOG $_;
+					}
+
+				close(RECENT_ERRORS);
+				unlink("$recent_errors_file");
+			}
+		
+		if ( $stop_on_1st_error && $found_errors )
+			{
+				print ERROR_LOG "### Build failed.\n";
+				die "### Errors encountered building \"$project_name\".\n";
+			}
+	}
+	
+sub DoBuildProject($$$)
+	{
+		my ($project_path, $target_name, $clean_build) = @_;
+		$project_path = full_path_to($project_path);
+
+#		$project_path =~ m/.+:(.+)/;
+#		my $project_name = $1;
+
+		log_message_with_time("### Building \"$project_path\"");
+
+			# Check that the given project exists
+		if (! -e $project_path)
+			{
+				print ERROR_LOG "### Build failed.\n";
+				die "### Can't find project file \"$project_path\".\n";
+			}
+		
+		print "Building \"$project_path\[$target_name\]\"\n";
+		
+		$had_errors = Moz::CodeWarriorLib::build_project(
+			$project_path, $target_name, $recent_errors_file, $clean_build
+		);
+		WaitNextEvent();
+
+#		$had_errors =
+#MacPerl::DoAppleScript(<<END_OF_APPLESCRIPT);
+#	tell (load script file "$CodeWarriorLib") to BuildProject("$project_path", "$project_name", "$target_name", "$recent_errors_file", $clean_build)
+#END_OF_APPLESCRIPT
+
+			# Append any errors to the globally accumulated log file
+#		if ( $had_errors ) # Removed this test, because we want warnings, too.  -- jrm
+			{
+				log_recent_errors($project_path);
+			}
+	}
+
+
+sub ImportXMLProject($$)
+{
+    my ($xml_path, $project_path) = @_;
+
+#    my ($codewarrior_ide_name) = Moz::CodeWarriorLib::getCodeWarriorIDEName();
+#    my $ascript = <<EOS;
+#      tell application "$codewarrior_ide_name"
+#        make new (project document) as ("$project_path") with data ("$xml_path")
+#      end tell
+#EOS
+#    print $ascript."\n";
+#    my($result) = MacPerl::DoAppleScript($ascript);
+#    unless ($result) { die "Error: ImportXMLProject AppleScript failed $^E $result\n";  }
+#    
+
+    my($import_error) = Moz::CodeWarriorLib::import_project($xml_path, $project_path);
+    if ($import_error ne "") {
+      die "Error: ImportXMLProject failed with error $import_error\n";
+    }
+}
+
+sub ExportProjectToXML($$)
+{
+    my ($project_path, $xml_path) = @_;
+
+    my (@suffix_list) = (".mcp");
+    my ($project_name, $project_dir, $suffix) = fileparse($project_path, @suffix_list);
+    if ($suffix eq "") { die "Project: $project_path doesn't look like a project file.\n"; }
+    
+    if (-e $xml_path) {
+        print "$xml_path exists - not exporting $project_path\n";
+    }
+    else {
+        print "Exporting $project_path to $xml_path\n";
+        my($export_error) = Moz::CodeWarriorLib::export_project($project_path, $xml_path);
+        if ($export_error ne "") {
+            die "Error: export_project failed with error '$export_error'\n";
+        }
+        
+        if (! -e $xml_path) {
+          die "Error: XML export to $xml_path failed\n";
+        }
+    }
+}
+
+
+=head2 Miscellaneous
+
+C<MakeAlias($old_file, $new_file)> functions like C<symlink()>, except with better argument defaulting and more explicit error messages.
+
+=cut
+
+sub MakeAlias($$)
+	{
+		my ($old_file, $new_file) = @_;
+
+			# if the directory to hold $new_file doesn't exist, create it
+		if ( ($new_file =~ m/(.+:)/) && !-d $1 )
+			{
+				mkpath($1);
+			}
+
+			# if a leaf name wasn't specified for $new_file, use the leaf from $old_file
+		if ( ($new_file =~ m/:$/) && ($old_file =~ m/.+:(.+)/) )
+			{
+				$new_file .= $1;
+			}
+
+		my $message = "Can't create a Finder alias (at \"$new_file\")\n for \"$old_file\"; because ";
+
+		die "Error: $message \"$old_file\" doesn't exist.\n" unless -e $old_file;
+		die "Error: $message I won't replace an existing (non-alias) file with an alias.\n" if ( -e $new_file && ! -l $new_file );
+
+			# now: $old_file exists; $new_file doesn't (or else, is an alias already)
+
+		if ( -l $new_file )
+			{
+					# ...then see if it already points to $old_file
+				my $current_target	= full_path_to(readlink($new_file));
+				my $new_target			= full_path_to($old_file);
+
+				return if ( $current_target eq $new_target );
+					# if the desired alias already exists and points to the right thing, then we're done
+				
+				unlink $new_file;
+			}
+		
+		symlink($old_file, $new_file) || die "Error: $message symlink returned an unexpected error.\n";
+	}
+	
+	
+=pod
+
+C<InstallFromManifest()>
+
+=cut
+
+sub InstallFromManifest($;$$)
+	{
+		my ($manifest_file, $dest_dir, $flat) = @_;
+		
+		$flat = 0 unless defined($flat); # if $flat, all rel. paths in MANIFEST get aliased to the root of $dest_dir
+
+		$dest_dir ||= ":";
+
+		$manifest_file =~ m/(.+):/;
+		my $source_dir =  $1;
+
+		chop($dest_dir) if $dest_dir =~ m/:$/;
+
+		#Mac::Events->import();
+		WaitNextEvent();
+		if ($flat)
+		{
+			print "Doing manifest on \"$manifest_file\" FLAT\n" unless $QUIET;
+		}
+		else
+		{
+			print "Doing manifest on \"$manifest_file\"\n" unless $QUIET;
+		}
+		
+		my $read = maniread(full_path_to($manifest_file));
+		foreach $file (keys %$read)
+			{
+				next unless $file;
+
+				$subdir = ":";
+				if (!$flat && ($file =~ /:.+:/ ))
+					{
+						$subdir = $&;
+					}
+
+				$file = ":$file" unless $file =~ m/^:/;
+				MakeAlias("$source_dir$file", "$dest_dir$subdir");
+			}
+	}
+
+
+=pod
+
+C<InstallResources()>
+
+=cut
+
+# parameters are path to MANIFEST file, destination dir, true (to make copies) or false (to make aliases)
+sub InstallResources($;$;$)
+	{
+		my ($manifest_file, $dest_dir, $copy_files) = @_;
+
+		$dest_dir ||= ":";
+		mkpath($dest_dir) if !-d $dest_dir;
+
+		$manifest_file =~ m/(.+):/;
+		my $source_dir =  $1;
+
+		chop($dest_dir) if $dest_dir =~ m/:$/;
+
+		WaitNextEvent();
+		print "Installing resources from \"$manifest_file\"\n" unless $QUIET;
+		
+		my $read = maniread(full_path_to($manifest_file));
+		foreach $file (keys %$read)
+			{
+				next unless $file;
+				
+				if ($copy_files)
+					{
+						copy("$source_dir:$file", "$dest_dir:$file");
+					}
+				else
+					{
+						MakeAlias("$source_dir:$file", "$dest_dir:$file");
+					}
+			}
+	}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// Delay
+#//--------------------------------------------------------------------------------------------------
+sub Delay($)		
+{
+  my ($delay_seconds) = @_;
+
+  $now = time;
+  
+  $exit_time = $now + $delay_seconds;
+
+  while ($exit_time > $now) {
+     $now = time;
+  }
+	
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// GetFileModDate
+#//--------------------------------------------------------------------------------------------------
+sub GetFileModDate($)
+{
+    my($filePath)=@_;
+    my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+        $atime,$mtime,$ctime,$blksize,$blocks) = stat($filePath);
+    return $mtime;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// LaunchCodeWarrior
+#//--------------------------------------------------------------------------------------------------
+sub LaunchCodeWarrior($)
+{
+  my($idepath_file) = @_;   # full path to IDE location file
+  my($cur_dir) = cwd();
+  
+  # this both launches and writes the IDE path file
+  Moz::CodeWarriorLib::activate($idepath_file);
+  
+  chdir($cur_dir);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// GetCodeWarriorRelativePath
+#//--------------------------------------------------------------------------------------------------
+sub GetCodeWarriorRelativePath($)
+{
+  my($rel_path) = @_;
+  return Moz::CodeWarriorLib::getCodeWarriorPath($rel_path);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// RedirectOutputToFile
+#//--------------------------------------------------------------------------------------------------
+sub RedirectOutputToFile($)
+{
+    my($log_file) = @_;
+    
+    # ensure that folders in the path exist
+    my($logdir) = "";
+    my($logfile) = $log_file;
+    
+    if ($log_file =~ /(.+?:)([^:]+)$/)       # ? for non-greedy match
+    {
+        $logdir = $1;
+        $logfile = $2;
+        
+        mkpath($logdir);
+    }
+
+    print "Output is now being redirected to the file '$log_file'\n";
+    
+    open(STDOUT, "> $log_file") || die "Can't redirect stdout";
+    open(STDERR, ">&STDOUT") || die "Can't dup stdout";
+    select(STDERR); $| = 1;     # make unbuffered
+    select(STDOUT); $| = 1;     # make unbuffered
+    
+    MacPerl::SetFileInfo("CWIE", "TEXT", $log_file);
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// ActivateApplication
+#//--------------------------------------------------------------------------------------------------
+
+sub ActivateApplication($)
+{
+	my ($appSignature) = @_;
+	my ($psi, $found);
+	my ($appPSN);
+	
+	$found = 0;
+		
+	foreach $psi (values(%Process))
+	{
+		if ($psi->processSignature() eq $appSignature)
+		{
+			$appPSN = $psi->processNumber();
+			$found = 1;
+            last;
+		}
+	}
+
+	if ($found == 0 || SameProcess($appPSN, GetFrontProcess()))
+	{
+		return;
+	}
+
+	SetFrontProcess($appPSN);
+
+	while (GetFrontProcess() != $appPSN)
+	{
+		WaitNextEvent();
+	}
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// IsProcessRunning
+#//--------------------------------------------------------------------------------------------------
+
+sub IsProcessRunning($)
+{
+    my($processName, $psn, $psi) = @_;
+    while ( ($psn, $psi) = each(%Process) ) {
+     if ($psi->processName eq $processName) { return 1; }
+    }
+    return 0;
+}
+
+
+1;
+
+=head1 AUTHORS
+
+Scott Collins <scc@netscape.com>, Simon Fraser <sfraser@netscape.com>, Chris Yeh <cyeh@netscape.com>
+
+=head1 SEE ALSO
+
+BuildMozillaDebug.pl (et al), BuildList.pm, CodeWarriorLib (an AppleScript library)
+
+=head1 COPYRIGHT
+
+The contents of this file are subject to the Netscape Public
+License Version 1.1 (the "License"); you may not use this file
+except in compliance with the License. You may obtain a copy of
+the License at http://www.mozilla.org/NPL/
+
+Software distributed under the License is distributed on an "AS
+IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+implied. See the License for the specific language governing
+rights and limitations under the License.
+
+The Original Code is Mozilla Communicator client code, released
+March 31, 1998.
+
+The Initial Developer of the Original Code is Netscape
+Communications Corporation. Portions created by Netscape are
+Copyright (C) 1998-1999 Netscape Communications Corporation. All
+Rights Reserved.
+
+Contributor(s): 
+
+=cut

mozilla/build/mac/build_scripts/Moz/Prefs.pm

@@ -0,0 +1,272 @@
+
+package Moz::Prefs;
+
+require 5.004;
+require Exporter;
+
+# Package that attempts to read a file from the Preferences folder,
+# and get build settings out of it
+
+use strict;
+
+use Exporter;
+use File::Path;
+
+use Mac::Files;
+
+use vars qw(@ISA @EXPORT);
+
+@ISA		  = qw(Exporter);
+@EXPORT 	= qw(ReadMozUserPrefs);
+
+
+#-------------------------------------------------------------------------------
+#
+# GetPrefsFolder
+#
+#-------------------------------------------------------------------------------
+
+sub GetPrefsFolder()
+{
+  my($prefs_folder) = FindFolder(kOnSystemDisk, kPreferencesFolderType, 1);
+  return $prefs_folder.":Mozilla build prefs";
+}
+
+
+#-------------------------------------------------------------------------------
+#
+# SetArrayValue
+#
+#-------------------------------------------------------------------------------
+sub SetArrayValue($$$)
+{
+  my($array_ref, $index1, $index2) = @_;
+
+  my($index);
+  foreach $index (@$array_ref)
+  {
+    if ($index->[0] eq $index1)
+    {
+      $index->[1] = $index2;
+      return 1;
+    }
+  }
+  
+  return 0;
+}
+
+
+#-------------------------------------------------------------------------------
+#
+# WriteDefaultPrefsFile
+#
+#-------------------------------------------------------------------------------
+
+sub WriteDefaultPrefsFile($)
+{
+  my($file_path) = @_;
+
+  my($file_contents);
+  $file_contents = <<'EOS';
+% You can use this file to customize the Mozilla build system.
+% The following kinds of lines are allowable:
+%   Comment lines, which start with a '%' in the first column
+%   Lines which modify the default build settings. For the list of flags,
+%   see MozBuildFlags.pm. Examples are:
+%
+%    build       pull            0                    % don't pull
+%    options     mng             1                    % turn mng on
+%   
+%   Line containing the special 'buildfrom' flag, which specifies
+%   where to start the build. Example:
+%   
+%    buildfrom   nglayout                % where to start the build
+%
+%   Lines which specify the location of the files used to store paths
+%   to the CodeWarrior IDE, and the MacCVS Pro session file. Note quoting
+%   of paths containing whitespace. Examples:
+%
+%    filepath   idepath         ::codewarrior.txt
+%    filepath   sessionpath     ":Some folder:MacCVS session path.txt"
+%
+%   Lines which modify the build settings like %main::DEBUG.
+%   Any lines which do not match either of the above are assumed
+%   to set variables on $main::. Examples:
+%   
+%    MOZILLA_OFFICIAL    1
+%
+EOS
+
+  $file_contents =~ s/%/#/g;
+   
+  local(*PREFS_FILE);
+
+  open(PREFS_FILE, "> $file_path") || die "Could not write default prefs file\n";
+  print PREFS_FILE ($file_contents);
+  close(PREFS_FILE);
+
+  MacPerl::SetFileInfo("McPL", "TEXT", $file_path);
+}
+
+
+#-------------------------------------------------------------------------------
+#
+# HandlePrefSet
+#
+#-------------------------------------------------------------------------------
+sub HandlePrefSet($$$$)
+{
+  my($flags, $name, $value, $desc) = @_;
+
+  if (SetArrayValue($flags, $name, $value)) {
+    print "Prefs set $desc flag '$name' to '$value'\n";
+  } else {
+    die "$desc setting '$name' is not a valid option\n";
+  }
+
+}
+
+
+#-------------------------------------------------------------------------------
+#
+# HandleBuildFromPref
+#
+#-------------------------------------------------------------------------------
+sub HandleBuildFromPref($$)
+{
+  my($build_array, $name) = @_;
+
+  my($setting) = 0;
+  my($index);
+  foreach $index (@$build_array)
+  {
+    if ($index->[0] eq $name) {
+      $setting = 1;
+    }
+    
+    $index->[1] = $setting;    
+  }
+
+  if ($setting == 1) {
+    print "Building from $name onwards, as specified by prefs\n";
+  } else {
+    printf "Failed to find buildfrom setting '$name'\n";
+  }
+}
+
+
+#-------------------------------------------------------------------------------
+#
+# ReadPrefsFile
+#
+#-------------------------------------------------------------------------------
+
+sub ReadPrefsFile($$$$$)
+{
+  my($file_path, $build_flags, $options_flags, $filepath_flags, $create_if_missing) = @_;
+  
+  local(*PREFS_FILE);
+  
+  if (open(PREFS_FILE, "< $file_path"))
+  {
+    print "Reading build prefs from '$file_path'\n";
+  
+    while (<PREFS_FILE>)
+    {
+      my($line) = $_;
+      chomp($line);
+      
+      if ($line =~ /^\#/ || $line =~ /^\s*$/) {    # ignore comments and empty lines
+        next;
+      }
+            
+      if (($line =~ /^\s*([^#\s]+)\s+([^#\s]+)\s+\"(.+)\"(\s+#.+)?/) ||
+          ($line =~ /^\s*([^#\s]+)\s+([^#\s]+)\s+\'(.+)\'(\s+#.+)?/) ||
+          ($line =~ /^\s*([^#\s]+)\s+([^#\s]+)\s+([^#\s]+)(\s+#.+)?/))
+      {
+        my($array_name) = $1;      
+        my($option_name) = $2;
+        my($option_value) = $3;      
+      
+        # print "Read '$array_name' '$option_name' '$option_value'\n";
+        
+        if ($array_name eq "build")
+        {
+          HandlePrefSet($build_flags, $option_name, $option_value, "Build");
+        }
+        elsif ($array_name eq "options")
+        {
+          HandlePrefSet($options_flags, $option_name, $option_value, "Options");
+        }
+        elsif ($array_name eq "filepath" && $option_name && $option_value)
+        {
+          HandlePrefSet($filepath_flags, $option_name, $option_value, "Filepath");
+        }
+        else
+        {
+          print "Unknown pref option at $line\n";
+        }
+      }
+      elsif ($line =~ /^\s*buildfrom\s+([^#\s]+)(\s+#.+)?/)
+      {
+        my($build_start) = $1;
+        HandleBuildFromPref($build_flags, $build_start);
+      }
+      elsif ($line =~ /^\s*([^#\s]+)\s+([^#\s]+)(\s+#.+)?/)
+      {
+        my($build_var) = $1;
+        my($var_setting) = $2;
+        
+        print "Setting \$main::$build_var to $var_setting\n";
+        eval "\$main::$build_var = \"$var_setting\"";
+      }
+      else
+      {
+        print "Unrecognized input line at $line\n";
+      }
+      
+    }
+    
+    close(PREFS_FILE);  
+  }
+  elsif ($create_if_missing)
+  {
+    print "No prefs file found at $file_path; using defaults\n";
+    
+    my($folder_path) = $file_path;
+    $folder_path =~ s/[^:]+$//;
+    mkpath($folder_path);
+    WriteDefaultPrefsFile($file_path);
+  }
+}
+
+
+#-------------------------------------------------------------------------------
+#
+# ReadMozUserPrefs
+#
+#-------------------------------------------------------------------------------
+
+sub ReadMozUserPrefs($$$$)
+{
+  my($prefs_file_name, $build_flags, $options_flags, $filepath_flags) = @_;
+  
+  if ($prefs_file_name eq "") { return; }
+  
+  # if local prefs exist, just use those. Othewise, look in the prefs folder
+  if (-e $prefs_file_name)
+  {
+    # read local prefs
+    ReadPrefsFile($prefs_file_name, $build_flags, $options_flags, $filepath_flags, 0);
+  }
+  else
+  {
+    # first read prefs folder prefs
+    my($prefs_path) = GetPrefsFolder();
+    $prefs_path .= ":$prefs_file_name";
+
+    ReadPrefsFile($prefs_path, $build_flags, $options_flags, $filepath_flags, 1);
+  }
+}
+
+1;

mozilla/build/mac/build_scripts/Moz/ProjectXML.pm

@@ -0,0 +1,932 @@
+#!/usr/bin/perl
+
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#   Simon Fraser <sfraser@netscape.com>
+#
+
+package Moz::ProjectXML;
+
+require 5.004;
+require Exporter;
+
+use strict;
+use Exporter;
+
+use Cwd;
+use XML::DOM;
+
+use vars qw(@ISA @EXPORT);
+
+@ISA      = qw(Exporter);
+@EXPORT   = qw(
+                ParseXMLDocument
+                DisposeXMLDocument
+                WriteXMLDocument
+                CleanupPro5XML
+                GetTargetsList
+                CloneTarget
+                SetAsSharedLibraryTarget
+                SetAsStaticLibraryTarget
+                AddTarget
+                RemoveTarget
+                GetTargetSetting
+                SetTargetSetting
+                getChildElementTextContents
+              );
+
+
+#--------------------------------------------------------------------------------------------------
+# A module for reading, manipulating, and writing XML-format CodeWarrior project files.
+# 
+# Sample usage:
+# 
+# use ProjectXML;
+# 
+# my $doc = ProjectXML::ParseXMLDocument("Test.mcp.xml");
+# ProjectXML::CloneTarget($doc, "Test.shlb", "Test.lib");
+# ProjectXML::SetAsStaticLibraryTarget($doc, "Test.lib", "TestOutput.lib");
+# ProjectXML::WriteXMLDocument($doc, "Test_out.xml");
+# ProjectXML::DisposeXMLDocument($doc);
+# 
+#--------------------------------------------------------------------------------------------------
+
+
+#//--------------------------------------------------------------------------------------------------
+#// ParseXMLDocument
+#// Note that the caller must call DisposeXMLDocument on the returned doc
+#//--------------------------------------------------------------------------------------------------
+sub ParseXMLDocument($)
+{
+  my($doc_path) = @_;
+
+  my $parser = new XML::DOM::Parser(ErrorContext => 2);
+  my $doc = $parser->parsefile($doc_path);
+
+  return $doc;
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// DisposeXMLDocument
+#// Needed to avoid memory leaks - cleanup circular references for garbage collection
+#//--------------------------------------------------------------------------------------------------
+sub DisposeXMLDocument($)
+{
+  my($doc) = @_;
+  
+  $doc->dispose();
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// WriteXMLDocument
+#//--------------------------------------------------------------------------------------------------
+
+sub _pro5_tag_compression($$)
+{
+   return 1;    # Pro 5 is broken and can't import XML with <foo/> style tags
+}
+
+sub _pro6plus_tag_compression($$)
+{
+   return 0;    # Pro 6 can deal with empty XML tags like <foo/>
+}
+
+sub WriteXMLDocument($$$)
+{
+  my($doc, $file_path, $ide_version) = @_;
+
+  if ($ide_version eq "4.0")
+  {
+    XML::DOM::setTagCompression(\&_pro5_tag_compression);
+  }
+  else
+  {
+    XML::DOM::setTagCompression(\&_pro6plus_tag_compression);
+  }
+
+  $doc->printToFile($file_path);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// CleanupPro5XML
+#// XML Projects exported by Pro 5 contain garbage data under the MWMerge_MacOS_skipResources
+#// setting. This routine cleans this up, saving the result to a new file
+#//--------------------------------------------------------------------------------------------------
+sub CleanupPro5XML($$)
+{
+  my($xml_path, $out_path) = @_;
+  
+  local(*XML_FILE);
+  open(XML_FILE, "< $xml_path") || die "Error: failed to open file $xml_path\n";
+  
+  local(*CLEANED_FILE);
+  open(CLEANED_FILE, "> $out_path") || die "Error: failed to open file $out_path for writing\n";
+  
+  my $in_skip_resources_settings = 0;
+  
+  while(<XML_FILE>)
+  {
+      my($line) = $_;
+
+      if ($line =~ /^<\?codewarrior/)    # is processing inst line
+      {
+        my $test_line = $line;
+        chomp($test_line);
+  
+        my $out_line = $test_line;
+        if ($test_line =~ /^<\?codewarrior\s+exportversion=\"(.+)\"\s+ideversion=\"(.+)\"\s*\?>$/)
+        {
+          my $export_version = $1;
+          my $ide_version    = $2;
+
+          $ide_version = "4.0_mozilla";   # pseudo IDE version so we know we touched it
+          $out_line = "<?codewarrior exportversion=\"".$export_version."\" ideversion=\"".$ide_version."\"?>";
+        }
+
+        print CLEANED_FILE "$out_line\n";
+        next;
+      }
+      
+      if ($line =~ /MWMerge_MacOS_skipResources/)
+      {
+        $in_skip_resources_settings = 1;
+        print CLEANED_FILE "$line";
+      }
+      elsif($in_skip_resources_settings && $line =~ /<!-- Settings for/)
+      {
+        # leaving bad settings lines. Write closing tag
+        print CLEANED_FILE "                    <!-- Corrupted setting entries removed by script -->\n";
+        print CLEANED_FILE "                </SETTING>\n\n";
+        
+        print CLEANED_FILE "$line";
+
+        $in_skip_resources_settings = 0;
+      }
+      elsif (!$in_skip_resources_settings)
+      {      
+        print CLEANED_FILE "$line";
+      }
+  }
+  
+  close(XML_FILE);
+  close(CLEANED_FILE);
+
+}
+
+#--------------------------------------------------------------------------------------------------
+# SniffProjectXMLIDEVersion
+#
+#--------------------------------------------------------------------------------------------------
+sub SniffProjectXMLIDEVersion($)
+{
+  my($xml_path) = @_;
+  
+  my $found_version = "";
+  
+  local(*XML_FILE);
+  open(XML_FILE, "< $xml_path") || die "Error: failed to open file $xml_path\n";
+  
+  while(<XML_FILE>)
+  {
+      my($line) = $_;
+      chomp($line);
+      
+      if ($line =~ /^<\?codewarrior/)    # is processing inst line
+      {
+        unless ($line =~ /^<\?codewarrior\s+exportversion=\"(.+)\"\s+ideversion=\"(.+)\"\s*\?>$/)
+        {
+          die "Error: Failed to find ideversion in $xml_path in line $line\n";
+        }
+        
+        my $export_version = $1;
+        my $ide_version    = $2;
+
+        $found_version = $ide_version;         
+        last;
+      }
+  }
+  
+  close(XML_FILE);
+
+  return $found_version;
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// GetTargetsList
+#// Returns an array of target names
+#//--------------------------------------------------------------------------------------------------
+sub GetTargetsList($)
+{
+  my($doc) = @_;
+
+  my $nodes = $doc->getElementsByTagName("TARGET");
+  my $n = $nodes->getLength;
+  
+  my @target_names;
+  
+  for (my $i = 0; $i < $n; $i++)
+  {
+    my ($node) = $nodes->item($i);   
+   
+    my($target_name) = getChildElementTextContents($node, "NAME");
+    push(@target_names, $target_name);
+  }
+
+  return @target_names;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// CloneTarget
+#// Clone the named target, renaming it to 'new_name'
+#//--------------------------------------------------------------------------------------------------
+sub CloneTarget($$$)
+{
+  my($doc, $target_name, $new_name) = @_;
+
+  my $target_node   = getTargetNode($doc, $target_name);
+
+  # clone here
+  my $target_clone  = $target_node->cloneNode(1);   # deep clone
+  
+  # -- munge target settings --
+
+  # set the target name field
+  setChildElementTextContents($doc, $target_clone, "NAME", $new_name);
+  
+  # set the targetname pref
+  setTargetNodeSetting($doc, $target_clone, "Targetname", $new_name);
+
+  # -- insert new target subtree --
+  
+  my $target_list   = $target_node->getParentNode();
+  $target_list->appendChild($target_clone);
+  
+  # -- now add to targetorder --
+  my (@target_order_nodes) = getChildOfDocument($doc, "TARGETORDER");
+  
+  my $target_order = @target_order_nodes[0];
+  
+  my $new_order     = $doc->createElement("ORDEREDTARGET");
+  my $order_name    = $doc->createElement("NAME");
+  
+  $new_order->appendChild($order_name);
+
+  setChildElementTextContents($doc, $new_order, "NAME", $new_name);
+  $target_order->appendChild($new_order);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// SetAsSharedLibraryTarget
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub SetAsSharedLibraryTarget($$$)
+{
+  my($doc, $target_name, $output_name) = @_;
+
+  my $target_node = getTargetNode($doc, $target_name);
+
+  setTargetNodeSetting($doc, $target_node, "MWProject_PPC_type", "SharedLibrary");
+  setTargetNodeSetting($doc, $target_node, "MWProject_PPC_filetype", "1936223330"); #'shlb'
+  setTargetNodeSetting($doc, $target_node, "MWProject_PPC_outfile", $output_name);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// AddFileToTarget
+#// 
+#// Add a file to the specified target(s).
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub AddFileToTarget($$$)
+{
+  my($doc, $target_list, $file_name) = @_;
+
+  # the file must be added in 3 places:
+  # 1. in <TARGET><FILELIST><FILE> (with linkage flags if necessary)
+  # 2. in <TARGET><LINKORDER><FILEREF>
+  # 3. in <GROUPLIST><GROUP><FILEREF>
+  die "Write me\n";
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// RemoveFileFromTarget
+#// 
+#// Remove a file from the specified target, removing it from the entire project
+#// if no other targets reference it.
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub RemoveFileFromTarget($$$)
+{
+  my($doc, $target_node, $file_name) = @_;
+  
+  # the file must be removed in 3 places:
+  # 1. in <TARGET><FILELIST><FILE>
+  # 2. in <TARGET><LINKORDER><FILEREF>
+  # 3. in <GROUPLIST><GROUP><FILEREF>
+  
+  # first, remove from <FILELIST>
+  my $filelist_node = getFirstChildElement($target_node, "FILELIST");
+  unless ($filelist_node) { die "Error: failed to find FILELIST node\n"; }
+  
+  my $file_node = getChildNodeByGrandchildContents($doc, $filelist_node, "FILE", "PATH", $file_name);
+  unless ($file_node) { return; }
+
+  $filelist_node->removeChild($file_node);
+  
+  # next, remove from <LINKORDER>
+  my $linkorder_node = getFirstChildElement($target_node, "LINKORDER");
+  unless ($linkorder_node) { die "Error: failed to find LINKORDER node\n"; }
+  
+  my $fileref_node = getChildNodeByGrandchildContents($doc, $linkorder_node, "FILEREF", "PATH", $file_name);
+  unless ($fileref_node) { die "Error: link order node for file $file_name not found\n"; }
+
+  $linkorder_node->removeChild($fileref_node);
+  
+  # last, remove from <GROUPLIST>
+  # <GROUPLIST> is cross-target, so we have to be careful here.
+  my $grouplist_node = getChildOfDocument($doc, "GROUPLIST");
+  unless ($grouplist_node) { die "Error: failed to find GROUPLIST node\n"; }
+
+  # if the file isn't in any other targets, remove it from the groups
+  if (!GetFileInUse($doc, $file_name))
+  {
+    print "File $file_name is in no other targest. Removing from project\n";
+
+    my @group_nodes;
+    getChildElementsOfType($doc, $grouplist_node, "GROUP", \@group_nodes);
+    my $group_node;
+    foreach $group_node (@group_nodes)
+    {
+      my @fileref_nodes;
+      getChildElementsOfType($doc, $group_node, "FILEREF", \@fileref_nodes);
+  
+      my $fileref_node;
+      foreach $fileref_node (@fileref_nodes)
+      {
+        my $path_name = getChildElementTextContents($fileref_node, "PATH");
+        if ($path_name eq $file_name)
+        {
+          print "Removing $file_name from project group list\n";
+          $group_node->removeChild($fileref_node);
+          last;
+        }
+      }
+      
+      # can a file appear in more than one group?
+    }
+  }
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// SetAsStaticLibraryTarget
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub SetAsStaticLibraryTarget($$$)
+{
+  my($doc, $target_name, $output_name) = @_;
+
+  my $target_node = getTargetNode($doc, $target_name);
+
+  setTargetNodeSetting($doc, $target_node, "MWProject_PPC_type", "Library");
+  setTargetNodeSetting($doc, $target_node, "MWProject_PPC_filetype", "1061109567"); #'????'
+  setTargetNodeSetting($doc, $target_node, "MWProject_PPC_outfile", $output_name);
+
+  # static targets don't need any library linkage, so we can remove linkage
+  # with all .shlb and .Lib files.
+  
+  my(@obsolete_files) = ("NSStdLibStubs", "InterfacesStubs", "InterfaceLib", "InternetConfigLib");
+
+  print " Removing libraries etc. from target\n";
+
+  # get all files in target
+  my @target_files = GetTargetFilesList($doc, $target_name);
+  my $target_file;
+  foreach $target_file (@target_files)
+  {
+    if ($target_file =~ /(\.shlb|\.lib|\.Lib|\.o|\.exp)$/)
+    {
+      RemoveFileFromTarget($doc, $target_node, $target_file);
+    }
+  }
+  
+  print " Removing stub libraries from target\n";
+  
+  # then remove files with known names
+  my $obs_file;
+  foreach $obs_file (@obsolete_files)
+  {
+    RemoveFileFromTarget($doc, $target_node, $obs_file);
+  }
+
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// AddTarget
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub AddTarget($$)
+{
+  my($doc, $target_name) = @_;
+
+  die "Write me\n";
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// RemoveTarget
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub RemoveTarget($$)
+{
+  my($doc, $target_name) = @_;
+
+  die "Write me\n";
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// GetTargetSetting
+#// Get the value for the specified setting in the specified target
+#//--------------------------------------------------------------------------------------------------
+sub GetTargetSetting($$$)
+{
+  my($doc, $target_name, $setting_name) = @_;
+
+  my $target_node   = getTargetNode($doc, $target_name);
+  return getTargetNodeSetting($target_node, "VALUE");
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// SetTargetSetting
+#// Set the value for the specified setting in the specified target
+#//--------------------------------------------------------------------------------------------------
+sub SetTargetSetting($$$$)
+{
+  my($doc, $target_name, $setting_name, $new_value) = @_;
+
+  my $target_node   = getTargetNode($doc, $target_name);
+  setTargetNodeSetting($doc, $target_node, "VALUE", $new_value);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// GetTargetFilesList
+#// Return an array of the files in the target (in filelist order)
+#//--------------------------------------------------------------------------------------------------
+sub GetTargetFilesList($$)
+{
+  my($doc, $target_name) = @_;
+
+  my $target_node = getTargetNode($doc, $target_name);
+
+  my @files_list;
+    
+  my $filelist_node = getFirstChildElement($target_node, "FILELIST");
+  unless ($filelist_node) { die "Error: failed to find FILELIST node\n"; }
+
+  my @file_nodes;
+  getChildElementsOfType($doc, $filelist_node, "FILE", \@file_nodes);
+  
+  my $node;
+  foreach $node (@file_nodes)
+  {
+    my $file_name = getChildElementTextContents($node, "PATH");
+    push(@files_list, $file_name);
+  }
+  
+  return @files_list;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// FileIsInTarget
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub FileIsInTarget($$$)
+{
+  my($doc, $file_name, $target_name) = @_;
+
+  my $target_node = getTargetNode($doc, $target_name);
+  unless ($target_node) { die "Error: no target found called $target_name\n"; }
+
+  my $file_node = GetTargetFileNode($doc, $target_node, $file_name);
+  if ($file_node) {
+    return 1;
+  }
+  
+  return 0;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// GetFileTargetsList
+#// Return an array of the targets that a file is in (expensive)
+#//--------------------------------------------------------------------------------------------------
+sub GetFileTargetsList($$)
+{
+  my ($doc, $file_name) = @_;
+
+  my @target_list;
+
+  my @targets = GetTargetsList($doc);
+  my $target;
+  
+  foreach $target (@targets)
+  {
+    if (FileIsInTarget($doc, $file_name, $target))
+    {
+      push(@target_list, $target);
+    }
+  }
+  
+  return @target_list;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// GetTargetFileNode
+#// 
+#//--------------------------------------------------------------------------------------------------
+sub GetTargetFileNode($$$)
+{
+  my($doc, $target_node, $file_name) = @_;
+
+  my $filelist_node = getFirstChildElement($target_node, "FILELIST");
+  unless ($filelist_node) { die "Error: failed to find FILELIST node\n"; }
+  
+  my $file_node = getChildNodeByGrandchildContents($doc, $filelist_node, "FILE", "PATH", $file_name);
+
+  return $file_node;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// GetFileInUse
+#// Return true if the file is used by any target
+#//--------------------------------------------------------------------------------------------------
+sub GetFileInUse($$)
+{
+  my($doc, $file_name) = @_;
+
+  my $targetlist_node = getChildOfDocument($doc, "TARGETLIST");
+
+  my $target_node = $targetlist_node->getFirstChild();
+ 
+  while ($target_node)
+  {
+    if ($target_node->getNodeTypeName eq "ELEMENT_NODE" &&
+        $target_node->getTagName() eq "TARGET")
+    {
+      # if this is a target node
+      my $file_node = GetTargetFileNode($doc, $target_node, $file_name);
+      if ($file_node) {
+        return 1;   # found it
+      }      
+    }
+
+    $target_node = $target_node->getNextSibling();
+  }
+  
+  # not found
+  return 0;
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// getChildOfDocument
+#//--------------------------------------------------------------------------------------------------
+sub getChildOfDocument($$)
+{
+  my($doc, $child_type) = @_;
+
+  return getFirstChildElement($doc->getDocumentElement(), $child_type);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// getFirstChildElement
+#//--------------------------------------------------------------------------------------------------
+sub getFirstChildElement($$)
+{
+  my($node, $element_name) = @_;
+
+  my $found_node;
+  
+  unless ($node) { die "getFirstChildElement called with empty node\n"; }
+  
+  #look for the first "element_name" child
+
+  my $child_node = $node->getFirstChild();
+ 
+  while ($child_node)
+  {
+    if ($child_node->getNodeTypeName eq "ELEMENT_NODE" &&
+        $child_node->getTagName() eq $element_name)
+    {
+      $found_node = $child_node;
+      last;
+    }
+
+    $child_node = $child_node->getNextSibling();
+  }
+   
+  return $found_node;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// getChildElementsOfType
+#// 
+#// Return an array of refs to child nodes of the given type
+#//--------------------------------------------------------------------------------------------------
+sub getChildElementsOfType($$$$)
+{
+  my($doc, $node, $child_type, $array_ref) = @_;
+
+  my $child_node = $node->getFirstChild();
+ 
+  while ($child_node)
+  {
+    if ($child_node->getNodeTypeName eq "ELEMENT_NODE" &&
+        $child_node->getTagName() eq $child_type)
+    {
+      push(@$array_ref, $child_node);
+    }
+
+    $child_node = $child_node->getNextSibling();
+  }
+
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// getChildElementTextContents
+#//--------------------------------------------------------------------------------------------------
+#
+# Given <FOOPY><NERD>Hi!</NERD></FOOPY>, where $node is <FOOPY>,
+# returns "Hi!". If > 1 <NERD> node, returns the contents of the first.
+#
+sub getChildElementTextContents($$)
+{
+  my($node, $tag_name) = @_;
+
+  my $first_element = getFirstChildElement($node, $tag_name);  
+  my $text_node     = $first_element->getFirstChild();
+  
+  my $text_contents = "";
+  
+  # concat adjacent text nodes
+  while ($text_node)
+  {
+    if ($text_node->getNodeTypeName() ne "TEXT_NODE")
+    {
+      last;
+    }
+
+    $text_contents = $text_contents.$text_node->getData();
+    $text_node = $text_node->getNextSibling();
+  }
+
+  return $text_contents;
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// setChildElementTextContents
+#//--------------------------------------------------------------------------------------------------
+sub setChildElementTextContents($$$$)
+{
+  my($doc, $node, $tag_name, $contents_text) = @_;
+  
+  my $first_element = getFirstChildElement($node, $tag_name);  
+  my $new_text_node = $doc->createTextNode($contents_text);
+  
+  # replace all child elements with a text element
+  removeAllChildren($first_element);
+  
+  $first_element->appendChild($new_text_node);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// getChildNodeByContents
+#// 
+#// Consider <foo><bar><baz>Foopy</baz></bar><bar><baz>Loopy</baz></bar></foo>
+#// This function, when called with getChildNodeByContents($foonode, "bar", "baz", "Loopy")
+#// returns the second <bar> node.
+#//--------------------------------------------------------------------------------------------------
+sub getChildNodeByGrandchildContents($$$$$)
+{
+  my($doc, $node, $child_type, $gc_type, $gc_contents) = @_;    # gc = grandchild
+
+  my $found_node;
+  my $child_node = $node->getFirstChild();
+  while ($child_node)
+  {
+    if ($child_node->getNodeTypeName eq "ELEMENT_NODE" &&
+        $child_node->getTagName() eq $child_type)
+    {
+      # check for a child of this node of type 
+      my $child_contents = getChildElementTextContents($child_node, $gc_type);
+
+      if ($child_contents eq $gc_contents)
+      {
+        $found_node = $child_node;
+        last;
+      }
+    }
+
+    $child_node = $child_node->getNextSibling();
+  }
+
+  return $found_node;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// getTargetNode
+#//--------------------------------------------------------------------------------------------------
+sub getTargetNode($$)
+{
+  my($doc, $target_name) = @_;
+
+  my $targetlist_node = getChildOfDocument($doc, "TARGETLIST");
+  return getChildNodeByGrandchildContents($doc, $targetlist_node, "TARGET", "NAME", $target_name);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// getTargetNamedSettingNode
+#//--------------------------------------------------------------------------------------------------
+sub getTargetNamedSettingNode($$)
+{
+  my($target_node, $setting_name) = @_;
+
+  my $setting_node;
+
+  my $settinglist_node = getFirstChildElement($target_node, "SETTINGLIST");
+  my $child_node = $settinglist_node->getFirstChild();
+ 
+  while ($child_node)
+  {
+    if ($child_node->getNodeTypeName ne "ELEMENT_NODE")
+    {
+      $child_node = $child_node->getNextSibling();
+      next;
+    }
+    
+    if ($child_node->getTagName() eq "SETTING")
+    {
+      my $set_name = getChildElementTextContents($child_node, "NAME");
+
+      if ($set_name eq $setting_name)
+      {
+        $setting_node = $child_node;
+        last;
+      }
+    }
+
+    $child_node = $child_node->getNextSibling();
+  }
+
+  return $setting_node;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// getTargetNodeSetting
+#//--------------------------------------------------------------------------------------------------
+sub getTargetNodeSetting($$)
+{
+  my($target_node, $setting_name) = @_;
+  
+  my $setting_node  = getTargetNamedSettingNode($target_node, $setting_name);
+  return getChildElementTextContents($setting_node, "VALUE");
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// setTargetNodeSetting
+#//--------------------------------------------------------------------------------------------------
+sub setTargetNodeSetting($$$$)
+{
+  my($doc, $target_node, $setting_name, $new_value) = @_;
+
+  my $setting_node  = getTargetNamedSettingNode($target_node, $setting_name);
+
+  setChildElementTextContents($doc, $setting_node, "VALUE", $new_value);
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// elementInArray
+#//--------------------------------------------------------------------------------------------------
+sub elementInArray($$)
+{
+  my($element, $array) = @_;
+  my $test;
+  foreach $test (@$array)
+  {
+    if ($test eq $element) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// removeAllChildren
+#//--------------------------------------------------------------------------------------------------
+sub removeAllChildren($)
+{
+  my($node) = @_;
+  
+  my $child_node = $node->getFirstChild();
+  
+  while ($child_node)
+  {
+    $node->removeChild($child_node);
+    $child_node = $node->getFirstChild();
+  }
+}
+
+
+#//--------------------------------------------------------------------------------------------------
+#// dumpNodeData
+#//--------------------------------------------------------------------------------------------------
+sub dumpNodeData($)
+{
+  my($node) = @_;
+  
+  unless ($node) { die "Null node passed to dumpNodeData\n"; }
+  
+  print "Dumping node $node\n";
+  
+  my($node_type) = $node->getNodeTypeName();
+  
+  if ($node_type eq "ELEMENT_NODE")
+  {
+    my($node_name) = $node->getTagName();
+    print "Element $node_name\n";
+  }
+  elsif ($node_type eq "TEXT_NODE")
+  {
+    my($node_data) = $node->getData;
+    # my(@node_vals) = unpack("C*", $node_data);
+    print "Text '$node_data'\n";    # may contain LF chars
+  }
+  else
+  {
+    print "Node $node_type\n";
+  }
+
+}
+
+#//--------------------------------------------------------------------------------------------------
+#// dumpNodeTree
+#//--------------------------------------------------------------------------------------------------
+sub dumpNodeTree($)
+{
+  my($node) = @_;
+  
+  my($child_node) = $node->getFirstChild();
+  
+  unless ($child_node) { return; }
+
+  # recurse
+  dumpNodeData($child_node);
+  
+  # then go through child nodes
+  while ($child_node)
+  {
+    dumpNodeTree($child_node);
+  
+    $child_node = $child_node->getNextSibling();
+  }
+}
+
+
+
+
+1;
+

mozilla/build/mac/build_scripts/MozillaBuildFlags.txt

@@ -0,0 +1,90 @@
+#-------------------------------------------------------------------------------
+# These 3 lists are the 'master lists' to control what gets built.
+# 
+# Ordering in these arrays is important; it has to reflect the order in
+# which the build occurs.
+#
+# Setting containing spaces must be quoted with double quotes.
+#-------------------------------------------------------------------------------
+
+build_flags
+all             1
+pull            0
+dist            0
+config          0
+xpidl           0
+idl             0
+stubs           0
+runtime         0
+common          0
+imglib          0
+libimg2         0
+necko           0
+security        0
+browserutils    0
+intl            0
+nglayout        0
+accessiblity    0
+editor          0
+embedding       0
+viewer          0
+xpapp           0
+extensions      0
+plugins         0
+mailnews        0
+apprunner       0
+resources       0
+
+options_flags
+pull_by_date    0
+chrome_jars     1
+chrome_files    0
+use_jars        1
+transformiix    1
+mathml          0      MOZ_MATHML
+svg             0      MOZ_SVG
+# svg requires libart, which is an lgpl library. You need to pull it 
+# explicitly.
+libart_lgpl     0
+mng             1
+ldap            1      MOZ_LDAP_XPCOM
+ldap_experimental 0    MOZ_LDAP_XPCOM_EXPERIMENTAL
+xmlextras       1
+wsp             0      MOZ_WSP
+inspector       1
+mailextras      1
+xptlink         0
+psm             0      MOZ_PSM
+embedding_test  1
+embedding_chrome 0
+embedding_xulprefs 0
+embedding_xulsecurity 0
+carbon          0      TARGET_CARBON
+useimg2         1      USE_IMG2
+lowmem          0      MOZ_MAC_LOWMEM
+accessible      1      ACCESSIBILITY
+bidi            1      IBMBIDI
+p3p             0
+jsd             1
+venkman         1
+moz_logging     1      MOZ_LOGGING
+chatzilla       1
+content_packs   1
+xml_rpc         1
+cview           1
+help            1
+timeline        0      MOZ_TIMELINE
+static_build    0      MOZ_STATIC_COMPONENT_LIBS
+string_debug    0      DEBUG_STRING
+string_stats    0      DEBUG_STRING_STATS
+xpctools        0      XPC_TOOLS_SUPPORT
+smime           1
+mdn             1
+print_preview   1      NS_PRINT_PREVIEW
+moz_xul         1      MOZ_XUL
+
+filepath_flags
+idepath             ":CodeWarrior IDE Path.txt"
+sessionpath         ":Mozilla session path.txt"
+buildlogfilepath    ":Build Logs:Mozilla build log.txt"   # this is a path
+scriptlogfilepath   ":Build Logs:Mozilla script log.txt"

mozilla/build/mac/build_scripts/MozillaCheckoutList.txt

@@ -0,0 +1,22 @@
+# List of modules to check out. Format is
+#   module, (tag), (date)
+# where tag and date are optional (non-trailing commas are required)
+#
+# Examples:
+#   mozilla/nsprpub, NSPRPUB_CLIENT_TAG
+#   mozilla/gc, , 10/25/2000 12:00:00
+#
+
+mozilla/nsprpub,        	NETSCAPE_7_0_RTM
+mozilla/security/nss,   	NETSCAPE_7_0_RTM
+mozilla/security/manager,	NETSCAPE_7_0_RTM
+mozilla/accessible,			NETSCAPE_7_0_RTM
+mozilla/directory/c-sdk,	NETSCAPE_7_0_RTM
+mozilla/lib/mac/Instrumentation, 	NETSCAPE_7_0_RTM
+mozilla/gfx2, 				NETSCAPE_7_0_RTM
+mozilla/modules/libpr0n,	NETSCAPE_7_0_RTM
+SeaMonkeyAll, 				NETSCAPE_7_0_RTM
+
+## You need this if you want to be able to use SVG
+## Note that this library is under the LGPL, not the MPL
+#mozilla/other-licenses/libart_lgpl

mozilla/build/mac/build_scripts/PullMozilla.pl

@@ -0,0 +1,79 @@
+#!perl
+
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#   Simon Fraser <sfraser@netscape.com>
+#
+
+require 5.004;
+
+use strict;
+
+use Cwd;
+use Moz::BuildUtils;
+use Moz::BuildCore;
+
+#-------------------------------------------------------------
+# Where have the build options gone?
+# 
+# The various build flags have been centralized into one place. 
+# The master list of options is in MozBuildFlags.txt. However, 
+# you should never need to edit that file, or this one.
+# 
+# To customize what gets built, or where to start the build, 
+# edit the $prefs_file_name file in
+# System Folder:Preferences:Mozilla build prefs:
+# Documentation is provided in that file.
+#-------------------------------------------------------------
+
+my($prefs_file_name) = "Mozilla pull prefs";
+
+#-------------------------------------------------------------
+# hashes to hold build options
+#-------------------------------------------------------------
+my(%build);
+my(%options);
+my(%filepaths);
+my(%optiondefines);
+
+# Hash of input files for this build. Eventually, there will be
+# input files for manifests, and projects too.
+my(%inputfiles) = (
+  "buildflags",     "MozillaBuildFlags.txt",
+  "checkoutdata",   "MozillaCheckoutList.txt",
+  "buildprogress",  "",
+  "buildmodule",    "MozillaBuildList.pm",
+  "checkouttime",   "Mozilla last checkout"
+);
+#-------------------------------------------------------------
+# end build hashes
+#-------------------------------------------------------------
+
+# set the build root directory, which is the the dir above mozilla
+SetupBuildRootDir(":mozilla:build:mac:build_scripts");
+
+# Set up all the flags on $main::, like DEBUG, CARBON etc.
+# Override the defaults using the preferences files.
+SetupDefaultBuildOptions(0, ":mozilla:dist:viewer:", "");
+
+my($do_checkout)    = 1;
+my($do_build)       = 0;
+
+RunBuild($do_checkout, $do_build, \%inputfiles, $prefs_file_name);

mozilla/client.mak

@@ -0,0 +1,511 @@
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+
+DEPTH=.
+
+!if !defined(MOZ_TOP)
+#enable builds from changed top level directories
+MOZ_TOP=mozilla
+!endif
+
+MOZ_SRC_FLIPPED = $(MOZ_SRC:\=/)
+MOZ_DIST_FLIPPED = $(MOZ_SRC_FLIPPED)/mozilla/dist
+!ifdef MOZ_DEBUG
+MOZ_OBJDIR = WIN32_D.OBJ
+!else
+MOZ_OBJDIR = WIN32_O.OBJ
+!endif
+
+#
+# Command macro defines
+#
+
+#//------------------------------------------------------------------------
+#// Figure out how to do the pull.
+#//------------------------------------------------------------------------
+# uncomment these, modify branch tag, and check in to branch for milestones
+MOZ_BRANCH=NETSCAPE_7_0_RTM
+NSPR_CO_TAG=NETSCAPE_7_0_RTM
+PSM_CO_TAG=NETSCAPE_7_0_RTM
+NSS_CO_TAG=NETSCAPE_7_0_RTM
+LDAPCSDK_CO_TAG=NETSCAPE_7_0_RTM
+ACCESSIBLE_CO_TAG=NETSCAPE_7_0_RTM
+IMGLIB2_CO_TAG=NETSCAPE_7_0_RTM
+GFX2_CO_TAG=NETSCAPE_7_0_RTM
+
+
+!ifdef MOZ_BRANCH
+CVS_BRANCH=-r $(MOZ_BRANCH)
+!endif
+
+!ifdef MOZ_DATE
+CVS_BRANCH=$(CVS_BRANCH) -D "$(MOZ_DATE)"
+!endif
+
+# default pull is "quiet" but it can be overridden with MOZ_CVS_VERBOSE
+!ifndef MOZ_CVS_VERBOSE
+CVS_FLAGS=-q
+!endif
+
+# honor any user-defined CVS flags
+!ifdef MOZ_CVS_FLAGS
+CVS_FLAGS=$(CVS_FLAGS) $(MOZ_CVS_FLAGS)
+!endif
+
+# let's be explicit about CVSROOT... some windows cvs clients
+# are too stupid to correctly work without the -d option 
+#
+#  if they are too stupid, they should fail.  I am
+#  commenting this out because this does not work
+#  under 4nt.  (%'s are evaluted differently)
+#
+#  If it breaks you, mail dougt@netscape.com
+#  and leaf@mozilla.org
+#
+!if 0
+!if defined(CVSROOT)
+CVS_FLAGS=$(CVS_FLAGS) -d "$(CVSROOT)"
+!endif
+!endif
+
+!ifndef MOZ_CO_FLAGS
+MOZ_CO_FLAGS = -P
+!endif
+
+CVSCO = cvs $(CVS_FLAGS) co $(MOZ_CO_FLAGS) $(CVS_BRANCH)
+
+#//------------------------------------------------------------------------
+#// Figure out how to pull NSPR.
+#// If no NSPR_CO_TAG is specified, use the default static tag
+#//------------------------------------------------------------------------
+
+!ifndef NSPR_CO_FLAGS
+NSPR_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+NSPR_CO_FLAGS=$(NSPR_CO_FLAGS) $(CVS_BRANCH)
+
+
+CVSCO_NSPR = cvs $(CVS_FLAGS) co $(NSPR_CO_FLAGS)
+
+#//------------------------------------------------------------------------
+#// Figure out how to pull NSS and PSM libs.
+#// If no NSS_CO_TAG or PSM_CO_TAG is specified, use the default static tag
+#//------------------------------------------------------------------------
+
+!ifndef NSS_CO_FLAGS
+NSS_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+NSS_CO_FLAGS=$(NSS_CO_FLAGS) $(CVS_BRANCH)
+
+CVSCO_NSS = cvs $(CVS_FLAGS) co $(NSS_CO_FLAGS)
+
+!ifndef PSM_CO_FLAGS
+PSM_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+PSM_CO_FLAGS=$(PSM_CO_FLAGS) $(CVS_BRANCH)
+
+CVSCO_PSM = cvs $(CVS_FLAGS) co $(PSM_CO_FLAGS)
+
+#//------------------------------------------------------------------------
+#// Figure out how to pull LDAP C SDK client libs.
+#// If no LDAPCSDK_CO_TAG is specified, use the default tag
+#//------------------------------------------------------------------------
+
+
+!ifndef LDAPCSDK_CO_FLAGS
+LDAPCSDK_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+LDAPCSDK_CO_FLAGS=$(LDAPCSDK_CO_FLAGS) $(CVS_BRANCH)
+
+CVSCO_LDAPCSDK = cvs $(CVS_FLAGS) co $(LDAPCSDK_CO_FLAGS)
+
+#//------------------------------------------------------------------------
+#// Figure out how to pull accessibility libs.
+#// If no ACCESSIBLE_CO_TAG is specified, use the default tag
+#//------------------------------------------------------------------------
+
+!ifndef ACCESSIBLE_CO_FLAGS
+ACCESSIBLE_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+ACCESSIBLE_CO_FLAGS=$(ACCESSIBLE_CO_FLAGS) $(CVS_BRANCH)
+
+CVSCO_ACCESSIBLE = cvs $(CVS_FLAGS) co $(ACCESSIBLE_CO_FLAGS)
+
+#//------------------------------------------------------------------------
+#// Figure out how to pull new image library.
+#// If no IMGLIB2_CO_TAG is specified, use the default tag
+#//------------------------------------------------------------------------
+
+!ifndef IMGLIB2_CO_FLAGS
+IMGLIB2_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+IMGLIB2_CO_FLAGS=$(IMGLIB2_CO_FLAGS) $(CVS_BRANCH)
+
+CVSCO_IMGLIB2 = cvs $(CVS_FLAGS) co $(IMGLIB2_CO_FLAGS)
+
+#//------------------------------------------------------------------------
+#// Figure out how to pull new image library.
+#// If no GFX2_CO_TAG is specified, use the default tag
+#//------------------------------------------------------------------------
+
+!ifndef GFX2_CO_FLAGS
+GFX2_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+GFX2_CO_FLAGS=$(GFX2_CO_FLAGS) $(CVS_BRANCH)
+
+CVSCO_GFX2 = cvs $(CVS_FLAGS) co $(GFX2_CO_FLAGS)
+
+#//------------------------------------------------------------------------
+#// Figure out how to pull the internal libart
+#// (only pulled and built if MOZ_INTERNAL_LIBART_LGPL is set)
+#// If no MOZ_INTERNAL_LIBART_CO_TAG is specified, use the default tag
+#//------------------------------------------------------------------------
+
+!if defined(MOZ_SVG) && !defined(MOZ_INTERNAL_LIBART_LGPL)
+ERR_MESSAGE = ^
+You are trying to build Mozilla with SVG support (MOZ_SVG=1), but you ^
+haven not specified that mozilla/other-licenses/libart_lgpl should be ^
+pulled and built. At the moment Mozilla SVG builds need this patched ^
+version of libart. You either need to disable SVG support (unset MOZ_SVG) ^
+or enable pulling and building by setting MOZ_INTERNAL_LIBART_LGPL=1.^
+^
+If you choose to pull and build libart, note that it is only licensed^
+under the terms of the LGPL, not the MPL. (Which is why you have to opt^
+in explicitly.)
+!endif
+
+!if defined(MOZ_INTERNAL_LIBART_LGPL)
+
+!ifndef MOZ_INTERNAL_LIBART_CO_FLAGS
+MOZ_INTERNAL_LIBART_CO_FLAGS=$(MOZ_CO_FLAGS)
+!endif
+
+!if "$(MOZ_INTERNAL_LIBART_CO_TAG)" != ""
+MOZ_INTERNAL_LIBART_CO_FLAGS=$(MOZ_INTERNAL_LIBART_CO_FLAGS) -r $(MOZ_INTERNAL_LIBART_CO_TAG)
+!else
+MOZ_INTERNAL_LIBART_CO_FLAGS=$(MOZ_INTERNAL_LIBART_CO_FLAGS) $(CVS_BRANCH)
+!endif
+
+CVSCO_MOZ_INTERNAL_LIBART = cvs $(CVS_FLAGS) co $(MOZ_INTERNAL_LIBART_CO_FLAGS)
+
+!endif
+
+## The master target
+############################################################
+
+pull_and_build_all: pull_all build_all_dep
+
+
+## Rules for pulling the source from the cvs repository
+############################################################
+
+pull_clobber_and_build_all: pull_all clobber_all build_all
+
+!if !defined(MOZ_INTERNAL_LIBART_LGPL)
+pull_all: pull_nspr pull_psm pull_ldapcsdk pull_accessible pull_gfx2 pull_imglib2 pull_seamonkey
+!else
+pull_all: pull_nspr pull_psm pull_ldapcsdk pull_accessible pull_gfx2 pull_imglib2 pull_moz_internal_libart pull_seamonkey
+!endif
+
+pull_nspr: pull_clientmak
+      cd $(MOZ_SRC)\.
+      $(CVSCO_NSPR) mozilla/nsprpub
+
+pull_nss:
+	cd $(MOZ_SRC)\.
+	$(CVSCO_NSS) mozilla/security/coreconf
+	$(CVSCO_NSS) mozilla/security/nss
+
+pull_psm: pull_nss
+	cd $(MOZ_SRC)\.
+	$(CVSCO_PSM) mozilla/security/manager
+	$(CVSCO_PSM) mozilla/security/makefile.win
+
+pull_ldapcsdk:
+	cd $(MOZ_SRC)\.
+	$(CVSCO_LDAPCSDK) mozilla/directory/c-sdk
+
+pull_accessible:
+	cd $(MOZ_SRC)\.
+	$(CVSCO_ACCESSIBLE) mozilla/accessible
+
+pull_gfx2:
+  cd $(MOZ_SRC)\.
+  $(CVSCO_GFX2) mozilla/gfx2
+
+pull_imglib2:
+  cd $(MOZ_SRC)\.
+  $(CVSCO_IMGLIB2) mozilla/modules/libpr0n
+
+!if defined(MOZ_INTERNAL_LIBART_LGPL)
+pull_moz_internal_libart:
+  cd $(MOZ_SRC)\.
+  $(CVSCO_MOZ_INTERNAL_LIBART) mozilla/other-licenses/libart_lgpl
+!endif
+
+pull_xpconnect: pull_nspr
+	cd $(MOZ_SRC)\.
+	$(CVSCO) mozilla/include
+	$(CVSCO) mozilla/config
+	$(CVSCO) -l mozilla/js
+	$(CVSCO) -l mozilla/js/src
+	$(CVSCO) mozilla/js/src/fdlibm
+	$(CVSCO) mozilla/js/src/xpconnect
+	$(CVSCO) mozilla/modules/libreg
+	$(CVSCO) mozilla/xpcom
+	$(CVSCO) mozilla/string
+
+# pull either layout only or seamonkey the browser
+pull_layout:
+	cd $(MOZ_SRC)\.
+	$(CVSCO) RaptorWin
+
+pull_seamonkey: pull_clientmak
+	cd $(MOZ_SRC)\.
+	$(CVSCO) SeaMonkeyAll
+
+pull_clientmak:
+    cd $(MOZ_SRC)\.
+    $(CVSCO) mozilla/client.mak
+
+############################################################
+
+# nmake has to be hardcoded, or we have to depend on mozilla/config
+# being pulled already to figure out what $(NMAKE) should be.
+
+clobber_all: clobber_nspr clobber_ldapcsdk clobber_psm clobber_seamonkey
+
+build_all: build_nspr build_ldapcsdk build_seamonkey
+
+build_all_dep: depend libs
+
+distclean: 
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\directory\c-sdk
+	gmake -f gmakefile.win distclean MOZ_SRC_FLIPPED=$(MOZ_SRC_FLIPPED)
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\nsprpub
+	gmake -f gmakefile.win distclean MOZ_SRC_FLIPPED=$(MOZ_SRC_FLIPPED)
+	@cd $(MOZ_SRC)\$(MOZ_TOP)
+	nmake /f client.mak clobber_psm
+	nmake /f client.mak clobber_seamonkey
+
+clobber_ldapcsdk:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\directory\c-sdk
+	gmake -f gmakefile.win clobber_all MOZ_SRC_FLIPPED=$(MOZ_SRC_FLIPPED) \
+		SHELL=sh
+
+clobber_nspr: 
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\nsprpub
+	gmake -f gmakefile.win clobber_all MOZ_SRC_FLIPPED=$(MOZ_SRC_FLIPPED)
+
+clobber_psm:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\security
+	nmake -f makefile.win clobber_all
+
+clobber_xpconnect:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\.
+	-rd /s /q dist
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\nsprpub
+	gmake -f gmakefile.win clobber_all  MOZ_SRC_FLIPPED=$(MOZ_SRC_FLIPPED)
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\include
+	nmake -f makefile.win clobber_all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\modules\libreg
+	nmake -f makefile.win clobber_all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\string
+	nmake -f makefile.win clobber_all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\xpcom
+	nmake -f makefile.win clobber_all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\js
+	nmake -f makefile.win clobber_all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\js\src\xpconnect
+	nmake -f makefile.win clobber_all
+
+clobber_seamonkey:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\.
+	-rd /s /q dist
+	nmake -f makefile.win clobber_all 
+
+depend: export
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\.
+	nmake -f makefile.win depend 
+
+depend_xpconnect:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\include
+	nmake -f makefile.win depend
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\modules\libreg
+	nmake -f makefile.win depend
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\string
+	nmake -f makefile.win depend
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\xpcom
+	nmake -f makefile.win depend
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\js\src
+	nmake -f makefile.win depend
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\js\src\xpconnect
+	nmake -f makefile.win depend
+
+build_nspr: 
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\nsprpub
+	gmake -f gmakefile.win MOZ_SRC_FLIPPED=$(MOZ_SRC_FLIPPED)
+
+build_ldapcsdk:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\directory\c-sdk
+	gmake -f gmakefile.win MOZ_SRC_FLIPPED=$(MOZ_SRC_FLIPPED) SHELL=sh
+
+build_psm:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\security
+	nmake -f makefile.win 
+
+build_xpconnect: build_nspr
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\include
+	nmake -f makefile.win all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\modules\libreg
+	nmake -f makefile.win all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\xpcom
+	nmake -f makefile.win export
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\string
+	nmake -f makefile.win all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\xpcom
+	nmake -f makefile.win libs
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\js\src
+	nmake -f makefile.win all
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\js\src\xpconnect
+	nmake -f makefile.win all
+
+build_seamonkey:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\.
+	nmake -f makefile.win all
+
+build_client:
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake -f makefile.win all
+
+build_layout:
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake -f makefile.win all
+
+build_dist:
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake -f makefile.win all
+
+libs:
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\.
+	nmake -f makefile.win libs
+
+export: build_nspr build_ldapcsdk
+	@cd $(MOZ_SRC)\$(MOZ_TOP)\.
+	nmake -f makefile.win export
+
+clobber_dist:
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake -f makefile.win clobber_all
+
+clobber_client:
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake -f makefile.win clobber_all
+
+clobber_layout:
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake -f makefile.win clobber_all
+
+browse_info::
+	cd $(MOZ_SRC)\$(MOZ_TOP)
+	-dir /s /b *.sbr > sbrlist.tmp
+	-bscmake /Es /o mozilla.bsc @sbrlist.tmp
+	-rm sbrlist.tmp
+
+regchrome::
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake /f makefile.win regchrome
+
+deliver::
+	@cd $(MOZ_SRC)\mozilla\.
+	nmake /f makefile.win splitsymbols
+
+#//------------------------------------------------------------------------
+#// Utility stuff...
+#//------------------------------------------------------------------------
+
+#//------------------------------------------------------------------------
+# Verify that MOZ_SRC is set correctly
+#//------------------------------------------------------------------------
+
+# Check to see if it is set at all
+!if "$(MOZ_SRC)"==""
+MOZ_SRC = $(MAKEDIR)\..
+!endif
+
+#
+# create a temp file at the root and make sure it is visible from MOZ_SRC
+#
+!if [copy $(MAKEDIR)\client.mak $(MAKEDIR)\xyzzy.tmp > NUL] == 0
+!endif
+
+!if !EXIST( $(MOZ_SRC)\mozilla\xyzzy.tmp )
+ERR_MESSAGE=$(ERR_MESSAGE)^
+MOZ_SRC isn't set correctly: [$(MOZ_SRC)\mozilla]!=[$(MAKEDIR)]
+!endif
+
+!if [del $(MAKEDIR)\xyzzy.tmp]
+!endif
+
+#//------------------------------------------------------------------------
+# Verify that MOZ_BITS is set
+#//------------------------------------------------------------------------
+!if !defined(MOZ_BITS)
+ERR_MESSAGE=$(ERR_MESSAGE)^
+Environment variable MOZ_BITS isn't set.
+!endif
+
+!if !defined(MOZ_TOOLS)
+ERR_MESSAGE=$(ERR_MESSAGE)^
+Environment variable MOZ_TOOLS isn't set.
+!endif
+
+
+#//------------------------------------------------------------------------
+#// Display error 
+#//------------------------------------------------------------------------
+
+!if "$(ERR_MESSAGE)" != ""
+ERR_MESSAGE = ^
+client.mak:  ^
+$(ERR_MESSAGE) ^
+^
+client.mak: usage^
+^
+nmake -f client.mak [MOZ_BRANCH=<cvs_branch_name>] ^
+		    [MOZ_DATE=<cvs_date>]^
+		    [pull_and_build_all]^
+		    [pull_all]^
+		    [build_all]^
+^
+Environment variables:^
+^
+MOZ_BITS    set to 32^
+MOZ_TOOLS   set to the directory containing the needed tools ^
+
+!ERROR $(ERR_MESSAGE)
+
+!endif

mozilla/client.mk

@@ -52,14 +52,14 @@
 #
 # For branches, uncomment the MOZ_CO_TAG line with the proper tag,
 # and commit this file on that tag.
-MOZ_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
-NSPR_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
-PSM_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
-NSS_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
-LDAPCSDK_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
-ACCESSIBLE_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
-GFX2_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
-IMGLIB2_CO_TAG = NETSCAPE_7_0_OEM_BRANCH
+MOZ_CO_TAG = NETSCAPE_7_0_RTM
+NSPR_CO_TAG = NETSCAPE_7_0_RTM
+PSM_CO_TAG = NETSCAPE_7_0_RTM
+NSS_CO_TAG = NETSCAPE_7_0_RTM
+LDAPCSDK_CO_TAG = NETSCAPE_7_0_RTM
+ACCESSIBLE_CO_TAG = NETSCAPE_7_0_RTM
+GFX2_CO_TAG = NETSCAPE_7_0_RTM
+IMGLIB2_CO_TAG = NETSCAPE_7_0_RTM
 BUILD_MODULES = all
 
 #######################################################################