first cut, works on unix, need to undo some s/STL/stl/ changes before final merge

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

mozilla/build/mac/build_scripts/BuildMozilla.pl

@@ -1,80 +0,0 @@
-#!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

@@ -1,80 +0,0 @@
-#!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

@@ -1,595 +0,0 @@
-#!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

@@ -1,425 +0,0 @@
-#!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

@@ -1,786 +0,0 @@
-
-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

@@ -1,660 +0,0 @@
-#!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

@@ -1,573 +0,0 @@
-#!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

@@ -1,228 +0,0 @@
-#!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

@@ -1,603 +0,0 @@
-=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

@@ -1,272 +0,0 @@
-
-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

@@ -1,932 +0,0 @@
-#!/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

@@ -1,90 +0,0 @@
-#-------------------------------------------------------------------------------
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,79 +0,0 @@
-#!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

@@ -1,511 +0,0 @@
-# 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

@@ -1,650 +0,0 @@
-# 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): Stephen Lamm
-
-# Build the Mozilla client.
-#
-# This needs CVSROOT set to work, e.g.,
-#   setenv CVSROOT :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot
-# or
-#   setenv CVSROOT :pserver:username%somedomain.org@cvs.mozilla.org:/cvsroot
-# 
-# To checkout and build a tree,
-#    1. cvs co mozilla/client.mk
-#    2. cd mozilla
-#    3. gmake -f client.mk
-#
-# Other targets (gmake -f client.mk [targets...]),
-#    checkout
-#    build
-#    clean (realclean is now the same as clean)
-#    distclean
-#
-# See http://www.mozilla.org/build/unix.html for more information.
-#
-# Options:
-#   MOZ_OBJDIR           - Destination object directory
-#   MOZ_CO_DATE          - Date tag to use for checkout (default: none)
-#   MOZ_CO_MODULE        - Module to checkout (default: SeaMonkeyAll)
-#   MOZ_CVS_FLAGS        - Flags to pass cvs (default: -q -z3)
-#   MOZ_CO_FLAGS         - Flags to pass after 'cvs co' (default: -P)
-#   MOZ_MAKE_FLAGS       - Flags to pass to $(MAKE)
-#   MOZ_CO_BRANCH        - Branch tag (Deprecated. Use MOZ_CO_TAG below.)
-#
-
-#######################################################################
-# Checkout Tags
-#
-# 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_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
-
-#######################################################################
-# Defines
-#
-CVS = cvs
-
-CWD := $(shell pwd)
-
-ifeq "$(CWD)" "/"
-CWD   := /.
-endif
-
-ifneq (, $(wildcard client.mk))
-# Ran from mozilla directory
-ROOTDIR   := $(shell dirname $(CWD))
-TOPSRCDIR := $(CWD)
-else
-# Ran from mozilla/.. directory (?)
-ROOTDIR   := $(CWD)
-TOPSRCDIR := $(CWD)/mozilla
-endif
-
-# on os2, TOPSRCDIR may have two forward slashes in a row, which doesn't
-#  work;  replace first instance with one forward slash
-TOPSRCDIR := $(shell echo "$(TOPSRCDIR)" | sed -e 's%//%/%')
-
-ifndef TOPSRCDIR_MOZ
-TOPSRCDIR_MOZ=$(TOPSRCDIR)
-endif
-
-# if ROOTDIR equals only drive letter (i.e. "C:"), set to "/"
-DIRNAME := $(shell echo "$(ROOTDIR)" | sed -e 's/^.://')
-ifeq ($(DIRNAME),)
-ROOTDIR := /.
-endif
-
-AUTOCONF := autoconf
-MKDIR := mkdir
-SH := /bin/sh
-ifndef MAKE
-MAKE := gmake
-endif
-
-CONFIG_GUESS_SCRIPT := $(wildcard $(TOPSRCDIR)/build/autoconf/config.guess)
-ifdef CONFIG_GUESS_SCRIPT
-  CONFIG_GUESS = $(shell $(CONFIG_GUESS_SCRIPT))
-else
-  _IS_FIRST_CHECKOUT := 1
-endif
-
-####################################
-# CVS
-
-# Add the CVS root to CVS_FLAGS if needed
-CVS_ROOT_IN_TREE := $(shell cat $(TOPSRCDIR)/CVS/Root 2>/dev/null)
-ifneq ($(CVS_ROOT_IN_TREE),)
-ifneq ($(CVS_ROOT_IN_TREE),$(CVSROOT))
-  CVS_FLAGS := -d $(CVS_ROOT_IN_TREE)
-endif
-endif
-
-CVSCO = $(strip $(CVS) $(CVS_FLAGS) co $(CVS_CO_FLAGS))
-CVSCO_LOGFILE := $(ROOTDIR)/cvsco.log
-CVSCO_LOGFILE := $(shell echo $(CVSCO_LOGFILE) | sed s%//%/%)
-
-ifdef MOZ_CO_TAG
-  CVS_CO_FLAGS := -r $(MOZ_CO_TAG)
-endif
-
-####################################
-# Load mozconfig Options
-
-# See build pages, http://www.mozilla.org/build/unix.html, 
-# for how to set up mozconfig.
-MOZCONFIG_LOADER := mozilla/build/autoconf/mozconfig2client-mk
-MOZCONFIG_FINDER := mozilla/build/autoconf/mozconfig-find 
-MOZCONFIG_MODULES := mozilla/build/unix/modules.mk
-run_for_side_effects := \
-  $(shell cd $(ROOTDIR); \
-     if test "$(_IS_FIRST_CHECKOUT)"; then \
-        $(CVSCO) $(MOZCONFIG_FINDER) $(MOZCONFIG_LOADER) $(MOZCONFIG_MODULES); \
-     else true; \
-     fi; \
-     $(MOZCONFIG_LOADER) $(TOPSRCDIR) mozilla/.mozconfig.mk > mozilla/.mozconfig.out)
-include $(TOPSRCDIR)/.mozconfig.mk
-include $(TOPSRCDIR)/build/unix/modules.mk
-
-####################################
-# Options that may come from mozconfig
-
-# Change CVS flags if anonymous root is requested
-ifdef MOZ_CO_USE_MIRROR
-  CVS_FLAGS := -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot
-endif
-
-# MOZ_CVS_FLAGS - Basic CVS flags
-ifeq "$(origin MOZ_CVS_FLAGS)" "undefined"
-  CVS_FLAGS := $(CVS_FLAGS) -q -z 3 
-else
-  CVS_FLAGS := $(MOZ_CVS_FLAGS)
-endif
-
-# This option is deprecated. The best way to have client.mk pull a tag
-# is to set MOZ_CO_TAG (see above) and commit that change on the tag.
-ifdef MOZ_CO_BRANCH
-  $(warning Use MOZ_CO_TAG instead of MOZ_CO_BRANCH)
-  CVS_CO_FLAGS := -r $(MOZ_CO_BRANCH)
-endif
-
-# MOZ_CO_FLAGS - Anything that we should use on all checkouts
-ifeq "$(origin MOZ_CO_FLAGS)" "undefined"
-  CVS_CO_FLAGS := $(CVS_CO_FLAGS) -P
-else
-  CVS_CO_FLAGS := $(CVS_CO_FLAGS) $(MOZ_CO_FLAGS)
-endif
-
-ifdef MOZ_CO_DATE
-  CVS_CO_DATE_FLAGS := -D "$(MOZ_CO_DATE)"
-endif
-
-ifdef MOZ_OBJDIR
-  OBJDIR := $(MOZ_OBJDIR)
-  MOZ_MAKE := $(MAKE) $(MOZ_MAKE_FLAGS) -C $(OBJDIR)
-else
-  OBJDIR := $(TOPSRCDIR)
-  MOZ_MAKE := $(MAKE) $(MOZ_MAKE_FLAGS)
-endif
-
-####################################
-# CVS defines for PSM
-#
-PSM_CO_MODULE= mozilla/security/manager
-PSM_CO_FLAGS := -P -A
-ifdef MOZ_CO_FLAGS
-  PSM_CO_FLAGS := $(MOZ_CO_FLAGS)
-endif
-ifdef PSM_CO_TAG
-  PSM_CO_FLAGS := $(PSM_CO_FLAGS) -r $(PSM_CO_TAG)
-endif
-CVSCO_PSM = $(CVS) $(CVS_FLAGS) co $(PSM_CO_FLAGS) $(CVS_CO_DATE_FLAGS) $(PSM_CO_MODULE)
-
-####################################
-# CVS defines for NSS
-#
-NSS_CO_MODULE = mozilla/security/nss \
-		mozilla/security/coreconf \
-		$(NULL)
-
-NSS_CO_FLAGS := -P
-ifdef MOZ_CO_FLAGS
-  NSS_CO_FLAGS := $(MOZ_CO_FLAGS)
-endif
-ifdef NSS_CO_TAG
-   NSS_CO_FLAGS := $(NSS_CO_FLAGS) -r $(NSS_CO_TAG)
-endif
-# Cannot pull static tags by date
-ifeq ($(NSS_CO_TAG),NSS_CLIENT_TAG)
-CVSCO_NSS = $(CVS) $(CVS_FLAGS) co $(NSS_CO_FLAGS) $(NSS_CO_MODULE)
-else
-CVSCO_NSS = $(CVS) $(CVS_FLAGS) co $(NSS_CO_FLAGS) $(CVS_CO_DATE_FLAGS) $(NSS_CO_MODULE)
-endif
-
-####################################
-# CVS defines for NSPR
-#
-NSPR_CO_MODULE = mozilla/nsprpub
-NSPR_CO_FLAGS := -P
-ifdef MOZ_CO_FLAGS
-  NSPR_CO_FLAGS := $(MOZ_CO_FLAGS)
-endif
-ifdef NSPR_CO_TAG
-  NSPR_CO_FLAGS := $(NSPR_CO_FLAGS) -r $(NSPR_CO_TAG)
-endif
-# Cannot pull static tags by date
-ifeq ($(NSPR_CO_TAG),NSPRPUB_CLIENT_TAG)
-CVSCO_NSPR = $(CVS) $(CVS_FLAGS) co $(NSPR_CO_FLAGS) $(NSPR_CO_MODULE)
-else
-CVSCO_NSPR = $(CVS) $(CVS_FLAGS) co $(NSPR_CO_FLAGS) $(CVS_CO_DATE_FLAGS) $(NSPR_CO_MODULE)
-endif
-
-####################################
-# CVS defines for the C LDAP SDK
-#
-LDAPCSDK_CO_MODULE = mozilla/directory/c-sdk
-LDAPCSDK_CO_FLAGS := -P
-ifdef MOZ_CO_FLAGS
-  LDAPCSDK_CO_FLAGS := $(MOZ_CO_FLAGS)
-endif
-ifdef LDAPCSDK_CO_TAG
-  LDAPCSDK_CO_FLAGS := $(LDAPCSDK_CO_FLAGS) -r $(LDAPCSDK_CO_TAG)
-endif
-CVSCO_LDAPCSDK = $(CVS) $(CVS_FLAGS) co $(LDAPCSDK_CO_FLAGS) $(CVS_CO_DATE_FLAGS) $(LDAPCSDK_CO_MODULE)
-
-####################################
-# CVS defines for the C LDAP SDK
-#
-ACCESSIBLE_CO_MODULE = mozilla/accessible
-ACCESSIBLE_CO_FLAGS := -P
-ifdef MOZ_CO_FLAGS
-  ACCESSIBLE_CO_FLAGS := $(MOZ_CO_FLAGS)
-endif
-ifdef ACCESSIBLE_CO_TAG
-  ACCESSIBLE_CO_FLAGS := $(ACCESSIBLE_CO_FLAGS) -r $(ACCESSIBLE_CO_TAG)
-endif
-CVSCO_ACCESSIBLE = $(CVS) $(CVS_FLAGS) co $(ACCESSIBLE_CO_FLAGS) $(CVS_CO_DATE_FLAGS) $(ACCESSIBLE_CO_MODULE)
-
-####################################
-# CVS defines for gfx2
-#
-GFX2_CO_MODULE = mozilla/gfx2
-GFX2_CO_FLAGS := -P
-ifdef MOZ_CO_FLAGS
-  GFX2_CO_FLAGS := $(MOZ_CO_FLAGS)
-endif
-ifdef GFX2_CO_TAG
-  GFX2_CO_FLAGS := $(GFX2_CO_FLAGS) -r $(GFX2_CO_TAG)
-endif
-CVSCO_GFX2 = $(CVS) $(CVS_FLAGS) co $(GFX2_CO_FLAGS) $(CVS_CO_DATE_FLAGS) $(GFX2_CO_MODULE)
-
-####################################
-# CVS defines for new image library
-#
-IMGLIB2_CO_MODULE = mozilla/modules/libpr0n
-IMGLIB2_CO_FLAGS := -P
-ifdef MOZ_CO_FLAGS
-  IMGLIB2_CO_FLAGS := $(MOZ_CO_FLAGS)
-endif
-ifdef IMGLIB2_CO_TAG
-  IMGLIB2_CO_FLAGS := $(IMGLIB2_CO_FLAGS) -r $(IMGLIB2_CO_TAG)
-endif
-CVSCO_IMGLIB2 = $(CVS) $(CVS_FLAGS) co $(IMGLIB2_CO_FLAGS) $(CVS_CO_DATE_FLAGS) $(IMGLIB2_CO_MODULE)
-
-####################################
-# CVS defines for standalone modules
-#
-ifneq ($(BUILD_MODULES),all)
-  MOZ_CO_MODULE := $(filter-out $(NSPRPUB_DIR) security directory/c-sdk, $(BUILD_MODULE_CVS))
-  MOZ_CO_MODULE += allmakefiles.sh client.mk aclocal.m4 configure configure.in
-  MOZ_CO_MODULE += Makefile.in
-  MOZ_CO_MODULE := $(addprefix mozilla/, $(MOZ_CO_MODULE))
-
-  NOSUBDIRS_MODULE := $(addprefix mozilla/, $(BUILD_MODULE_CVS_NS))
-ifneq ($(NOSUBDIRS_MODULE),)
-  CVSCO_NOSUBDIRS := $(CVSCO) -l $(CVS_CO_DATE_FLAGS) $(NOSUBDIRS_MODULE)
-endif
-
-ifeq (,$(filter $(NSPRPUB_DIR), $(BUILD_MODULE_CVS)))
-  CVSCO_NSPR :=
-endif
-ifeq (,$(filter security security/manager, $(BUILD_MODULE_CVS)))
-  CVSCO_PSM :=
-  CVSCO_NSS :=
-endif
-ifeq (,$(filter directory/c-sdk, $(BUILD_MODULE_CVS)))
-  CVSCO_LDAPCSDK :=
-endif
-ifeq (,$(filter accessible, $(BUILD_MODULE_CVS)))
-  CVSCO_ACCESSIBLE :=
-endif
-ifeq (,$(filter gfx2, $(BUILD_MODULE_CVS)))
-  CVSCO_GFX2 :=
-endif
-ifeq (,$(filter modules/libpr0n, $(BUILD_MODULE_CVS)))
-  CVSCO_IMGLIB2 :=
-endif
-endif
-
-####################################
-# CVS defines for SeaMonkey
-#
-ifeq ($(MOZ_CO_MODULE),)
-  MOZ_CO_MODULE := SeaMonkeyAll
-endif
-CVSCO_SEAMONKEY := $(CVSCO) $(CVS_CO_DATE_FLAGS) $(MOZ_CO_MODULE)
-
-####################################
-# CVS defined for libart (pulled and built if MOZ_INTERNAL_LIBART_LGPL is set)
-#
-CVSCO_LIBART := $(CVSCO) $(CVS_CO_DATE_FLAGS) mozilla/other-licenses/libart_lgpl
-
-ifdef MOZ_INTERNAL_LIBART_LGPL
-FASTUPDATE_LIBART := fast_update $(CVSCO_LIBART)
-CHECKOUT_LIBART := cvs_co $(CVSCO_LIBART)
-else
-CHECKOUT_LIBART := true
-FASTUPDATE_LIBART := true
-endif
-
-####################################
-# CVS defines for Calendar (pulled and built if MOZ_CALENDAR is set)
-#
-CVSCO_CALENDAR := $(CVSCO) $(CVS_CO_DATE_FLAGS) mozilla/calendar
-
-ifdef MOZ_CALENDAR
-FASTUPDATE_CALENDAR := fast_update $(CVSCO_CALENDAR)
-CHECKOUT_CALENDAR := cvs_co $(CVSCO_CALENDAR)
-else
-CHECKOUT_CALENDAR := true
-FASTUPDATE_CALENDAR := true
-endif
-
-
-# because some cygwin tools can't handle native dos-drive paths & vice-versa
-# force configure to use a relative path for --srcdir
-# need a better check for win32
-# and we need to get OBJDIR earlier
-ifdef MOZ_TOOLS
-_tmpobjdir := $(shell cygpath -u $(OBJDIR))
-_abs2rel := $(shell cygpath -w $(TOPSRCDIR)/build/unix/abs2rel.pl | sed -e 's|\\|/|g')
-_OBJ2SRCPATH := $(shell $(_abs2rel) $(TOPSRCDIR) $(_tmpobjdir))
-endif 
-
-#######################################################################
-# Rules
-# 
-
-# Print out any options loaded from mozconfig.
-all build checkout clean depend distclean export libs install realclean::
-	@if test -f .mozconfig.out; then \
-	  cat .mozconfig.out; \
-	  rm -f .mozconfig.out; \
-	else true; \
-	fi
-
-ifdef _IS_FIRST_CHECKOUT
-all:: checkout build
-else
-all:: checkout alldep
-endif
-
-# Windows equivalents
-pull_all: checkout
-build_all: build
-build_all_dep: alldep
-build_all_depend: alldep
-clobber clobber_all: clean
-pull_and_build_all: checkout alldep
-
-# Do everything from scratch
-everything: checkout clean build
-
-####################################
-# CVS checkout
-#
-checkout::
-#	@: Backup the last checkout log.
-	@if test -f $(CVSCO_LOGFILE) ; then \
-	  mv $(CVSCO_LOGFILE) $(CVSCO_LOGFILE).old; \
-	else true; \
-	fi
-ifdef RUN_AUTOCONF_LOCALLY
-	@echo "Removing local configures" ; \
-	cd $(ROOTDIR) && \
-	$(RM) -f mozilla/configure mozilla/nsprpub/configure \
-		mozilla/directory/c-sdk/configure
-endif
-	@echo "checkout start: "`date` | tee $(CVSCO_LOGFILE)
-	@echo '$(CVSCO) mozilla/client.mk mozilla/build/unix/modules.mk'; \
-        cd $(ROOTDIR) && \
-	$(CVSCO) mozilla/client.mk mozilla/build/unix/modules.mk
-	@cd $(ROOTDIR) && $(MAKE) -f mozilla/client.mk real_checkout
-
-real_checkout:
-#	@: Start the checkout. Split the output to the tty and a log file. \
-#	 : If it fails, touch an error file because "tee" hides the error.
-	@failed=.cvs-failed.tmp; rm -f $$failed*; \
-	cvs_co() { echo "$$@" ; \
-	  ("$$@" || touch $$failed) 2>&1 | tee -a $(CVSCO_LOGFILE) && \
-	  if test -f $$failed; then false; else true; fi; }; \
-	cvs_co $(CVSCO_NSPR) && \
-	cvs_co $(CVSCO_NSS) && \
-	cvs_co $(CVSCO_PSM) && \
-        cvs_co $(CVSCO_LDAPCSDK) && \
-        cvs_co $(CVSCO_ACCESSIBLE) && \
-        cvs_co $(CVSCO_GFX2) && \
-        cvs_co $(CVSCO_IMGLIB2) && \
-	$(CHECKOUT_CALENDAR) && \
-	$(CHECKOUT_LIBART) && \
-	cvs_co $(CVSCO_SEAMONKEY) && \
-	cvs_co $(CVSCO_NOSUBDIRS)
-	@echo "checkout finish: "`date` | tee -a $(CVSCO_LOGFILE)
-#	@: Check the log for conflicts. ;
-	@conflicts=`egrep "^C " $(CVSCO_LOGFILE)` ;\
-	if test "$$conflicts" ; then \
-	  echo "$(MAKE): *** Conflicts during checkout." ;\
-	  echo "$$conflicts" ;\
-	  echo "$(MAKE): Refer to $(CVSCO_LOGFILE) for full log." ;\
-	  false; \
-	else true; \
-	fi
-ifdef RUN_AUTOCONF_LOCALLY
-	@echo Generating configures using $(AUTOCONF) ; \
-	cd $(TOPSRCDIR) && $(AUTOCONF) && \
-	cd $(TOPSRCDIR)/nsprpub && $(AUTOCONF) && \
-	cd $(TOPSRCDIR)/directory/c-sdk && $(AUTOCONF)
-endif
-
-fast-update:
-#	@: Backup the last checkout log.
-	@if test -f $(CVSCO_LOGFILE) ; then \
-	  mv $(CVSCO_LOGFILE) $(CVSCO_LOGFILE).old; \
-	else true; \
-	fi
-ifdef RUN_AUTOCONF_LOCALLY
-	@echo "Removing local configures" ; \
-	cd $(ROOTDIR) && \
-	$(RM) -f mozilla/configure mozilla/nsprpub/configure \
-		mozilla/directory/c-sdk/configure
-endif
-	@echo "checkout start: "`date` | tee $(CVSCO_LOGFILE)
-	@echo '$(CVSCO) mozilla/client.mk mozilla/build/unix/modules.mk'; \
-        cd $(ROOTDIR) && \
-	$(CVSCO) mozilla/client.mk mozilla/build/unix/modules.mk
-	@cd $(TOPSRCDIR) && \
-	$(MAKE) -f client.mk real_fast-update
-
-real_fast-update:
-#	@: Start the update. Split the output to the tty and a log file. \
-#	 : If it fails, touch an error file because "tee" hides the error.
-	@failed=.fast_update-failed.tmp; rm -f $$failed*; \
-	fast_update() { (config/cvsco-fast-update.pl $$@ || touch $$failed) 2>&1 | tee -a $(CVSCO_LOGFILE) && \
-	  if test -f $$failed; then false; else true; fi; }; \
-	cvs_co() { echo "$$@" ; \
-	  ("$$@" || touch $$failed) 2>&1 | tee -a $(CVSCO_LOGFILE) && \
-	  if test -f $$failed; then false; else true; fi; }; \
-	fast_update $(CVSCO_NSPR) && \
-	cd $(ROOTDIR) && \
-	failed=mozilla/.fast_update-failed.tmp && \
-	cvs_co $(CVSCO_NSS) && \
-	failed=.fast_update-failed.tmp && \
-	cd mozilla && \
-	fast_update $(CVSCO_PSM) && \
-	fast_update $(CVSCO_LDAPCSDK) && \
-	fast_update $(CVSCO_ACCESSIBLE) && \
-	fast_update $(CVSCO_GFX2) && \
-	fast_update $(CVSCO_IMGLIB2) && \
-	$(FASTUPDATE_CALENDAR) && \
-	$(FASTUPDATE_LIBART) && \
-	fast_update $(CVSCO_SEAMONKEY) && \
-	fast_update $(CVSCO_NOSUBDIRS)
-	@echo "fast_update finish: "`date` | tee -a $(CVSCO_LOGFILE)
-#	@: Check the log for conflicts. ;
-	@conflicts=`egrep "^C " $(CVSCO_LOGFILE)` ;\
-	if test "$$conflicts" ; then \
-	  echo "$(MAKE): *** Conflicts during fast-update." ;\
-	  echo "$$conflicts" ;\
-	  echo "$(MAKE): Refer to $(CVSCO_LOGFILE) for full log." ;\
-	  false; \
-	else true; \
-	fi
-ifdef RUN_AUTOCONF_LOCALLY
-	@echo Generating configures using $(AUTOCONF) ; \
-	cd $(TOPSRCDIR) && $(AUTOCONF) && \
-	cd $(TOPSRCDIR)/nsprpub && $(AUTOCONF) && \
-	cd $(TOPSRCDIR)/directory/c-sdk && $(AUTOCONF)
-endif
-
-####################################
-# Web configure
-
-WEBCONFIG_FILE  := $(HOME)/.mozconfig
-
-MOZCONFIG2CONFIGURATOR := build/autoconf/mozconfig2configurator
-webconfig:
-	@cd $(TOPSRCDIR); \
-	url=`$(MOZCONFIG2CONFIGURATOR) $(TOPSRCDIR)`; \
-	echo Running mozilla with the following url: ;\
-	echo ;\
-	echo $$url ;\
-	mozilla -remote "openURL($$url)" || \
-	netscape -remote "openURL($$url)" || \
-	mozilla $$url || \
-	netscape $$url ;\
-	echo ;\
-	echo   1. Fill out the form on the browser. ;\
-	echo   2. Save the results to $(WEBCONFIG_FILE)
-
-#####################################################
-# First Checkout
-
-ifdef _IS_FIRST_CHECKOUT
-# First time, do build target in a new process to pick up new files.
-build::
-	$(MAKE) -f $(TOPSRCDIR)/client.mk build
-else
-
-#####################################################
-# After First Checkout
-
-
-####################################
-# Configure
-
-CONFIG_STATUS := $(wildcard $(OBJDIR)/config.status)
-CONFIG_CACHE  := $(wildcard $(OBJDIR)/config.cache)
-
-ifdef RUN_AUTOCONF_LOCALLY
-EXTRA_CONFIG_DEPS := \
-	$(TOPSRCDIR)/aclocal.m4 \
-	$(wildcard $(TOPSRCDIR)/build/autoconf/*.m4) \
-	$(NULL)
-
-$(TOPSRCDIR)/configure: $(TOPSRCDIR)/configure.in $(EXTRA_CONFIG_DEPS)
-	@echo Generating $@ using autoconf
-	cd $(TOPSRCDIR); $(AUTOCONF)
-endif
-
-CONFIG_STATUS_DEPS_L10N := $(wildcard $(TOPSRCDIR)/l10n/makefiles.all)
-
-CONFIG_STATUS_DEPS := \
-	$(TOPSRCDIR)/configure \
-	$(TOPSRCDIR)/allmakefiles.sh \
-	$(TOPSRCDIR)/.mozconfig.mk \
-	$(wildcard $(TOPSRCDIR)/nsprpub/configure) \
-	$(wildcard $(TOPSRCDIR)/directory/c-sdk/configure) \
-	$(wildcard $(TOPSRCDIR)/mailnews/makefiles) \
-	$(CONFIG_STATUS_DEPS_L10N) \
-	$(wildcard $(TOPSRCDIR)/themes/makefiles) \
-	$(NULL)
-
-# configure uses the program name to determine @srcdir@. Calling it without
-#   $(TOPSRCDIR) will set @srcdir@ to "."; otherwise, it is set to the full
-#   path of $(TOPSRCDIR).
-ifeq ($(TOPSRCDIR),$(OBJDIR))
-  CONFIGURE := ./configure
-else
-  CONFIGURE := $(TOPSRCDIR)/configure
-endif
-
-ifdef _OBJ2SRCPATH
-CONFIGURE_ARGS := --srcdir=$(_OBJ2SRCPATH) $(CONFIGURE_ARGS)
-endif
-
-$(OBJDIR)/Makefile $(OBJDIR)/config.status: $(CONFIG_STATUS_DEPS)
-	@if test ! -d $(OBJDIR); then $(MKDIR) $(OBJDIR); else true; fi
-	@echo cd $(OBJDIR);
-	@echo $(CONFIGURE) $(CONFIGURE_ARGS)
-	@cd $(OBJDIR) && $(CONFIGURE_ENV_ARGS) $(CONFIGURE) $(CONFIGURE_ARGS) \
-	  || ( echo "*** Fix above errors and then restart with\
-               \"$(MAKE) -f client.mk build\"" && exit 1 )
-	@touch $(OBJDIR)/Makefile
-
-ifdef CONFIG_STATUS
-$(OBJDIR)/config/autoconf.mk: $(TOPSRCDIR)/config/autoconf.mk.in
-	cd $(OBJDIR); \
-	  CONFIG_FILES=config/autoconf.mk ./config.status
-endif
-
-
-####################################
-# Depend
-
-depend:: $(OBJDIR)/Makefile $(OBJDIR)/config.status
-	$(MOZ_MAKE) export && $(MOZ_MAKE) depend
-
-####################################
-# Build it
-
-build::  $(OBJDIR)/Makefile $(OBJDIR)/config.status
-	$(MOZ_MAKE)
-
-####################################
-# Other targets
-
-# Pass these target onto the real build system
-install export libs clean realclean distclean alldep:: $(OBJDIR)/Makefile $(OBJDIR)/config.status
-	$(MOZ_MAKE) $@
-
-cleansrcdir:
-	@cd $(TOPSRCDIR); \
-        if [ -f webshell/embed/gtk/Makefile ]; then \
-          $(MAKE) -C webshell/embed/gtk distclean; \
-        fi; \
-	if [ -f Makefile ]; then \
-	  $(MAKE) distclean ; \
-	else \
-	  echo "Removing object files from srcdir..."; \
-	  rm -fr `find . -type d \( -name .deps -print -o -name CVS \
-	          -o -exec test ! -d {}/CVS \; \) -prune \
-	          -o \( -name '*.[ao]' -o -name '*.so' \) -type f -print`; \
-	   build/autoconf/clean-config.sh; \
-	fi;
-
-# (! IS_FIRST_CHECKOUT)
-endif
-
-.PHONY: checkout real_checkout depend build export libs alldep install clean realclean distclean cleansrcdir pull_all build_all clobber clobber_all pull_and_build_all everything

mozilla/js/js2/Makefile

@@ -0,0 +1,44 @@
+STLPORT = /usr/local/include/stlport
+
+CC = gcc
+CFLAGS = -g -ggdb -DDEBUG -DXP_UNIX -Wall -W -Wpointer-arith \
+	-Wbad-function-cast -Wstrict-prototypes -Wmissing-prototypes \
+	-Wno-non-virtual-dtor -I$(STLPORT)
+
+objs = 	hash.o \
+	icodegenerator.o \
+	interpreter.o \
+	js2.o \
+	jsmath.o \
+	jstypes.o \
+	numerics.o \
+	parser.o \
+	utilities.o \
+	world.o \
+	vmtypes.o \
+	debugger.o
+
+gc_path = ../../gc/boehm/
+
+libs =	gc.a -lstdc++ -lm
+
+%.o : %.cpp
+	$(CC) -c $(CFLAGS) $< -o $@
+
+js2: $(objs) gc.a
+	$(CC) -o $@ -ggdb $(objs) $(libs)
+
+gc.a:
+	(cd $(gc_path) ; ln -f -s Makefile.unix Makefile ; make gc.a)
+	ln -f -s $(gc_path)gc.a ./gc.a
+
+gctest: gc_allocator.o
+	$(CC) -o $@ -ggdb $^ $(libs)
+
+clean:
+	rm -f $(objs)
+
+depend:
+	gcc -MM *.cpp > dependencies
+
+include dependencies

mozilla/js/js2/cplusplustests/CPlusPlusTests.dsp

@@ -0,0 +1,111 @@
+# Microsoft Developer Studio Project File - Name="CPlusPlusTests" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=CPlusPlusTests - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "CPlusPlusTests.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "CPlusPlusTests.mak" CFG="CPlusPlusTests - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "CPlusPlusTests - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "CPlusPlusTests - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "CPlusPlusTests - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "CPlusPlusTests - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "CPlusPlusTests - Win32 Release"
+# Name "CPlusPlusTests - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\cplusplustests.cpp
+
+!IF  "$(CFG)" == "CPlusPlusTests - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "CPlusPlusTests - Win32 Debug"
+
+# ADD CPP /Ob1 /FR
+# SUBTRACT CPP /O<none> /YX
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

mozilla/js/js2/cplusplustests/CPlusPlusTests.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "CPlusPlusTests"=.\CPlusPlusTests.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

mozilla/js/js2/cplusplustests/cplusplustests.cpp

@@ -0,0 +1,129 @@
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <new>
+
+using namespace std;
+
+struct Arena {
+	const char *name;
+
+	Arena(const char *name): name(name) {}
+};
+
+
+void *operator new(size_t size, Arena &arena);
+void operator delete(void *p);
+
+void *operator new(size_t size, Arena &arena)
+{
+	void *p = malloc(size);
+	printf("Allocating %d bytes at %p using arena \"%s\"\n", size, p, arena.name);
+	return p;
+}
+
+#ifndef __MWERKS__
+void operator delete(void *p, Arena &arena)
+{
+	printf("Deleting object at %p using arena \"%s\"\n", p, arena.name);
+}
+#endif
+
+
+void operator delete(void *p)
+{
+	printf("Deleting object at %p\n", p);
+}
+
+
+struct C {
+	int n;
+
+	C(int n, bool bad = false);
+	~C();
+};
+
+struct Exception {
+	int num;
+
+	explicit Exception(int n): num(n) {}
+};
+
+
+C::C(int n, bool bad): n(n)
+{
+	printf("Constructing C #%d at %p\n", n, this);
+	if (bad) {
+		printf("Throwing %d; constructor aborted\n", n);
+		throw Exception(n);
+	}
+}
+
+C::~C()
+{
+	printf("Destroying C #%d at %p\n", n, this);
+}
+
+
+static void constructorTest1(int n, bool bad)
+{
+	try {
+		printf("Calling C(%d,%d)\n", n, (int)bad);
+		{
+			C c(n, bad);
+			printf("We have C #%d\n", c.n);
+		}
+		printf("C is out of scope\n");
+	} catch (Exception &e) {
+		printf("Caught exception %d\n", e.num);
+	}
+	printf("\n");
+}
+
+
+static void constructorTest2(int n, bool bad)
+{
+	try {
+		printf("Calling new C(%d,%d)\n", n, (int)bad);
+		{
+			C *c = new C(n, bad);
+			printf("We have C #%d\n", c->n);
+			delete c;
+		}
+		printf("C is out of scope\n");
+	} catch (Exception &e) {
+		printf("Caught exception %d\n", e.num);
+	}
+	printf("\n");
+}
+
+
+static void constructorTest3(int n, bool bad)
+{
+	try {
+		printf("Calling new(arena) C(%d,%d)\n", n, (int)bad);
+		{
+			Arena arena("My arena");
+			C *c = new(arena) C(n, bad);
+			printf("We have C #%d\n", c->n);
+		}
+		printf("C is out of scope\n");
+	} catch (Exception &e) {
+		printf("Caught exception %d\n", e.num);
+	}
+	printf("\n");
+}
+
+
+int main()
+{
+	printf("Beginning constructor tests\n\n");
+	constructorTest1(1, false);
+	constructorTest1(2, true);
+	constructorTest2(3, false);
+	constructorTest2(4, true);
+	constructorTest3(5, false);
+	constructorTest3(6, true);
+	printf("Ending constructor tests\n");
+	return 0;
+}

mozilla/js/js2/cpucfg.h

@@ -0,0 +1,191 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * 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 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifndef cpucfg_h
+#define cpucfg_h
+
+#define JS_HAVE_LONG_LONG
+
+#ifdef XP_MAC
+#undef  IS_LITTLE_ENDIAN
+#define IS_BIG_ENDIAN 1
+
+#define JS_BYTES_PER_BYTE   1L
+#define JS_BYTES_PER_SHORT  2L
+#define JS_BYTES_PER_INT    4L
+#define JS_BYTES_PER_INT64  8L
+#define JS_BYTES_PER_LONG   4L
+#define JS_BYTES_PER_FLOAT  4L
+#define JS_BYTES_PER_DOUBLE 8L
+#define JS_BYTES_PER_WORD   4L
+#define JS_BYTES_PER_DWORD  8L
+
+#define JS_BITS_PER_BYTE    8L
+#define JS_BITS_PER_SHORT   16L
+#define JS_BITS_PER_INT     32L
+#define JS_BITS_PER_INT64   64L
+#define JS_BITS_PER_LONG    32L
+#define JS_BITS_PER_FLOAT   32L
+#define JS_BITS_PER_DOUBLE  64L
+#define JS_BITS_PER_WORD    32L
+
+#define JS_BITS_PER_BYTE_LOG2   3L
+#define JS_BITS_PER_SHORT_LOG2  4L
+#define JS_BITS_PER_INT_LOG2    5L
+#define JS_BITS_PER_INT64_LOG2  6L
+#define JS_BITS_PER_LONG_LOG2   5L
+#define JS_BITS_PER_FLOAT_LOG2  5L
+#define JS_BITS_PER_DOUBLE_LOG2 6L
+#define JS_BITS_PER_WORD_LOG2   5L
+
+#define JS_ALIGN_OF_SHORT   2L
+#define JS_ALIGN_OF_INT     4L
+#define JS_ALIGN_OF_LONG    4L
+#define JS_ALIGN_OF_INT64   2L
+#define JS_ALIGN_OF_FLOAT   4L
+#define JS_ALIGN_OF_DOUBLE  4L
+#define JS_ALIGN_OF_POINTER 4L
+#define JS_ALIGN_OF_WORD    4L
+
+#define JS_BYTES_PER_WORD_LOG2   2L
+#define JS_BYTES_PER_DWORD_LOG2  3L
+#define PR_WORDS_PER_DWORD_LOG2  1L
+
+#elif defined(XP_PC)
+
+#ifdef _WIN32
+#define IS_LITTLE_ENDIAN 1
+#undef  IS_BIG_ENDIAN
+
+#define JS_BYTES_PER_BYTE   1L
+#define JS_BYTES_PER_SHORT  2L
+#define JS_BYTES_PER_INT    4L
+#define JS_BYTES_PER_INT64  8L
+#define JS_BYTES_PER_LONG   4L
+#define JS_BYTES_PER_FLOAT  4L
+#define JS_BYTES_PER_DOUBLE 8L
+#define JS_BYTES_PER_WORD   4L
+#define JS_BYTES_PER_DWORD  8L
+
+#define JS_BITS_PER_BYTE    8L
+#define JS_BITS_PER_SHORT   16L
+#define JS_BITS_PER_INT     32L
+#define JS_BITS_PER_INT64   64L
+#define JS_BITS_PER_LONG    32L
+#define JS_BITS_PER_FLOAT   32L
+#define JS_BITS_PER_DOUBLE  64L
+#define JS_BITS_PER_WORD    32L
+
+#define JS_BITS_PER_BYTE_LOG2   3L
+#define JS_BITS_PER_SHORT_LOG2  4L
+#define JS_BITS_PER_INT_LOG2    5L
+#define JS_BITS_PER_INT64_LOG2  6L
+#define JS_BITS_PER_LONG_LOG2   5L
+#define JS_BITS_PER_FLOAT_LOG2  5L
+#define JS_BITS_PER_DOUBLE_LOG2 6L
+#define JS_BITS_PER_WORD_LOG2   5L
+
+#define JS_ALIGN_OF_SHORT   2L
+#define JS_ALIGN_OF_INT     4L
+#define JS_ALIGN_OF_LONG    4L
+#define JS_ALIGN_OF_INT64   8L
+#define JS_ALIGN_OF_FLOAT   4L
+#define JS_ALIGN_OF_DOUBLE  4L
+#define JS_ALIGN_OF_POINTER 4L
+#define JS_ALIGN_OF_WORD    4L
+
+#define JS_BYTES_PER_WORD_LOG2   2L
+#define JS_BYTES_PER_DWORD_LOG2  3L
+#define PR_WORDS_PER_DWORD_LOG2  1L
+#endif /* _WIN32 */
+
+#if defined(_WINDOWS) && !defined(_WIN32) /* WIN16 */
+#define IS_LITTLE_ENDIAN 1
+#undef  IS_BIG_ENDIAN
+
+#define JS_BYTES_PER_BYTE   1L
+#define JS_BYTES_PER_SHORT  2L
+#define JS_BYTES_PER_INT    2L
+#define JS_BYTES_PER_INT64  8L
+#define JS_BYTES_PER_LONG   4L
+#define JS_BYTES_PER_FLOAT  4L
+#define JS_BYTES_PER_DOUBLE 8L
+#define JS_BYTES_PER_WORD   4L
+#define JS_BYTES_PER_DWORD  8L
+
+#define JS_BITS_PER_BYTE    8L
+#define JS_BITS_PER_SHORT   16L
+#define JS_BITS_PER_INT     16L
+#define JS_BITS_PER_INT64   64L
+#define JS_BITS_PER_LONG    32L
+#define JS_BITS_PER_FLOAT   32L
+#define JS_BITS_PER_DOUBLE  64L
+#define JS_BITS_PER_WORD    32L
+
+#define JS_BITS_PER_BYTE_LOG2   3L
+#define JS_BITS_PER_SHORT_LOG2  4L
+#define JS_BITS_PER_INT_LOG2    4L
+#define JS_BITS_PER_INT64_LOG2  6L
+#define JS_BITS_PER_LONG_LOG2   5L
+#define JS_BITS_PER_FLOAT_LOG2  5L
+#define JS_BITS_PER_DOUBLE_LOG2 6L
+#define JS_BITS_PER_WORD_LOG2   5L
+
+#define JS_ALIGN_OF_SHORT   2L
+#define JS_ALIGN_OF_INT     2L
+#define JS_ALIGN_OF_LONG    2L
+#define JS_ALIGN_OF_INT64   2L
+#define JS_ALIGN_OF_FLOAT   2L
+#define JS_ALIGN_OF_DOUBLE  2L
+#define JS_ALIGN_OF_POINTER 2L
+#define JS_ALIGN_OF_WORD    2L
+
+#define JS_BYTES_PER_WORD_LOG2   2L
+#define JS_BYTES_PER_DWORD_LOG2  3L
+#define PR_WORDS_PER_DWORD_LOG2  1L
+#endif /* defined(_WINDOWS) && !defined(_WIN32) */
+
+#elif defined(XP_UNIX) || defined(XP_BEOS)
+
+#error "This file is supposed to be auto-generated on UNIX platforms, but the"
+#error "static version for Mac and Windows platforms is being used."
+#error "Something's probably wrong with paths/headers/dependencies/Makefiles."
+
+#else
+
+#error "Must define one of XP_MAC, XP_PC, or XP_UNIX"
+
+#endif
+
+#endif

mozilla/js/js2/debugger.cpp

@@ -0,0 +1,466 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#include "world.h"
+#include "debugger.h"
+
+#include <string>
+#include <ctype.h>
+#include <assert.h>
+
+namespace JavaScript {
+namespace Debugger {
+
+    using namespace Interpreter;
+
+    /* keep in sync with list in debugger.h */
+    static const char *shell_cmds[][3] = {
+        {"assemble", "", 0},
+        {"ambiguous", "", "Test command for ambiguous command detection"},
+        {"ambiguous2", "", "Test command for ambiguous command detection"},
+        {"continue", "", "Continue execution until complete."},
+        {"dissassemble", "[start_pc] [end_pc]", "Dissassemble entire module, or subset of module."},
+        {"exit", "", 0},
+        {"help", "", "Display this message."},
+        {"istep", "", "Execute the current opcode and stop."},
+        {"let", "", "Set a debugger environment variable."},
+        {"print", "", 0},
+        {"register", "", "(nyi) Show the value of a single register or all registers, or set the value of a single register."},
+        {"step", "", "Execute the current JS statement and stop."},
+        {0, 0} /* sentry */
+    };
+
+    enum ShellVariable {
+        TRACE_SOURCE,
+        TRACE_ICODE,
+        VARIABLE_COUNT
+    };
+    
+    static const char *shell_vars[][3] = {
+        {"tracesource", "", "(bool) Show JS source while executing."},
+        {"traceicode", " ", "(bool) Show opcodes while executing."},
+        {0, 0} /* sentry */
+    };
+    
+    /* return true if str2 starts with/is str1
+     * XXX ignore case */
+    static bool
+    startsWith (const String &str1, const String &str2)
+    {
+        uint n;
+        size_t m = str1.size();
+
+        if (m > str2.size())
+            return false;
+
+        for (n = 0; n < m; ++n)
+            if (str1[n] != str2[n])
+                return false;
+        
+        return true;
+    }
+
+
+    /**
+     * locate the best match for |partial| in the command list |list|.
+     * if no matches are found, return |length|, if multiple matches are found,
+     * return |length| plus the number of ambiguous matches
+     */
+    static uint32
+    matchElement (const String &partial, const char *list[][3], size_t length)
+    {
+        uint32 ambig_matches = 0;
+        uint32 match = length;
+        
+        for (uint32 i = 0; i < length ; ++i)
+        {
+            String possibleMatch (widenCString(list[i][0]));
+            if (startsWith(partial, possibleMatch))
+            {
+                if (partial.size() == possibleMatch.size())
+                {
+                    /* exact match */
+                    ambig_matches = 0;
+                    return i;
+                }
+                else if (match == COMMAND_COUNT) /* no match yet */
+                    match = i;
+                else
+                    ++ambig_matches; /* something already matched, 
+                                      * ambiguous command */
+            }
+            
+        }
+
+        if (ambig_matches == 0)
+            return match;
+        else
+            return length + ambig_matches;
+        
+    }    
+
+    static void
+    showHelp(Formatter &out)
+    {
+        int i;
+        
+        out << "JavaScript 2.0 Debugger Help...\n\n";
+        
+        for (i = 0; shell_cmds[i][0] != 0; i++)
+        {
+            out << "Command : " << shell_cmds[i][0] << " " << 
+                shell_cmds[i][1] << "\n";
+
+            if (shell_cmds[i][2])
+                out << "Help    : " << shell_cmds[i][2] << "\n";
+            else
+                out << "Help    : (probably) Not Implemented.\n";
+        }
+    }
+
+    static uint32
+    getClosestSourcePosForPC (Context *cx, InstructionIterator pc)
+    {
+        ICodeModule *iCode = cx->getICode();
+        
+        if (iCode->mInstructionMap->begin() == iCode->mInstructionMap->end())
+            return NotABanana;
+            /*NOT_REACHED ("Instruction map is empty, waah.");*/
+
+        InstructionMap::iterator pos_iter =
+            iCode->mInstructionMap->upper_bound (pc - iCode->its_iCode->begin());
+        if (pos_iter != iCode->mInstructionMap->begin())
+            --pos_iter;
+    
+        return pos_iter->second;
+    }
+        
+    void
+    Shell::showSourceAtPC (Context *cx, InstructionIterator pc)
+    {
+        if (!mResolveFileCallback)
+        {
+            mErr << "Source not available (Debugger was improperly initialized.)\n";
+            return;
+        }
+
+        ICodeModule *iCode = cx->getICode();
+
+        String fn = iCode->getFileName();
+        const Reader *reader = mResolveFileCallback(fn);
+        if (!reader)
+        {
+            mErr << "Source not available.\n";
+            return;
+        }
+        
+        uint32 pos = getClosestSourcePosForPC(cx, pc);
+        if (pos == NotABanana)
+        {
+            mErr << "Map is empty, cannot display source.\n";
+            return;
+        }
+            
+        uint32 lineNum = reader->posToLineNum (pos);
+        const char16 *lineBegin, *lineEnd;
+
+        uint32 lineStartPos = reader->getLine (lineNum, lineBegin, lineEnd);
+        String sourceLine (lineBegin, lineEnd);
+        
+        mOut << fn << ":" << lineNum << " " << sourceLine << "\n";
+
+        uint padding = fn.length() + (uint32)(lineNum / 10) + 3;
+        uint i;        
+
+        for (i = 0; i < padding; i++)
+            mOut << " ";
+        
+        padding = (pos - lineStartPos);
+        for (i = 0; i < padding; i++)
+            mOut << ".";
+        
+        mOut << "^\n";
+        
+    }
+
+    void
+    Shell::showOpAtPC(Context* cx, InstructionIterator pc)
+    {
+        ICodeModule *iCode = cx->getICode();
+
+        if ((pc < iCode->its_iCode->begin()) ||
+            (pc >= iCode->its_iCode->end()))
+        {
+            mErr << "PC Out Of Range.";
+            return;
+        }
+
+        JSValues &registers = cx->getRegisters();
+
+        printFormat(mOut, "trace [%02u:%04u]: ",
+                    iCode->mID, (pc - iCode->its_iCode->begin()));
+        Instruction* i = *pc;
+        stdOut << *i;
+        if (i->op() != BRANCH && i->count() > 0) {
+            mOut << " [";
+            i->printOperands(stdOut, registers);
+            mOut << "]\n";
+        } else {
+            mOut << '\n';
+        }
+    }    
+
+    void
+    Shell::listen(Context* cx, Context::Event event)
+    {
+        InstructionIterator pc = cx->getPC();
+        
+        if (mTraceSource)
+            showSourceAtPC (cx, pc);
+        if (mTraceICode)
+            showOpAtPC (cx, pc);
+            
+        if (!(mStopMask & event))
+            return;
+
+        if ((mLastCommand == STEP) && (mLastICodeID == cx->getICode()->mID) &&
+            (mLastSourcePos == getClosestSourcePosForPC (cx, cx->getPC())))
+            /* we're in source-step mode, and the source position hasn't
+             * changed yet */
+            return;
+
+        if (!mTraceSource && !mTraceICode)
+            showSourceAtPC (cx, pc);
+                
+        static String lastLine(widenCString("help\n"));
+        String line;
+        LineReader reader(mIn);
+
+        do {
+            stdOut << "jsd";
+            if (mLastCommand != COMMAND_COUNT)
+                stdOut << " (" << shell_cmds[mLastCommand][0] << ") ";
+            stdOut << "> ";
+        
+            reader.readLine(line);
+
+            if (line[0] == uni::lf)
+                line = lastLine;
+            else
+                lastLine = line;
+
+        } while (doCommand(cx, line));
+    }
+
+
+    /**
+     * lex and execute the debugger command in |source|, return true if the
+     * command does not require the script being debugged to continue (eg, ask
+     * for more debugger input.)
+     */
+    bool
+    Shell::doCommand (Interpreter::Context *cx, const String &source)
+    {
+        Lexer lex (mWorld, source, widenCString("debugger console"), 0);
+        const String *cmd;
+        uint32 match;
+        bool rv = true;
+        
+        const Token &t = lex.get(true);
+
+        if (t.hasKind(Token::identifier))
+            cmd = &(t.getIdentifier());
+        else
+        {
+            mErr << "you idiot.\n";
+            return true;
+        }        
+
+        match = matchElement (*cmd, shell_cmds, (size_t)COMMAND_COUNT);
+        
+        if (match <= (uint32)COMMAND_COUNT)
+        {
+            switch ((ShellCommand)match)
+            {
+                case COMMAND_COUNT:
+                    mErr << "Unknown command '" << *cmd << "'.\n";
+                    break;
+
+                case AMBIGUOUS:
+                case AMBIGUOUS2:
+                    mErr << "I pity the foogoo.\n";
+                    break;
+
+                case CONTINUE:
+                    mStopMask &= (Context::EV_ALL ^ Context::EV_STEP);
+                    rv = false;
+                    break;
+
+                case DISSASSEMBLE:
+                    mOut << *cx->getICode();
+                    break;    
+
+                case HELP:
+                    showHelp (mOut);
+                    break;
+
+                case PRINT:
+                    doPrint (cx, lex);
+                    break;
+                    
+                case STEP:
+                    mStopMask |= Context::EV_STEP;
+                    rv = false;
+                    break;
+                    
+                case LET:
+                    doSetVariable (lex);
+                    break;
+
+                default:
+                    mErr << "Input '" << *cmd << "' matched unimplemented " <<
+                        "command '" << shell_cmds[match][0] << "'.\n";
+                    break;
+                    
+            }
+
+            mLastSourcePos = getClosestSourcePosForPC (cx, cx->getPC());
+            mLastICodeID = cx->getICode()->mID;
+            mLastCommand = (ShellCommand)match;
+
+        } else
+            mErr << "Ambiguous command '" << *cmd << "', " <<
+                (match - (uint32)COMMAND_COUNT + 1) << " similar commands.\n";
+
+        return rv;        
+    }
+
+    void
+    Shell::doSetVariable (Lexer &lex)
+    {
+        uint32 match;
+        const String *varname;        
+        const Token *t = &(lex.get(true));
+
+        if (t->hasKind(Token::identifier))
+            varname = &(t->getIdentifier());
+        else
+        {
+            mErr << "invalid variable name.\n";
+            return;
+        }        
+
+        match = matchElement (*varname, shell_vars, (size_t)VARIABLE_COUNT);
+
+        if (match <= (uint32)VARIABLE_COUNT)
+            switch ((ShellVariable)match)
+            {
+                case VARIABLE_COUNT:
+                    mErr << "Unknown variable '" << *varname << "'.\n";
+                    break;
+                    
+                case TRACE_SOURCE:
+                    t = &(lex.get(true));
+                    if (t->hasKind(Token::assignment))
+                        t = &(lex.get(true)); /* optional = */
+
+                    if (t->hasKind(Token::True))
+                        mTraceSource = true;
+                    else if (t->hasKind(Token::False))
+                        mTraceSource = false;
+                    else
+                        goto badval;
+                    break;
+
+                case TRACE_ICODE:
+                    t = &(lex.get(true));
+                    if (t->hasKind(Token::assignment))
+                        t = &(lex.get(true)); /* optional = */
+
+                    if (t->hasKind(Token::True))
+                        mTraceICode = true;
+                    else if (t->hasKind(Token::False))
+                        mTraceICode = false;
+                    else
+                        goto badval;
+                    break;
+
+                default:
+                    mErr << "Variable '" << *varname <<
+                        "' matched unimplemented variable '" << 
+                        shell_vars[match][0] << "'.\n";
+            }
+        else
+            mErr << "Ambiguous variable '" << *varname << "', " <<
+                (match - (uint32)COMMAND_COUNT + 1) << " similar variables.\n";
+        
+        return;
+        
+    badval:
+        mErr << "Invalid value for variable '" <<
+            shell_vars[(ShellVariable)match][0] << "'\n";
+
+    }
+    
+    void
+    Shell::doPrint (Context *, Lexer &lex)
+    {
+        const Token *t = &(lex.get(true));
+
+        if (!(t->hasKind(Token::identifier)))
+        {
+            mErr << "Invalid register name.\n";
+            return;
+        }
+
+/*
+        const StringAtom *name = &(t->getIdentifier());
+        
+        VariableMap::iterator i = ((cx->getICode())->itsVariables)->find(*name);
+//        if (i)
+            mOut << (*i).first << " = " << (*i).second << "\n";
+//        else
+//            mOut << "No " << *name << " defined.\n";
+  
+*/      
+    }
+    
+            
+            
+    
+} /* namespace Debugger */
+} /* namespace JavaScript */
+
+                    
+            
+        

mozilla/js/js2/debugger.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+/* this is all vapor, don't take it to serious yet */
+
+#ifndef debugger_h
+#define debugger_h
+
+#include "utilities.h"
+#include "interpreter.h"
+
+#include <stdio.h>
+
+namespace JavaScript {
+namespace Debugger {
+
+    using namespace Interpreter;
+
+    class Shell;
+    
+    typedef const Reader *ResolveFileCallback (const String &fileName);
+    typedef bool DebuggerCommandCallback (Shell &debugger, const Lexer &lex);
+
+    class Breakpoint {
+    public:
+        /* representation of a breakpoint */
+        void set();
+        void clear();
+        bool getState();
+        InstructionIterator getPC();
+    };    
+
+    struct DebuggerCommand
+    {
+        DebuggerCommand(String aName, String aParamDesc, String aShortHelp,
+                        String aLongHelp = widenCString("No more help available."),
+                        DebuggerCommandCallback *aCommandFunction = 0) 
+            : mName(aName), mParamDesc(aParamDesc), mShortHelp(aShortHelp),
+              mLongHelp(aLongHelp), mCommandFunction(aCommandFunction) {}
+
+        String mName;
+        String mParamDesc;
+        String mShortHelp;
+        String mLongHelp;
+        DebuggerCommandCallback *mCommandFunction;
+    };
+
+    /* keep in sync with list in debugger.cpp */
+    enum ShellCommand {
+        ASSEMBLE,
+        AMBIGUOUS,
+        AMBIGUOUS2,
+        CONTINUE,
+        DISSASSEMBLE,
+        EXIT,
+        HELP,
+        ISTEP,
+        LET,
+        PRINT,
+        REGISTER,
+        STEP,
+        COMMAND_COUNT
+    };
+        
+    class Shell : public Context::Listener {
+    public:        
+        Shell (World &aWorld, FILE *aIn, Formatter &aOut, Formatter &aErr,
+               ResolveFileCallback *aCallback = 0) :
+            mWorld(aWorld), mIn(aIn), mOut(aOut), mErr(aErr),
+            mResolveFileCallback(aCallback), mStopMask(Context::EV_DEBUG),
+            mTraceSource(false), mTraceICode(false), mLastSourcePos(0),
+            mLastICodeID(NotABanana), mLastCommand(COMMAND_COUNT)
+        {
+        }
+
+        ~Shell ()
+        {
+        }
+        
+        ResolveFileCallback
+            *setResolveFileCallback (ResolveFileCallback  *aCallback)
+        {
+            ResolveFileCallback *rv = mResolveFileCallback;
+            mResolveFileCallback = aCallback;
+            return rv;
+        }
+        
+        void listen(Context *context, Context::Event event);
+        
+        /**
+         * install on a context
+         */
+        bool attachToContext (Context *aContext)
+        {
+            aContext->addListener (this);
+            return true;
+        }
+        
+        /**
+         * detach an icdebugger from a context
+         */
+        bool detachFromContext (Context *aContext)
+        {
+            aContext->removeListener (this);
+            return true;
+        }
+
+        FILE *getIStream() { return mIn; }
+        Formatter &getOStream() { return mOut; }
+        Formatter &getEStream() { return mErr; }
+
+    private:
+        bool doCommand (Context *cx, const String &aSource);
+        void doSetVariable (Lexer &lex);
+        void doPrint (Context *cx, Lexer &lex);
+
+        void showOpAtPC(Context* cx, InstructionIterator pc);
+        void showSourceAtPC(Context* cx, InstructionIterator pc);
+        
+        World &mWorld;
+        FILE *mIn;
+        Formatter &mOut, &mErr;
+        ResolveFileCallback *mResolveFileCallback;
+        uint32 mStopMask;
+        bool mTraceSource, mTraceICode;
+        uint32 mLastSourcePos, mLastICodeID;
+        ShellCommand mLastCommand;
+    };    
+
+} /* namespace Debugger */
+} /* namespace JavaScript */
+
+#endif /* debugger_h */

mozilla/js/js2/dependencies

@@ -0,0 +1,26 @@
+debugger.o: debugger.cpp world.h utilities.h systemtypes.h hash.h \
+ parser.h debugger.h interpreter.h jstypes.h gc_allocator.h vmtypes.h \
+ numerics.h jsclasses.h icode.h icodegenerator.h
+gc_allocator.o: gc_allocator.cpp gc_allocator.h gc_container.h
+hash.o: hash.cpp hash.h utilities.h systemtypes.h
+icodegenerator.o: icodegenerator.cpp numerics.h utilities.h \
+ systemtypes.h world.h hash.h parser.h vmtypes.h jstypes.h \
+ gc_allocator.h jsclasses.h icode.h icodegenerator.h interpreter.h
+interpreter.o: interpreter.cpp interpreter.h utilities.h systemtypes.h \
+ jstypes.h gc_allocator.h vmtypes.h numerics.h jsclasses.h world.h \
+ hash.h parser.h icode.h icodegenerator.h jsmath.h
+js2.o: js2.cpp world.h utilities.h systemtypes.h hash.h parser.h \
+ interpreter.h jstypes.h gc_allocator.h vmtypes.h numerics.h \
+ jsclasses.h icode.h icodegenerator.h debugger.h
+jsmath.o: jsmath.cpp jsmath.h jstypes.h utilities.h systemtypes.h \
+ gc_allocator.h
+jstypes.o: jstypes.cpp jstypes.h utilities.h systemtypes.h \
+ gc_allocator.h jsclasses.h numerics.h icodegenerator.h parser.h \
+ vmtypes.h world.h hash.h icode.h
+numerics.o: numerics.cpp numerics.h utilities.h systemtypes.h
+parser.o: parser.cpp numerics.h utilities.h systemtypes.h parser.h \
+ world.h hash.h
+utilities.o: utilities.cpp utilities.h systemtypes.h
+vmtypes.o: vmtypes.cpp utilities.h systemtypes.h vmtypes.h numerics.h \
+ jstypes.h gc_allocator.h jsclasses.h world.h hash.h parser.h icode.h
+world.o: world.cpp world.h utilities.h systemtypes.h hash.h parser.h

mozilla/js/js2/gc_allocator.cpp

@@ -0,0 +1,150 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// The Initial Developer of the Original Code is Netscape
+// Communications Corporation.  Portions created by Netscape are
+// Copyright (C) 2000 Netscape Communications Corporation. All
+// Rights Reserved.
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+
+#include "gc_allocator.h"
+#include "gc_container.h"
+
+/*
+namespace JavaScript {
+
+template <class T>
+typename gc_allocator<T>::pointer
+gc_allocator<T>::allocate(gc_allocator<T>::size_type n, const void*)
+{
+	return static_cast<pointer>(GC_malloc(n*sizeof(T)));
+}
+
+template <class T>
+void gc_allocator<T>::deallocate(gc_allocator<T>::pointer ptr, gc_allocator<T>::size_type)
+{
+	// this can really be a NO-OP with the GC.
+	// ::GC_free(static_cast<void*>(ptr));
+}
+
+}
+ */
+
+// test driver for standalone GC development.
+
+namespace JS = JavaScript;
+
+template <class T>
+void* operator new(std::size_t, const JS::gc_allocator<T>& alloc)
+{
+	return alloc.allocate(1);
+}
+
+/**
+ * Define a C++ class that is garbage collectable, and wants to have its destructor
+ * called when it is finalized.
+ */
+class A {
+public:
+	typedef JS::gc_traits_finalizable<A> traits;
+	typedef JS::gc_allocator<A, traits> allocator;
+	friend struct traits;
+	
+	static int instances;
+	
+	void* operator new(std::size_t)
+	{
+		return allocator::allocate(1);
+	}
+	
+	A()
+	{
+		++instances;
+		std::cout << "A::A() here." << std::endl;
+	}
+
+protected:	
+	~A()
+	{
+		--instances;
+		std::cout << "A::~A() here." << std::endl;
+	}
+
+private:
+	// void operator delete(void*) {}
+};
+
+int A::instances = 0;
+
+int main(int /* argc */, char* /* argv[] */)
+{
+	using namespace std;
+	using namespace JS;
+
+	cout << "testing the GC allocator." << endl;
+
+#ifdef XP_MAC
+	// allocate a string, using the GC, and owned by an auto_ptr, that knows how to correctly destroy the string.
+	typedef gc_container<char>::string char_string;
+	typedef gc_allocator<char_string> char_string_alloc;
+	auto_ptr<char_string, char_string_alloc> ptr(new(char_string_alloc()) char_string("This is a garbage collectable string."));
+	const char_string& str = *ptr;
+	cout << str << endl;
+#endif
+	
+	// question, how can we partially evaluate a template?
+	// can we say, typedef template <class T> vector<typename T>.
+	// typedef vector<int, gc_allocator<int> > int_vector;
+	typedef gc_container<int>::vector int_vector;
+	
+	// generate 1000 random values.
+	int_vector values;
+	for (int i = 0; i < 1000; ++i) {
+		int value = rand() % 32767;
+		values.push_back(value);
+		// allocate a random amount of garbage.
+		if (!GC_malloc(static_cast<size_t>(value)))
+			cerr << "GC_malloc failed." << endl;
+		// allocate an object that has a finalizer to call its destructor.
+		A* a = new A();
+	}
+
+	// run a collection.
+	// gc_allocator<void>::collect();
+	GC_gcollect();
+
+	// print out instance count.
+	cout << "A::instances = " << A::instances << endl;
+	
+	// sort the values.
+	sort(values.begin(), values.end());
+	
+	// print the values.
+	int_vector::iterator iter = values.begin(), last = values.end();
+	cout << *iter++;
+	while (iter < last)
+		cout << ' ' << *iter++;
+	cout << endl;
+
+#ifdef XP_MAC	
+	// finally, print the string again.
+	cout << str << endl;
+#endif
+
+	return 0;
+}

mozilla/js/js2/gc_allocator.h

@@ -0,0 +1,178 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// The Initial Developer of the Original Code is Netscape
+// Communications Corporation.  Portions created by Netscape are
+// Copyright (C) 2000 Netscape Communications Corporation. All
+// Rights Reserved.
+
+#ifndef gc_allocator_h
+#define gc_allocator_h
+
+#include <memory>
+
+#ifndef _WIN32 // Microsoft VC6 bug: standard identifiers should be in std namespace
+using std::size_t;
+using std::ptrdiff_t;
+#endif
+
+namespace JavaScript {
+    extern "C" {
+        void* GC_malloc(size_t bytes);
+        void* GC_malloc_atomic(size_t bytes);
+        void GC_free(void* ptr);
+        void GC_gcollect(void);
+
+        typedef void (*GC_finalization_proc) (void* obj, void* client_data);
+        void GC_register_finalizer(void* obj, GC_finalization_proc proc, void* client_data,
+                                   GC_finalization_proc *old_proc, void* *old_client_data);
+    }
+
+    #if 0 && !defined(XP_MAC)
+    // for platforms where GC doesn't exist yet.
+    inline void* GC_malloc(size_t bytes) { return ::operator new(bytes); }
+    inline void* GC_malloc_atomic(size_t bytes) { return ::operator new(bytes); }
+    inline void GC_free(void* ptr) { operator delete(ptr); }
+    inline void GC_gcollect() {}
+    inline void GC_register_finalizer(void* obj, GC_finalization_proc proc, void* client_data,
+                                      GC_finalization_proc *old_proc, void* *old_client_data) {}
+    #endif
+    
+	/**
+	 * General case:  memory for type must be allocated as a conservatively
+	 * scanned block of memory.
+	 */
+	template <class T> struct gc_traits {
+		static T* allocate(size_t n) { return static_cast<T*>(GC_malloc(n * sizeof(T))); }
+	};
+	
+	/**
+	 * Specializations for blocks of atomic types:  the macro define_atomic_type(_type)
+	 * specializes gc_traits<T> for types that need not be scanned by the
+	 * GC. Implementors are free to define other types as atomic, if they are
+	 * guaranteed not to contain pointers.
+	 */
+	#define define_atomic_type(_type) 											\
+	template <> struct gc_traits<_type> {										\
+		static _type* allocate(size_t n)										\
+		{																		\
+			return static_cast<_type*>(GC_malloc_atomic(n * sizeof(_type)));	\
+		}																		\
+	};
+	
+	define_atomic_type(char)
+	define_atomic_type(unsigned char)
+	define_atomic_type(short)
+	define_atomic_type(unsigned short)
+	define_atomic_type(int)
+	define_atomic_type(unsigned int)
+	define_atomic_type(long)
+	define_atomic_type(unsigned long)
+	define_atomic_type(float)
+	define_atomic_type(double)
+	
+	#undef define_atomic_type
+	
+	/**
+	 * Traits for classes that need to have their destructor called
+	 * when reclaimed by the garbage collector.
+	 */
+	template <class T> struct gc_traits_finalizable {
+		static void finalizer(void* obj, void* client_data)
+		{
+			T* t = static_cast<T*>(obj);
+			size_t n = reinterpret_cast<size_t>(client_data);
+			for (size_t i = 0; i < n; ++i)
+				t[i].~T();
+		}
+		
+		static T* allocate(size_t n)
+		{
+			T* t = gc_traits<T>::allocate(n);
+			GC_finalization_proc old_proc; void* old_client_data;
+			GC_register_finalizer(t, &finalizer, reinterpret_cast<void*>(n), &old_proc, &old_client_data);
+			return t;
+		}
+	};
+	
+	/**
+	 * An allocator that can be used to allocate objects in the garbage collected heap.
+	 */
+	template <class T, class traits = gc_traits<T> > class gc_allocator {
+	public:
+		typedef T value_type;
+		typedef size_t size_type;
+		typedef ptrdiff_t difference_type;
+		typedef T *pointer;
+		typedef const T *const_pointer;
+		typedef T &reference;
+		typedef const T &const_reference;
+		
+		gc_allocator() {}
+		template<typename U, typename UTraits> gc_allocator(const gc_allocator<U, UTraits>&) {}
+		// ~gc_allocator() {}
+
+		static pointer address(reference r) { return &r; }
+		static const_pointer address(const_reference r) { return &r; }
+				
+		static pointer allocate(size_type n, const void* /* hint */ = 0) { return traits::allocate(n); }
+		static void deallocate(pointer, size_type) {}
+		
+		static void construct(pointer p, const T &val) { new(p) T(val);}
+		static void destroy(pointer p) { p->~T(); }
+		
+#if defined(__GNUC__) || defined(_WIN32)
+        static size_type max_size() { return size_type(-1) / sizeof(T); }
+#else
+		static size_type max_size() { return std::numeric_limits<size_type>::max() / sizeof(T); }
+#endif
+
+		template<class U> struct rebind { typedef gc_allocator<U> other; };
+
+#ifdef _WIN32
+		// raw byte allocator used on some platforms (grrr).
+		typedef char _Char[1];
+		static char* _Charalloc(size_type n) { return (char*) rebind<_Char>::other::allocate(n); }
+
+        // funky operator required for calling basic_string<T> constructor (grrr).
+        template<typename U, typename UTraits> int operator==(const gc_allocator<U, UTraits>&) { return 0; }
+#endif
+
+		// void* deallocate used on some platforms (grrr).
+		static void deallocate(void*, size_type) {}
+
+		static void collect() { GC_gcollect(); }
+	};
+
+    /**
+     * Generic base class for objects allocated using a gc_allocator. How they are allocated
+     * can be controlled by specializing gc_traits for the specific class.
+     */
+    template <typename T> class gc_object {
+    public:
+        void* operator new(size_t) { return gc_allocator<T>::allocate(1, 0); }
+        void operator delete(void* /* ptr */) {}
+    };
+
+    /**
+     * Simpler base class for classes that have no need to specialize allocation behavior.
+     */
+    class gc_base {
+    public:
+        void* operator new(size_t n) { return GC_malloc(n); }
+        void operator delete(void*) {}
+    };
+}
+
+#endif /* gc_allocator_h */

mozilla/js/js2/gc_container.h

@@ -0,0 +1,71 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// The Initial Developer of the Original Code is Netscape
+// Communications Corporation.  Portions created by Netscape are
+// Copyright (C) 2000 Netscape Communications Corporation. All
+// Rights Reserved.
+
+#ifndef gc_container_h
+#define gc_container_h
+
+#include "gc_allocator.h"
+
+#include <list>
+#include <vector>
+#include <string>
+
+#define LIST std::list
+#define VECTOR std::vector
+
+#if defined(__GNUC__)
+// grr, what kind of standard is this?
+#define STRING basic_string
+#define CHAR_TRAITS string_char_traits
+#else
+#define STRING std::basic_string
+#define CHAR_TRAITS std::char_traits
+#endif
+
+namespace JavaScript {
+	/**
+	 * Rebind some of the basic container types to use a GC_allocator.
+	 * What I really want is something more general, something like:
+	 * template <typename Container, typename T> class gc_rebind {
+	 *   typedef typename Container<T, gc_allocator<T> > other;
+	 * };
+	 * But I can't figure out how to do that with C++ templates.
+	 */
+	template <class T> struct gc_container {
+		typedef typename LIST<T, gc_allocator<T> > list;
+		typedef typename VECTOR<T, gc_allocator<T> > vector;
+		typedef typename STRING<T, CHAR_TRAITS<T>, gc_allocator<T> > string;
+	};
+
+	/**
+	 * But, it's pretty easy to do with macros:
+	 */
+	#define GC_CONTAINER(container, type) container<T, gc_allocator<T> >
+	
+	/*
+	// this gives an "unimplemented C++ feature" error using CWPro5.
+	// maybe someday.
+	template <template<class, class> typename Container, typename T>
+	struct gc_rebind {
+		typedef typename Container<T, gc_allocator<T> > container;
+	};
+	*/
+}
+
+#endif /* gc_container_h */

mozilla/js/js2/hash.cpp

@@ -0,0 +1,173 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// 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.
+
+#include "hash.h"
+#include <new>
+namespace JS = JavaScript;
+
+
+//
+// Hash Codes
+//
+
+
+// General-purpose null-terminated C string hash function
+JS::HashNumber JS::hashString(const char *s)
+{
+    HashNumber h = 0;
+    uchar ch;
+
+    while ((ch = (uchar)*s++) != 0)
+        h = (h >> 28) ^ (h << 4) ^ ch;
+    return h;
+}
+
+
+// General-purpose String hash function
+JS::HashNumber JS::hashString(const String &s)
+{
+    HashNumber h = 0;
+    String::const_iterator p = s.begin();
+    String::size_type n = s.size();
+
+    if (n < 16)
+		// Hash every character in a short string.
+		while (n--)
+		    h = (h >> 28) ^ (h << 4) ^ *p++;
+    else
+		// Sample a la java.lang.String.hash().
+		for (String::size_type m = n / 8; n >= m; p += m, n -= m)
+		    h = (h >> 28) ^ (h << 4) ^ *p;
+    return h;
+}
+
+
+//
+// Hash Tables
+//
+
+
+const uint minLgNBuckets = 4;
+
+
+JS::GenericHashTableIterator::GenericHashTableIterator(GenericHashTable &ht):
+		ht(ht), entry(0), nextBucket(ht.buckets)
+{
+	DEBUG_ONLY(++ht.nReferences);
+	operator++();
+}
+
+
+
+JS::GenericHashTableIterator &
+JS::GenericHashTableIterator::operator++()
+{
+	GenericHashEntry *e = entry;
+
+	if (e) {
+		backpointer = &e->next;
+		e = e->next;
+	}
+	if (!e) {
+		GenericHashEntry **const bucketsEnd = ht.bucketsEnd;
+		GenericHashEntry **bucket = nextBucket;
+
+		while (bucket != bucketsEnd) {
+			e = *bucket++;
+			if (e) {
+				backpointer = bucket-1;
+				break;
+			}
+		}
+		nextBucket = bucket;
+	}
+	entry = e;
+	return *this;
+}
+
+
+JS::GenericHashTable::GenericHashTable(uint32 nEntriesDefault):
+	nEntries(0)
+{
+	DEBUG_ONLY(nReferences = 0);
+
+	uint lgNBuckets = ceilingLog2(nEntriesDefault);
+	if (lgNBuckets < minLgNBuckets)
+		lgNBuckets = minLgNBuckets;
+	defaultLgNBuckets = lgNBuckets;
+
+	recomputeMinMaxNEntries(lgNBuckets);
+	uint32 nBuckets = JS_BIT(lgNBuckets);
+	buckets = new GenericHashEntry*[nBuckets];
+	// No exceptions after this point unless buckets is deleted.
+
+	bucketsEnd = buckets + nBuckets;
+	zero(buckets, bucketsEnd);
+}
+
+
+// Initialize shift, minNEntries, and maxNEntries based on the lg2 of the
+// number of buckets.
+void JS::GenericHashTable::recomputeMinMaxNEntries(uint lgNBuckets)
+{
+	uint32 nBuckets = JS_BIT(lgNBuckets);
+	shift = 32 - lgNBuckets;
+	maxNEntries = nBuckets;							// Maximum ratio is 100%
+	minNEntries = lgNBuckets <= defaultLgNBuckets ? 0 : 3*(nBuckets>>3);	// Minimum ratio is 37.5%
+}
+
+
+// Rehash the table.  This method cannot throw out-of-memory exceptions, so it is
+// safe to call from a destructor.
+void JS::GenericHashTable::rehash()
+{
+	uint32 newLgNBuckets = ceilingLog2(nEntries);
+	if (newLgNBuckets < defaultLgNBuckets)
+		newLgNBuckets = defaultLgNBuckets;
+	uint32 newNBuckets = JS_BIT(newLgNBuckets);
+	try {
+		GenericHashEntry **newBuckets = new GenericHashEntry*[newNBuckets];
+		// No exceptions after this point.
+
+		GenericHashEntry **newBucketsEnd = newBuckets + newNBuckets;
+		zero(newBuckets, newBucketsEnd);
+		recomputeMinMaxNEntries(newLgNBuckets);
+		GenericHashEntry **be = bucketsEnd;
+		for (GenericHashEntry **b = buckets; b != be; b++) {
+			GenericHashEntry *e = *b;
+			while (e) {
+				GenericHashEntry *next = e->next;
+				// Place e in the new set of buckets.
+				GenericHashEntry **nb = newBuckets + (e->keyHash*goldenRatio >> shift);
+				e->next = *nb;
+				*nb = e;
+				e = next;
+			}
+		}
+		delete[] buckets;
+		buckets = newBuckets;
+		bucketsEnd = newBucketsEnd;
+	} catch (std::bad_alloc) {
+		// Out of memory.  Ignore the error and just relax the resizing boundaries.
+		if (buckets + JS_BIT(newLgNBuckets) > bucketsEnd)
+			maxNEntries >>= 1;
+		else
+			minNEntries <<= 1;
+	}
+}

mozilla/js/js2/hash.h

@@ -0,0 +1,373 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// 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.
+
+#ifndef hash_h
+#define hash_h
+
+#include "utilities.h"
+
+namespace JavaScript {
+
+
+//
+// Hash Codes
+//
+
+	typedef uint32 HashNumber;
+
+	HashNumber hashString(const char *s);
+	HashNumber hashString(const String &s);
+
+
+	template<class Key>
+	struct Hash {
+		HashNumber operator()(Key key) const;
+	};
+
+	template<class Key>
+	inline HashNumber Hash<Key>::operator()(Key key) const
+	{
+		return hashString(key);
+	}
+
+
+	const HashNumber goldenRatio = 0x9E3779B9U;
+
+
+//
+// Private
+//
+
+	// Base class for user-defined hash entries.
+	// private
+	class GenericHashEntry {
+	  public:
+	    GenericHashEntry *next;         // Link to next entry in the same bucket
+	    const HashNumber keyHash;       // This entry's hash value
+
+	  protected:
+		explicit GenericHashEntry(HashNumber keyHash): next(0), keyHash(keyHash) {}
+
+	    friend class GenericHashTable;
+	};
+
+
+	// private
+	class GenericHashTableIterator;
+	class GenericHashTable {
+	  protected:
+	    GenericHashEntry **buckets;		// Vector of hash buckets
+	    GenericHashEntry **bucketsEnd;	// Pointer past end of vector of hash buckets
+	    uint defaultLgNBuckets;			// lg2 of minimum number of buckets for which to size the table
+	    uint32 nEntries;				// Number of entries in table
+	    uint32 minNEntries;				// Minimum number of entries without rehashing
+	    uint32 maxNEntries;				// Maximum number of entries without rehashing
+	    uint32 shift;					// 32 - lg2(number of buckets)
+	  #ifdef DEBUG
+	  public:
+	    uint32 nReferences;				// Number of iterators and references currently pointing to this hash table
+	  #endif
+
+	  public:
+		explicit GenericHashTable(uint32 nEntriesDefault);
+		~GenericHashTable() {
+		  #ifndef _WIN32
+			ASSERT(nReferences == 0);
+		  #endif
+			delete[] buckets;
+		}
+
+		void recomputeMinMaxNEntries(uint lgNBuckets);
+		void rehash();
+		void maybeGrow() {if (nEntries > maxNEntries) rehash();}
+		void maybeShrink() {if (nEntries < minNEntries) rehash();}
+		
+		friend class GenericHashTableIterator;
+
+		typedef GenericHashTableIterator Iterator;
+	};
+
+	// This ought to be GenericHashTable::Iterator, but this doesn't work due to a
+	// Microsoft VC6 bug.
+	class GenericHashTableIterator {
+	  protected:
+		GenericHashTable &ht;			// Hash table being iterated
+		GenericHashEntry *entry;		// Current entry; nil if done
+		GenericHashEntry **backpointer;	// Pointer to pointer to current entry
+		GenericHashEntry **nextBucket;	// Next bucket; pointer past end of vector of hash buckets if done
+	  public:
+		explicit GenericHashTableIterator(GenericHashTable &ht);
+		~GenericHashTableIterator() {ht.maybeShrink(); DEBUG_ONLY(--ht.nReferences);}
+
+		operator bool() const {return entry != 0;}	// Return true if there are entries left.
+		GenericHashTableIterator &operator++();
+	};
+
+
+//
+// Hash Tables
+//
+
+	template<class Data, class Key, class H = Hash<Key> >
+	class HashTable: private GenericHashTable {
+		H hasher;						// Hash function
+
+		struct Entry: public GenericHashEntry {
+			Data data;
+			
+			Entry(HashNumber keyHash, Key key): GenericHashEntry(keyHash), data(key) {}
+			template<class Value>
+			Entry(HashNumber keyHash, Key key, Value value): GenericHashEntry(keyHash), data(key, value) {}
+		};
+
+	  public:
+		class Reference {
+#ifdef _WIN32 // Microsoft VC6 bug: friend declarations to inner classes don't work
+		  public:
+#endif
+			Entry *entry;						// Current entry; nil if done
+			GenericHashEntry **backpointer;		// Pointer to pointer to current entry
+			const HashNumber keyHash;			// This entry's key's hash value
+		  #ifdef DEBUG
+			GenericHashTable *ht;				// Hash table to which this Reference points
+		  #endif
+
+		  public:
+#ifndef _WIN32
+			Reference(HashTable &ht, Key key);	// Search for an entry with the given key.
+#else // Microsoft VC6 bug: VC6 doesn't allow this to be defined outside the class
+			Reference(HashTable &ht, Key key): keyHash(ht.hasher(key)) {
+			#ifdef DEBUG
+				Reference::ht = &ht;
+				++ht.nReferences;
+			#endif
+				HashNumber kh = keyHash;
+				HashNumber h = kh*goldenRatio >> ht.shift;
+				GenericHashEntry **bp = ht.buckets + h;
+				Entry *e;
+
+				while ((e = static_cast<Entry *>(*bp)) != 0 && !(e->keyHash == kh && e->data == key))
+					bp = &e->next;
+				entry = e;
+				backpointer = bp;
+			}
+#endif
+		  private:
+		    Reference(const Reference&);		// No copy constructor
+		    void operator=(const Reference&);	// No assignment operator
+		  public:
+		  #if defined(DEBUG) && !defined(_WIN32)
+			~Reference() {if (ht) --ht->nReferences;}
+		  #endif
+			
+			operator bool() const {return entry != 0;}	// Return true if an entry was found.
+			Data &operator*() const {ASSERT(entry); return entry->data;}	// Return the data of the entry that was found.
+			
+			friend class HashTable;
+		};
+
+		class Iterator: public GenericHashTableIterator {
+		  public:
+			explicit Iterator(HashTable &ht): GenericHashTableIterator(ht) {}
+		  private:
+		    Iterator(const Iterator&);			// No copy constructor
+		    void operator=(const Iterator&);	// No assignment operator
+		  public:
+
+			// Go to next entry.
+			Iterator &operator++() {return *static_cast<Iterator*>(&GenericHashTableIterator::operator++());}
+			Data &operator*() const {ASSERT(entry); return static_cast<Entry *>(entry)->data;}	// Return current entry's data.
+			void erase();
+		};
+
+		HashTable(uint32 nEntriesDefault = 0, const H &hasher = H()): GenericHashTable(nEntriesDefault), hasher(hasher) {}
+		~HashTable();
+
+		template<class Value> Data &insert(Reference &r, Key key, Value value);
+		Data &insert(Reference &r, Key key);
+		Data &insert(Key key);
+		void erase(Reference &r);
+		void erase(Key key);
+		Data *operator[](Key key);
+		
+		friend class Reference;
+		friend class Iterator;
+
+#ifndef _WIN32
+		template<class Value> Data &insert(Key key, Value value);
+#else // Microsoft VC6 bug: VC6 doesn't allow this to be defined outside the class
+		template<class Value> Data &insert(Key key, Value value) {
+			Reference r(*this, key);
+			if (r)
+				return *r = value;
+			else
+				return insert(r, key, value);
+		}
+#endif
+	};
+
+
+//
+// Implementation
+//
+
+	template<class Data, class Key, class H>
+	HashTable<Data, Key, H>::~HashTable()
+	{
+		GenericHashEntry **be = bucketsEnd;
+		for (GenericHashEntry **b = buckets; b != be; b++) {
+			Entry *e = static_cast<Entry *>(*b);
+			while (e) {
+				Entry *next = static_cast<Entry *>(e->next);
+				delete e;
+				e = next;
+			}
+		}
+	}
+
+
+#ifndef _WIN32
+	template<class Data, class Key, class H>
+	HashTable<Data, Key, H>::Reference::Reference(HashTable &ht, Key key):
+		keyHash(ht.hasher(key))
+	{
+	#ifdef DEBUG
+		Reference::ht = &ht;
+		++ht.nReferences;
+	#endif
+		HashNumber kh = keyHash;
+		HashNumber h = kh*goldenRatio >> ht.shift;
+		GenericHashEntry **bp = ht.buckets + h;
+		Entry *e;
+
+		while ((e = static_cast<Entry *>(*bp)) != 0 && !(e->keyHash == kh && e->data == key))
+			bp = &e->next;
+		entry = e;
+		backpointer = bp;
+	}
+
+
+	// Insert the given key/value pair into the hash table.  Reference must
+	// be the result of an unsuccessful search for that key in the table.
+	// The reference is not valid after this method is called.
+	// Return a reference to the new entry's value.
+	template<class Data, class Key, class H> template<class Value>
+	inline Data &HashTable<Data, Key, H>::insert(Reference &r, Key key, Value value)
+	{
+		ASSERT(r.ht == this && !r.entry);
+		Entry *e = new Entry(r.keyHash, key, value);
+		*r.backpointer = e;
+		++nEntries;
+		maybeGrow();
+	#ifdef DEBUG
+		--r.ht->nReferences;
+		r.ht = 0;
+	#endif
+		return e->data;
+	}
+#endif
+
+	// Same as above but without a Value argument.
+	template<class Data, class Key, class H>
+	inline Data &HashTable<Data, Key, H>::insert(Reference &r, Key key)
+	{
+		ASSERT(r.ht == this && !r.entry);
+		Entry *e = new Entry(r.keyHash, key);
+		*r.backpointer = e;
+		++nEntries;
+		maybeGrow();
+	#ifdef DEBUG
+		--r.ht->nReferences;
+		r.ht = 0;
+	#endif
+		return e->data;
+	}
+
+
+
+	// Insert the given key/value pair into the hash table.  If an entry with a
+	// matching key already exists, replace that entry's value.
+	// Return a reference to the new entry's value.
+#ifndef _WIN32 // Microsoft VC6 bug: VC6 doesn't allow this to be defined outside the class
+	template<class Data, class Key, class H> template<class Value>
+	Data &HashTable<Data, Key, H>::insert(Key key, Value value)
+	{
+		Reference r(*this, key);
+		if (r)
+			return *r = value;
+		else
+			return insert(r, key, value);
+	}
+#endif
+
+	// Same as above but without a Value argument.
+	template<class Data, class Key, class H>
+	Data &HashTable<Data, Key, H>::insert(Key key)
+	{
+		Reference r(*this, key);
+		if (r)
+			return *r;
+		else
+			return insert(r, key);
+	}
+
+
+	// Reference r must point to an existing entry.  Delete that entry.
+	// The reference is not valid after this method is called.
+	template<class Data, class Key, class H>
+	inline void HashTable<Data, Key, H>::erase(Reference &r)
+	{
+		Entry *e = r.entry;
+		ASSERT(r.ht == this && e);
+		*r.backpointer = e->next;
+		--nEntries;
+		delete e;
+	#ifdef DEBUG
+		--r.ht->nReferences;
+		r.ht = 0;
+	#endif
+		maybeShrink();
+	}
+
+
+	// Remove the hash table entry, if any, matching the given key.
+	template<class Data, class Key, class H>
+	void HashTable<Data, Key, H>::erase(Key key)
+	{
+		Reference r(*this, key);
+		if (r)
+			erase(r);
+	}
+
+
+	// Return a pointer to the value of the hash table entry matching the given key.
+	// Return nil if no entry matches.
+	template<class Data, class Key, class H>
+	Data *HashTable<Data, Key, H>::operator[](Key key)
+	{
+		Reference r(*this, key);
+		if (r)
+			return &*r;
+		else
+			return 0;
+	}
+
+}
+
+#endif

mozilla/js/js2/icodegenerator.h

@@ -0,0 +1,306 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifndef icodegenerator_h
+#define icodegenerator_h
+
+#include <vector>
+#include <stack>
+
+#include "utilities.h"
+#include "parser.h"
+#include "vmtypes.h"
+#include "jsclasses.h"
+
+
+namespace JavaScript {
+namespace ICG {
+    
+    using namespace VM;
+    using namespace JSTypes;
+    using namespace JSClasses;
+    
+    typedef std::map<String, TypedRegister, std::less<String> > VariableList;
+    typedef std::map<uint32, uint32, std::less<uint32> > InstructionMap;
+   
+
+    class ICodeModule {
+    public:
+        ICodeModule(InstructionStream *iCode, VariableList *variables,
+                    uint32 maxRegister, uint32 maxParameter,
+                    InstructionMap *instructionMap) :
+            its_iCode(iCode), itsVariables(variables),
+            itsParameterCount(maxParameter), itsMaxRegister(maxRegister),
+            mID(++sMaxID), mInstructionMap(instructionMap) { }
+        ~ICodeModule()
+        {
+            delete its_iCode;
+            delete itsVariables;
+            delete mInstructionMap;
+        }
+
+        Formatter& print(Formatter& f);
+        void setFileName (String aFileName) { mFileName = aFileName; }
+        String getFileName () { return mFileName; }
+        
+        InstructionStream *its_iCode;
+        VariableList *itsVariables;
+        uint32 itsParameterCount;
+        uint32 itsMaxRegister;
+        uint32 mID;
+        InstructionMap *mInstructionMap;
+        String mFileName;
+
+        static uint32 sMaxID;
+        
+    };
+
+    typedef std::vector<const StringAtom *> LabelSet;
+    class LabelEntry {
+    public:
+        LabelEntry(LabelSet *labelSet, Label *breakLabel) 
+            : labelSet(labelSet), breakLabel(breakLabel), continueLabel(NULL) { }
+        LabelEntry(LabelSet *labelSet, Label *breakLabel, Label *continueLabel) 
+            : labelSet(labelSet), breakLabel(breakLabel), continueLabel(continueLabel) { }
+
+        bool containsLabel(const StringAtom *label);
+
+        LabelSet *labelSet;
+        Label *breakLabel;
+        Label *continueLabel;
+    };
+    typedef std::vector<LabelEntry *> LabelStack;
+
+    Formatter& operator<<(Formatter &f, ICodeModule &i);
+
+    /****************************************************************/
+    
+    // An ICodeGenerator provides the interface between the parser and the
+    // interpreter. The parser constructs one of these for each
+    // function/script, adds statements and expressions to it and then
+    // converts it into an ICodeModule, ready for execution.
+    
+    class ICodeGenerator {
+    public:
+        typedef enum { kNoFlags = 0, kIsTopLevel = 0x01, kIsStaticMethod = 0x02, kIsWithinWith = 0x04 } ICodeGeneratorFlags;
+    private:
+        InstructionStream *iCode;
+        bool iCodeOwner;
+        LabelList labels;
+        
+        Register mTopRegister;              // highest (currently) alloacated register
+        uint32   mParameterCount;           // number of parameters declared for the function
+                                            // these must come before any variables declared.
+        TypedRegister mExceptionRegister;   // reserved to carry the exception object.
+        VariableList *variableList;         // name|register pair for each variable
+
+        World *mWorld;                      // used to register strings
+        JSScope *mGlobal;                   // the scope for compiling within
+        LabelStack mLabelStack;             // stack of LabelEntry objects, one per nested looping construct
+                                            // maps source position to instruction index
+        InstructionMap *mInstructionMap;
+
+        JSClass *mClass;                    // enclosing class when generating code for methods
+        ICodeGeneratorFlags mFlags;         // assorted flags
+
+        std::vector<bool> mPermanentRegister;
+
+        Register getTempRegister() 
+        { 
+            while (mTopRegister < mPermanentRegister.size())
+                if (!mPermanentRegister[mTopRegister]) 
+                    return mTopRegister++;
+                else
+                    ++mTopRegister;
+            mPermanentRegister.resize(mTopRegister + 1);
+            mPermanentRegister[mTopRegister] = false;
+            return mTopRegister++;
+        }
+
+        void resetTopRegister() { mTopRegister = mParameterCount; }
+        void resetStatement()   { resetTopRegister(); }
+
+        TypedRegister allocateRegister(const StringAtom& name, JSType *type);
+
+        void setRegisterForVariable(const StringAtom& name, TypedRegister r) { (*variableList)[name] = r; }
+
+        JSType *findType(const StringAtom& typeName);
+
+
+
+
+
+
+        void setLabel(Label *label);
+        
+        void jsr(Label *label)                  { iCode->push_back(new Jsr(label)); }
+        void rts()                              { iCode->push_back(new Rts()); }
+        void branch(Label *label);
+        GenericBranch *branchTrue(Label *label, TypedRegister condition);
+        GenericBranch *branchFalse(Label *label, TypedRegister condition);
+        
+        void beginTry(Label *catchLabel, Label *finallyLabel)
+                                                { iCode->push_back(new Tryin(catchLabel, finallyLabel)); }
+        void endTry()                           { iCode->push_back(new Tryout()); }
+
+        void beginWith(TypedRegister obj)       { iCode->push_back(new Within(obj)); }
+        void endWith()                          { iCode->push_back(new Without()); }
+        
+
+
+        void startStatement(uint32 pos)         { (*mInstructionMap)[iCode->size()] = pos; }
+
+        ICodeOp mapExprNodeToICodeOp(ExprNode::Kind kind);
+
+
+        bool isTopLevel()       { return (mFlags & kIsTopLevel) != 0; }
+        bool isWithinWith()     { return (mFlags & kIsWithinWith) != 0; }
+        bool isStaticMethod()   { return (mFlags & kIsStaticMethod) != 0; }
+
+        void setFlag(uint32 flag, bool v) { mFlags = (ICodeGeneratorFlags)((v) ? mFlags | flag : mFlags & ~flag); }
+
+
+        typedef enum {Var, Property, Slot, Static, Constructor, Name, Method} LValueKind;
+
+        LValueKind resolveIdentifier(const StringAtom &name, TypedRegister &v, uint32 &slotIndex);
+        TypedRegister handleIdentifier(IdentifierExprNode *p, ExprNode::Kind use, ICodeOp xcrementOp, TypedRegister ret, RegisterList *args);
+        TypedRegister handleDot(BinaryExprNode *b, ExprNode::Kind use, ICodeOp xcrementOp, TypedRegister ret, RegisterList *args);
+        ICodeModule *genFunction(FunctionStmtNode *f, bool isConstructor, JSClass *superClass);
+    
+    public:
+
+        ICodeGenerator(World *world, JSScope *global, JSClass *aClass = NULL, ICodeGeneratorFlags flags = kIsTopLevel);
+        
+        ~ICodeGenerator()
+        {
+            if (iCodeOwner) {
+                delete iCode;
+                delete mInstructionMap;
+            }
+        }
+                
+        ICodeModule *complete();
+
+        TypedRegister genExpr(ExprNode *p, 
+                                bool needBoolValueInBranch = false, 
+                                Label *trueBranch = NULL, 
+                                Label *falseBranch = NULL);
+        TypedRegister genStmt(StmtNode *p, LabelSet *currentLabelSet = NULL);
+
+        void returnStmt(TypedRegister r);
+        void returnStmt();
+        void throwStmt(TypedRegister r)         { iCode->push_back(new Throw(r)); }
+        void debuggerStmt()                     { iCode->push_back(new Debugger()); }
+
+        TypedRegister allocateVariable(const StringAtom& name);
+        TypedRegister allocateVariable(const StringAtom& name, const StringAtom& typeName);
+
+        TypedRegister findVariable(const StringAtom& name)
+        {
+            VariableList::iterator i = variableList->find(name);
+            return (i == variableList->end()) ? TypedRegister(NotARegister, &None_Type) : (*i).second;
+        }
+        
+        TypedRegister allocateParameter(const StringAtom& name)         { mParameterCount++; return allocateRegister(name, &Any_Type); }
+        TypedRegister allocateParameter(const StringAtom& name, const StringAtom& typeName) 
+                                                                        { mParameterCount++; return allocateRegister(name, findType(typeName)); }
+        TypedRegister allocateParameter(const StringAtom& name, JSType *type) 
+                                                                        { mParameterCount++; return allocateRegister(name, type); }
+        
+        Formatter& print(Formatter& f);
+        
+        TypedRegister op(ICodeOp op, TypedRegister source);
+        TypedRegister op(ICodeOp op, TypedRegister source1, TypedRegister source2);
+        TypedRegister binaryOp(ICodeOp op, TypedRegister source1, TypedRegister source2);
+        TypedRegister call(TypedRegister base, TypedRegister target, RegisterList *args);
+        TypedRegister getMethod(TypedRegister thisArg, uint32 slotIndex);
+
+        void move(TypedRegister destination, TypedRegister source);
+        TypedRegister logicalNot(TypedRegister source);
+        TypedRegister test(TypedRegister source);
+        
+        TypedRegister loadBoolean(bool value);
+        TypedRegister loadImmediate(double value);
+        TypedRegister loadString(const String &value);
+        TypedRegister loadString(const StringAtom &name);
+                
+        TypedRegister newObject(TypedRegister constructor);
+        TypedRegister newArray();
+        TypedRegister newFunction(ICodeModule *icm);
+        TypedRegister newClass(JSClass *clazz);
+
+        TypedRegister cast(TypedRegister arg, JSType *toType);
+        
+        TypedRegister super();
+        TypedRegister loadName(const StringAtom &name, JSType *t = &Any_Type);
+        void saveName(const StringAtom &name, TypedRegister value);
+        TypedRegister nameXcr(const StringAtom &name, ICodeOp op);
+       
+        TypedRegister deleteProperty(TypedRegister base, const StringAtom &name);
+        TypedRegister getProperty(TypedRegister base, const StringAtom &name);
+        void setProperty(TypedRegister base, const StringAtom &name, TypedRegister value);
+        TypedRegister propertyXcr(TypedRegister base, const StringAtom &name, ICodeOp op);
+        
+        TypedRegister getStatic(JSClass *base, const String &name);
+        void setStatic(JSClass *base, const StringAtom &name, TypedRegister value);
+        TypedRegister staticXcr(JSClass *base, const StringAtom &name, ICodeOp op);
+        
+        TypedRegister getElement(TypedRegister base, TypedRegister index);
+        void setElement(TypedRegister base, TypedRegister index, TypedRegister value);
+        TypedRegister elementXcr(TypedRegister base, TypedRegister index, ICodeOp op);
+
+        TypedRegister getSlot(TypedRegister base, uint32 slot);
+        void setSlot(TypedRegister base, uint32 slot, TypedRegister value);
+        TypedRegister slotXcr(TypedRegister base, uint32 slot, ICodeOp op);
+
+        TypedRegister varXcr(TypedRegister var, ICodeOp op);
+        
+        InstructionStream *getICode()   { return iCode; }
+        
+        Label *getLabel();
+
+    };
+
+    Formatter& operator<<(Formatter &f, ICodeGenerator &i);
+    Formatter& operator<<(Formatter &f, ICodeModule &i);
+    /*
+      std::ostream &operator<<(std::ostream &s, ICodeGenerator &i);
+      std::ostream &operator<<(std::ostream &s, StringAtom &str);
+    */
+
+
+
+} /* namespace IGC */
+} /* namespace JavaScript */
+
+#endif /* icodegenerator_h */

mozilla/js/js2/interpreter.h

@@ -0,0 +1,113 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// The Initial Developer of the Original Code is Netscape
+// Communications Corporation.  Portions created by Netscape are
+// Copyright (C) 2000 Netscape Communications Corporation. All
+// Rights Reserved.
+
+#ifndef interpreter_h
+#define interpreter_h
+
+#include "utilities.h"
+#include "jstypes.h"
+#include "vmtypes.h"
+#include "icodegenerator.h"
+#include "gc_allocator.h"
+
+namespace JavaScript {
+namespace Interpreter {
+
+    using namespace ICG;
+    using namespace JSTypes;
+
+    struct Activation;
+    
+    struct Linkage;
+
+    class Context : public gc_base {
+        void initContext();
+    public:
+        explicit Context(World& world, JSScope* aGlobal)
+            : mWorld(world), mGlobal(aGlobal), mLinkage(0), mActivation(0), mHasOperatorsPackageLoaded(false) { initContext(); }
+
+        World& getWorld()           { return mWorld; }
+        JSScope* getGlobalObject()  { return mGlobal; }
+        InstructionIterator getPC() { return mPC; }
+        
+        JSValues& getRegisters();
+        ICodeModule* getICode();
+
+        enum Event {
+            EV_NONE     = 0x0000,
+            EV_STEP     = 0x0001,
+            EV_THROW    = 0x0002,
+            EV_DEBUG    = 0x0004,
+            EV_ALL      = 0xffff
+        };
+    
+        class Listener {
+        public:
+            virtual void listen(Context *context, Event event) = 0;
+        };
+    
+        void addListener(Listener* listener);
+        void removeListener(Listener* listener);
+    
+        class Frame {
+        public:
+            virtual Frame* getNext() = 0;
+            virtual void getState(InstructionIterator& pc, JSValues*& registers,
+                                  ICodeModule*& iCode) = 0;
+        };
+    
+        Frame* getFrames();
+
+        JSValue interpret(ICodeModule* iCode, const JSValues& args);
+        void doCall(JSFunction *target, Instruction *pc);
+
+        ICodeModule* compile(const String &source);
+        ICodeModule* genCode(StmtNode *p, const String &fileName);
+        JSValue readEvalFile(FILE* in, const String& fileName);
+
+        void addBinaryOperator(BinaryOperator::BinaryOp op, BinaryOperator *fn) { mBinaryOperators[op].push_back(fn); }
+        const JSValue findBinaryOverride(JSValue &operand1, JSValue &operand2, BinaryOperator::BinaryOp op);
+
+
+        bool hasOperatorsPackageLoaded()    { return mHasOperatorsPackageLoaded; }
+
+    private:
+        void broadcast(Event event);
+        void initOperatorsPackage();
+
+    private:
+        World& mWorld;
+        JSScope* mGlobal;
+        Linkage* mLinkage;
+        typedef std::vector<Listener*, gc_allocator<Listener*> > ListenerList;
+        typedef ListenerList::iterator ListenerIterator;
+        ListenerList mListeners;
+        Activation* mActivation;
+        bool mHasOperatorsPackageLoaded;
+
+        InstructionIterator mPC;
+        
+        BinaryOperatorList mBinaryOperators[BinaryOperator::BinaryOperatorCount];
+
+    }; /* class Context */
+
+} /* namespace Interpreter */
+} /* namespace JavaScript */
+
+#endif /* interpreter_h */

mozilla/js/js2/java/ArithmeticNode.java

@@ -0,0 +1,33 @@
+class ArithmeticNode extends BinaryNode {
+
+    ArithmeticNode(String aOp, ExpressionNode aLeft, ExpressionNode aRight)
+    {
+        super(aOp, aLeft, aRight);
+    }
+
+    JSValue eval(Environment theEnv)
+    {
+        JSValue lV = left.eval(theEnv);
+        JSValue rV = right.eval(theEnv);
+
+        if (op == "+")
+            return lV.add(theEnv, rV);
+        else
+        if (op == "-")
+            return lV.subtract(theEnv, rV);
+        else
+        if (op == "*")
+            return lV.multiply(theEnv, rV);
+        else
+        if (op == "/")
+            return lV.divide(theEnv, rV);
+        else
+        if (op == "%")
+            return lV.remainder(theEnv, rV);
+        else {
+            System.out.println("missing arithmetic op " + op);
+            return null;
+        }
+    }
+
+}

mozilla/js/js2/java/AssignmentNode.java

@@ -0,0 +1,16 @@
+class AssignmentNode extends BinaryNode {
+    
+    AssignmentNode(String aOp, ExpressionNode aLeft, ExpressionNode aRight)
+    {
+        super(aOp, aLeft, aRight);
+    }
+
+    JSValue eval(Environment theEnv)
+    {
+        JSReference lV = left.evalLHS(theEnv);
+        JSValue rV = right.eval(theEnv);
+        
+        return lV.base.putProp(theEnv, lV.id, rV);
+    }
+
+}

mozilla/js/js2/java/BinaryNode.java

@@ -0,0 +1,72 @@
+class BinaryNode extends ExpressionNode {
+    
+    BinaryNode(String aOp, ExpressionNode aLeft, ExpressionNode aRight)
+    {
+        left = aLeft;
+        right = aRight;
+        op = aOp;
+    }
+
+    JSReference evalLHS(Environment theEnv)
+    {
+        if (op == ".") {
+            JSValue lV = left.eval(theEnv);
+            JSString id;
+            if (right instanceof JSIdentifier)
+                id = (JSString)right;
+            else
+                id = right.eval(theEnv).toJSString(theEnv);
+            return new JSReference(lV, id);
+        }
+        else
+            throw new RuntimeException("bad lValue operator " + op);
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        JSValue lV = left.eval(theEnv);
+        JSValue rV = right.eval(theEnv);
+        
+        if (op == ".")
+            return lV.getProp(theEnv, rV.toJSString(theEnv));
+        else
+        if (op == "()")
+            return lV.call(theEnv, rV);
+        else
+        if (op == ",")
+            return JSValueList.buildList(lV, rV);
+        else {
+            System.out.println("missing binary op " + op);
+            return null;
+        }
+        
+    }
+    
+    String print(String indent)
+    {
+        StringBuffer result = new StringBuffer(indent);
+        result.append(getClass().toString());
+        result.append(" ");
+        result.append(op);
+        result.append("\n");
+        indent += "    ";
+        if (left == null) {
+            result.append(indent);
+            result.append("null\n");
+        }
+        else
+            result.append(left.print(indent));
+        if (right == null) {
+            result.append(indent);
+            result.append("null\n");
+        }
+        else
+            result.append(right.print(indent));
+        return result.toString();
+    }   
+    
+    protected ExpressionNode left;
+    protected ExpressionNode right;
+    protected String op;
+    
+}

mozilla/js/js2/java/BitwiseNode.java

@@ -0,0 +1,36 @@
+class BitwiseNode extends BinaryNode {
+
+    BitwiseNode(String aOp, ExpressionNode aLeft, ExpressionNode aRight)
+    {
+        super(aOp, aLeft, aRight);
+    }
+
+    JSValue eval(Environment theEnv)
+    {
+        JSInteger lV = left.eval(theEnv).toJSInteger(theEnv);
+        JSValue rV = right.eval(theEnv);
+
+        if (op == "&")
+            return lV.and(theEnv, rV);
+        else
+        if (op == "|")
+            return lV.or(theEnv, rV);
+        else
+        if (op == "^")
+            return lV.xor(theEnv, rV);
+        else
+        if (op == "<<")
+            return lV.shr(theEnv, rV);
+        else
+        if (op == ">>")
+            return lV.shl(theEnv, rV);
+        else
+        if (op == ">>>")
+            return lV.ushl(theEnv, rV);
+        else {
+            System.out.println("missing bitwise op " + op);
+            return null;
+        }
+    }
+
+}

mozilla/js/js2/java/Brenda.java

@@ -0,0 +1,24 @@
+import java.io.*;
+
+class Brenda {
+    
+	public static void main(String[] args) {
+		try {
+			JSLexer lexer = new JSLexer((args != null) ? new DataInputStream(new FileInputStream(args[0])) : new DataInputStream(System.in));
+			JSParser parser = new JSParser(lexer);
+			ControlNodeGroup tree = new ControlNodeGroup();
+			parser.statements(0, tree);
+			System.out.println(ControlNode.printAll());
+			
+            Environment theEnv = new Environment();
+			ControlNode c = tree.getHead();
+			while (c != null) c = c.eval(theEnv);
+			
+			System.out.println("After eval :\n" + theEnv.print());
+			
+		} catch(Exception e) {
+			System.err.println("exception: "+e);
+		}
+	}
+    
+}

mozilla/js/js2/java/ConditionalNode.java

@@ -0,0 +1,59 @@
+class ConditionalNode extends ControlNode {
+    
+    ConditionalNode(ExpressionNode aCondition)
+    {
+        super(aCondition);
+    }
+    
+    ConditionalNode(ExpressionNode aCondition, ControlNode aTrueCode)
+    {
+        super(aCondition);
+        trueCode = aTrueCode;
+    }
+    
+    ConditionalNode(ExpressionNode aCondition, ControlNode aTrueCode, ControlNode aFalseCode)
+    {
+        super(aCondition);
+        trueCode = aTrueCode;
+        setNext(aFalseCode);
+    }
+    
+    void moveNextToTrue()
+    {
+        trueCode = next;
+        setNext(null);
+    }
+    
+    ControlNode eval(Environment theEnv)
+    {
+        JSBoolean b = expr.eval(theEnv).toJSBoolean(theEnv);
+        if (b.isTrue())
+            return trueCode;
+        else
+            return next;
+    }
+
+    String print()
+    {
+        StringBuffer result = new StringBuffer("ConditionalNode ");
+        result.append(index);
+        result.append("\nexpr:\n");
+        if (expr == null)
+            result.append("expr = null\n");
+        else
+            result.append(expr.print(""));
+        result.append("true branch:\n");
+        if (trueCode == null)
+            result.append("true branch = null\n");
+        else
+            result.append("true branch->" + trueCode.index + "\n");
+        result.append("false branch:\n");
+        if (next == null)
+            result.append("false branch = null\n");
+        else
+            result.append("false branch->" + next.index + "\n");
+        return result.toString();
+    }
+ 
+    protected ControlNode trueCode;
+}

mozilla/js/js2/java/ControlNode.java

@@ -0,0 +1,67 @@
+
+import java.util.Vector;
+
+class ControlNode {
+
+    private static Vector gList = new Vector();
+    
+    static String printAll()
+    {
+        StringBuffer result = new StringBuffer();
+        for (int i = 0; i < gList.size(); i++) {
+            result.append(((ControlNode)(gList.elementAt(i))).print());
+        }
+        return result.toString();
+    }
+
+    ControlNode(ExpressionNode anExpr)
+    {
+        expr = anExpr;
+        index = gList.size();
+        gList.addElement(this);
+    }
+    
+    ExpressionNode getExpression()
+    {
+        return expr;
+    }
+    
+    void setNext(ControlNode aNext)
+    {
+        next = aNext;
+    }
+    
+    ControlNode eval(Environment theEnv)
+    {
+        if (expr != null) theEnv.resultValue = expr.eval(theEnv);
+        return next;
+    }
+    
+    String print()
+    {
+        StringBuffer result = new StringBuffer(getClass().toString().substring(6));
+        result.append(" #");
+        result.append(index);
+        result.append("\nexpr:  \n");
+        if (expr == null)
+            result.append("expr = null\n");
+        else
+            result.append(expr.print(""));
+        result.append("next:  ");
+        if (next == null)
+            result.append("next = null\n");
+        else
+            result.append("next->" + next.index + "\n");
+        return result.toString();
+    }
+
+    protected ExpressionNode expr;
+    protected ControlNode next;   
+    protected int index;
+
+}
+
+
+
+
+

mozilla/js/js2/java/ControlNodeGroup.java

@@ -0,0 +1,153 @@
+
+import java.util.Vector;
+
+class ControlNodeGroup {
+    
+    ControlNodeGroup()
+    {
+    }
+    
+    ControlNodeGroup(ControlNode aHead)
+    {
+        head = aHead;
+    }
+    
+    void add(ControlNodeGroup aGroup)
+    {
+        if (head == null) {
+            head = aGroup.head;
+        }
+        else {
+            fixTails(aGroup.getHead());
+        }
+        addTails(aGroup);
+    }
+    
+    void add(ControlNode aNode)
+    {
+        fixTails(aNode);
+        addTail(aNode);
+        if (head == null) head = aNode;
+    }
+    
+    void addBreak(ControlNode aNode)
+    {
+        fixTails(aNode);
+        addBreakTail(aNode);
+        if (head == null) head = aNode;
+    }
+    
+    void addContinue(ControlNode aNode)
+    {
+        fixTails(aNode);
+        addContinueTail(aNode);
+        if (head == null) head = aNode;
+    }
+    
+    void fixTails(ControlNode butt)
+    {
+        int count = tails.size();
+        for (int i = 0; i < count; i++)
+        {
+            ControlNode aNode = (ControlNode)(tails.elementAt(i));
+            aNode.setNext(butt);
+        }
+        tails.removeAllElements();
+    }
+    
+    void fixContinues(ControlNode butt, String label)
+    {
+        int count = continueTails.size();
+        int i = 0;
+        while (i < count) {
+            ControlNode c = (ControlNode)(continueTails.elementAt(i));            
+            ExpressionNode e = c.getExpression();
+            String tgt = (e == null) ? null : ((JSIdentifier)e).s;
+            if ((tgt == null) || tgt.equals(label)) {
+                c.setNext(butt);
+                continueTails.removeElementAt(i);
+                count--;
+            }
+            else
+                i++;
+        }
+    }
+    
+    void setHead(ControlNode aHead)
+    {
+        head = aHead;
+    }
+    
+    ControlNode getHead()
+    {
+        return head;
+    }
+    
+    void addTail(ControlNode aTail)
+    {
+        tails.addElement(aTail);
+    }
+    
+    void addBreakTail(ControlNode aTail)
+    {
+        breakTails.addElement(aTail);
+    }
+    
+    void addContinueTail(ControlNode aTail)
+    {
+        continueTails.addElement(aTail);
+    }
+    
+    void removeTail(ControlNode aTail)
+    {
+        tails.removeElement(aTail);
+    }
+    
+    void addTails(ControlNodeGroup aGroup)
+    {
+        int count = aGroup.tails.size();
+        for (int i = 0; i < count; i++)
+        {
+            tails.addElement(aGroup.tails.elementAt(i));
+        }
+        aGroup.tails.removeAllElements();
+        
+        count = aGroup.breakTails.size();
+        for (int i = 0; i < count; i++)
+        {
+            breakTails.addElement(aGroup.breakTails.elementAt(i));
+        }
+        aGroup.breakTails.removeAllElements();
+
+        count = aGroup.continueTails.size();
+        for (int i = 0; i < count; i++)
+        {
+            continueTails.addElement(aGroup.continueTails.elementAt(i));
+        }
+        aGroup.continueTails.removeAllElements();
+    }
+    
+    void shiftBreakTails(String label)
+    {
+        int count = breakTails.size();
+        int i = 0;
+        while (i < count) {
+            ControlNode c = (ControlNode)(breakTails.elementAt(i));
+            ExpressionNode e = c.getExpression();
+            String tgt = (e == null) ? null : ((JSIdentifier)e).s;
+            if ((tgt == null) || tgt.equals(label)) {
+                tails.addElement(c);
+                breakTails.removeElementAt(i);
+                count--;
+            }
+            else
+                i++;
+        }        
+    }
+  
+    ControlNode head;
+    Vector tails = new Vector();
+    Vector breakTails = new Vector();
+    Vector continueTails = new Vector();
+
+}

mozilla/js/js2/java/Environment.java

@@ -0,0 +1,30 @@
+
+import java.util.Hashtable;
+
+class Environment {
+
+    JSScope scope = new JSScope("globals");
+    JSScope globalScope = scope;
+    
+
+    void enterNewScope(JSScope newScope)
+    {
+        newScope.parent = scope;
+        scope = newScope;
+    }
+    
+    void leaveScope()
+    {
+        scope = scope.parent;
+    }
+
+    String print()
+    {
+        StringBuffer result = new StringBuffer("Globals contents :\n");
+        result.append(scope.toString());
+        return result.toString();
+    }
+
+    JSValue resultValue;
+
+}

mozilla/js/js2/java/ExpressionNode.java

@@ -0,0 +1,24 @@
+class ExpressionNode {
+
+    ExpressionNode()
+    {
+    }
+    
+    String print(String indent)
+    {
+        return indent + "ExpressionNode(" + getClass().toString() + ")\n";
+    }
+    
+    JSReference evalLHS(Environment theEnv)
+    {
+        System.out.println("Unimplemented evalLHS for " + print(""));
+        return null;
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        System.out.println("Unimplemented eval for " + print(""));
+        return null;
+    }
+    
+}

mozilla/js/js2/java/FunctionNode.java

@@ -0,0 +1,36 @@
+class FunctionNode extends ExpressionNode {
+
+    FunctionNode(JSIdentifier aName, ControlNodeGroup aBody, ExpressionNode parameterList)
+    {
+        fn = new NativeFunction(aBody.getHead());
+        name = aName;
+        if (parameterList != null) {
+            if (parameterList instanceof BinaryNode)
+                buildParameterVector((BinaryNode)parameterList);
+            else
+                fn.parameters.addElement(parameterList);
+        }
+    }
+
+    void buildParameterVector(BinaryNode x)
+    {
+        if (x.left instanceof BinaryNode) {
+            buildParameterVector((BinaryNode)(x.left));
+            fn.parameters.addElement(x.right);
+        }
+        else {
+            fn.parameters.addElement(x.left);
+            fn.parameters.addElement(x.right);
+        }
+    }
+
+    JSValue eval(Environment theEnv)
+    {
+        theEnv.scope.putProp(theEnv, name, fn);
+        return fn;
+    }
+
+    JSString name;
+    NativeFunction fn;
+
+}

mozilla/js/js2/java/JSBoolean.java

@@ -0,0 +1,52 @@
+class JSBoolean extends JSValue {
+    
+    static JSBoolean JSTrue = new JSBoolean(true);
+    static JSBoolean JSFalse = new JSBoolean(false);
+
+    private JSBoolean(boolean p)
+    {
+        b = p;
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        return this;
+    }
+    
+    boolean isTrue()
+    {
+        return b;
+    }
+            
+    boolean isFalse()
+    {
+        return !b;
+    }
+    
+    JSValue bang(Environment theEnv) {
+         return (b) ? JSFalse : JSTrue;
+    }
+
+    JSValue typeof(Environment theEnv) {
+        return new JSString("boolean");
+    }
+
+    JSBoolean toJSBoolean(Environment theEnv) {
+        return this;
+    }
+    
+    JSValue toPrimitive(Environment theEnv, String hint) {
+        return this;
+    }
+    
+    JSString toJSString(Environment theEnv) {
+        return (b) ? new JSString("true") : new JSString("false");
+    }
+    
+    JSDouble toJSDouble(Environment theEnv) {
+        return (b) ? new JSDouble(1) : new JSDouble(0);
+    }
+            
+    boolean b;
+    
+}

mozilla/js/js2/java/JSDouble.java

@@ -0,0 +1,111 @@
+class JSDouble extends JSNumber {
+ 
+    JSDouble(double p)
+    {
+        d = p;
+    }
+    
+    JSDouble(String s)
+    {
+        d = new Double(s).doubleValue();
+    }
+    
+    String print(String indent)
+    {
+        return indent + "JSDouble " + d + "\n";
+    }
+
+    public String toString()
+    {
+        return Double.toString(d);
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        return this;
+    }
+
+    JSValue plus(Environment theEnv) {
+        return this;
+    }
+    
+    JSValue minus(Environment theEnv) {
+        return new JSDouble(-d);
+    }
+    
+    JSValue add(Environment theEnv, JSValue rV) {
+        if (rV instanceof JSString)         
+            return toJSString(theEnv).add(theEnv, rV);
+        else
+            return new JSDouble(d + rV.toJSDouble(theEnv).d);
+    }
+    
+    JSValue subtract(Environment theEnv, JSValue rV) {
+        return new JSDouble(d - rV.toJSDouble(theEnv).d);
+    }
+    
+    JSValue multiply(Environment theEnv, JSValue rV) {
+        return new JSDouble(d * rV.toJSDouble(theEnv).d);
+    }
+
+    JSValue divide(Environment theEnv, JSValue rV) {
+        return new JSDouble(d / rV.toJSDouble(theEnv).d);
+    }
+    
+    JSValue remainder(Environment theEnv, JSValue rV) {
+        return new JSDouble(d % rV.toJSDouble(theEnv).d);
+    }
+    
+    JSValue gt(Environment theEnv, JSValue rV) {
+        return (d > rV.toJSDouble(theEnv).d) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+
+    JSValue ge(Environment theEnv, JSValue rV) {
+        return (d >= rV.toJSDouble(theEnv).d) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+    
+    JSValue lt(Environment theEnv, JSValue rV) {
+        return (d < rV.toJSDouble(theEnv).d) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+    
+    JSValue le(Environment theEnv, JSValue rV) {
+        return (d <= rV.toJSDouble(theEnv).d) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+    
+    JSValue eq(Environment theEnv, JSValue rV) {
+        return (d == rV.toJSDouble(theEnv).d) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+    
+    JSValue ne(Environment theEnv, JSValue rV) {
+        return (d != rV.toJSDouble(theEnv).d) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+    
+    JSDouble toJSDouble(Environment theEnv) {
+        return this;
+    }
+    
+    JSValue toPrimitive(Environment theEnv, String hint) {
+        return this;
+    }
+    
+    JSInteger toJSInteger(Environment theEnv) {
+        return new JSInteger((int)d);
+    }
+    
+    JSBoolean toJSBoolean(Environment theEnv) {
+        return ((d == d) && (d != 0.0)) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+    
+    JSString toJSString(Environment theEnv) {
+        return new JSString(Double.toString(d));
+    }
+    
+    JSObject toJSObject(Environment theEnv) {
+        return new NativeNumber(d);
+    }
+    
+    
+ 
+    double d;
+    
+}

mozilla/js/js2/java/JSException.java

@@ -0,0 +1,22 @@
+
+
+class JSException extends RuntimeException {
+
+    JSException(JSValue x)
+    {
+        value = x;
+    }
+    
+    JSValue getValue()
+    {
+        return value;
+    }
+    
+    public String toString()
+    {
+        return value.toJSString(null).s;
+    }
+    
+    JSValue value;
+    
+}

mozilla/js/js2/java/JSIdentifier.java

@@ -0,0 +1,23 @@
+class JSIdentifier extends JSString {
+
+    JSIdentifier(String s)
+    {
+        super(s);
+    }
+    
+    String print(String indent)
+    {
+        return indent + "JSIdentifier : " + s + "\n";
+    }
+
+    JSValue eval(Environment theEnv)
+    {
+        return theEnv.scope.getProp(theEnv, this);
+    }
+    
+    JSReference evalLHS(Environment theEnv)
+    {
+        return new JSReference(theEnv.scope, this);
+    }
+    
+}

mozilla/js/js2/java/JSInteger.java

@@ -0,0 +1,68 @@
+class JSInteger extends JSNumber {
+ 
+    JSInteger(String s)
+    {
+        i = new Integer(s).intValue();
+    }
+    
+    JSInteger(int p)
+    {
+        i = p;
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        return this;
+    }
+
+    JSBoolean toJSBoolean(Environment theEnv) {
+        return (i != 0) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+    }
+    
+    JSDouble toJSDouble(Environment theEnv) {
+        return new JSDouble(i);
+    }
+    
+    JSInteger toJSInteger(Environment theEnv) {
+        return this;
+    }
+    
+    JSValue toPrimitive(Environment theEnv, String hint) {
+        return this;
+    }
+    
+    JSString toJSString(Environment theEnv) {
+        return new JSString(Integer.toString(i));
+    }
+    
+    JSValue twiddle(Environment theEnv) {
+        return new JSInteger(~i);
+    }
+
+    JSValue and(Environment theEnv, JSValue rV) {
+        return new JSInteger(i & rV.toJSInteger(theEnv).i);
+    }
+    
+    JSValue or(Environment theEnv, JSValue rV) {
+        return new JSInteger(i | rV.toJSInteger(theEnv).i);
+    }
+
+    JSValue xor(Environment theEnv, JSValue rV) {
+        return new JSInteger(i ^ rV.toJSInteger(theEnv).i);
+    }
+
+    JSValue shl(Environment theEnv, JSValue rV) {
+        return new JSInteger(i >> rV.toJSInteger(theEnv).i);
+    }
+
+    JSValue shr(Environment theEnv, JSValue rV) {
+        return new JSInteger(i << rV.toJSInteger(theEnv).i);
+    }
+
+    JSValue ushl(Environment theEnv, JSValue rV) {
+        return new JSInteger(i >>> rV.toJSInteger(theEnv).i);
+    }
+
+    int i;
+    
+}

mozilla/js/js2/java/JSName.java

@@ -0,0 +1,41 @@
+class JSName extends ExpressionNode {
+
+    JSName(JSIdentifier anID, int aScope)
+    {
+        id = anID;
+        scope = aScope;         // this is the scope that the name was used in
+    }
+    
+    String print(String indent)
+    {
+        return indent + "JSName : " + id.s + ", scope : " + scope + "\n";
+    }
+
+    JSReference evalLHS(Environment theEnv)
+    {
+        JSScope scope = theEnv.scope;
+        while (scope != null) {
+            if (scope.hasProp(theEnv, id))
+                return new JSReference(scope, id);
+            else
+                scope = scope.parent;
+        }
+        return new JSReference(theEnv.globalScope, id);
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        JSScope scope = theEnv.scope;
+        while (scope != null) {
+            if (scope.hasProp(theEnv, id))
+                return scope.getProp(theEnv, id);
+            else
+                scope = scope.parent;
+        }
+        throw new JSException(new JSString(id.s + " undefined"));
+    }
+    
+    JSIdentifier id;
+    int scope;
+    
+}

mozilla/js/js2/java/JSNumber.java

@@ -0,0 +1,8 @@
+abstract class JSNumber extends JSValue {
+
+    JSValue typeof(Environment theEnv) {
+        return new JSString("number");
+    }
+
+    
+}

mozilla/js/js2/java/JSObject.java

@@ -0,0 +1,84 @@
+
+import java.util.Hashtable;
+
+class JSObject extends JSValue {
+    
+    static JSObject objectPrototype = new JSObject("Object");
+    static JSObject JSUndefined = new JSObject("undefined");
+    
+    JSObject(String aClass)
+    {
+        oClass = aClass;
+        prototype = objectPrototype;
+    }
+    
+    void setPrototype(JSObject aPrototype)
+    {
+        prototype = aPrototype;
+    }
+    
+    String print(String indent)
+    {
+        return indent + "JSObject : " + oClass + "\n";
+    }
+
+    public String toString() {
+        return oClass + contents.toString();
+    }
+        
+    JSValue eval(Environment theEnv)
+    {
+        return this;
+    }
+
+    JSValue typeof(Environment theEnv) {
+        if (this == JSUndefined)
+            return new JSString("undefined");
+        else
+            return new JSString("object");
+    }
+    
+    JSBoolean toJSBoolean(Environment theEnv) {
+        return JSBoolean.JSTrue;
+    }
+        
+    JSDouble toJSDouble(Environment theEnv) {
+        return toPrimitive(theEnv, "Number").toJSDouble(theEnv);
+    }
+    
+    JSValue getProp(Environment theEnv, JSString id)
+    {
+        Object v = contents.get(id.s);
+        if (v == null)
+            if (prototype == null)
+                return JSUndefined;
+            else
+                return prototype.getProp(theEnv, id);
+        else
+            return (JSValue)v;
+    }
+        
+    boolean hasProp(Environment theEnv, JSString id)
+    {
+        Object v = contents.get(id.s);
+        if (v == null)
+            if (prototype == null)
+                return false;
+            else
+                return prototype.hasProp(theEnv, id);
+        else
+            return true;
+    }
+        
+    JSValue putProp(Environment theEnv, JSString id, JSValue rV) {
+        contents.put(id.s, rV);
+        return rV;
+    }
+        
+        
+    Hashtable contents = new Hashtable();
+        
+    String oClass;
+    
+    JSObject prototype;
+}

mozilla/js/js2/java/JSReference.java

@@ -0,0 +1,12 @@
+class JSReference {
+
+    JSReference(JSValue aBase, JSString aID)
+    {
+        base = aBase;
+        id = aID;
+    }
+    
+    JSValue base;
+    JSString id;
+
+}

mozilla/js/js2/java/JSScope.java

@@ -0,0 +1,10 @@
+class JSScope extends JSObject {
+
+    JSScope(String s)
+    {
+        super(s);
+    }
+
+    JSScope parent;
+
+}

mozilla/js/js2/java/JSString.java

@@ -0,0 +1,83 @@
+class JSString extends JSValue {
+ 
+    JSString(String p)
+    {
+        s = p;
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        return this;
+    }
+    
+    JSValue typeof(Environment theEnv) {
+        return new JSString("string");
+    }
+
+    JSValue add(Environment theEnv, JSValue rV)
+    {
+        return new JSString(s + rV.toJSString(theEnv).s);
+    }
+
+    JSValue gt(Environment theEnv, JSValue rV) {
+        if (rV instanceof JSString)
+            return (s.compareTo(rV.toJSString(theEnv).s) == 1) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+        else
+            return toJSDouble(theEnv).gt(theEnv, rV);
+    }
+
+    JSValue ge(Environment theEnv, JSValue rV) {
+        if (rV instanceof JSString)
+            return (s.compareTo(rV.toJSString(theEnv).s) != -1) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+        else
+            return toJSDouble(theEnv).ge(theEnv, rV);
+    }
+    
+    JSValue lt(Environment theEnv, JSValue rV) {
+        if (rV instanceof JSString)
+            return (s.compareTo(rV.toJSString(theEnv).s) == -1) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+        else
+            return toJSDouble(theEnv).lt(theEnv, rV);
+    }
+    
+    JSValue le(Environment theEnv, JSValue rV) {
+        if (rV instanceof JSString)
+            return (s.compareTo(rV.toJSString(theEnv).s) != 1) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+        else
+            return toJSDouble(theEnv).le(theEnv, rV);
+    }
+    
+    JSValue eq(Environment theEnv, JSValue rV) {
+        if (rV instanceof JSString)
+            return (s.compareTo(rV.toJSString(theEnv).s) == 0) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+        else
+            return toJSDouble(theEnv).eq(theEnv, rV);
+    }
+    
+    JSValue ne(Environment theEnv, JSValue rV) {
+        if (rV instanceof JSString)
+            return (s.compareTo(rV.toJSString(theEnv).s) != 0) ? JSBoolean.JSTrue : JSBoolean.JSFalse;
+        else
+            return toJSDouble(theEnv).ne(theEnv, rV);
+    }
+    
+    JSDouble toJSDouble(Environment theEnv) {
+        return new JSDouble(s);         // XXX Way More To Do, see Rhino ScriptRuntime.java
+    }
+    
+    JSString toJSString(Environment theEnv) {
+        return this;
+    }
+    
+    JSValue toPrimitive(Environment theEnv, String hint) {
+        return this;
+    }
+    
+    String print(String indent)
+    {
+        return indent + "JSString : " + s + "\n";
+    }
+
+    protected String s;
+    
+}

mozilla/js/js2/java/JSValue.java

@@ -0,0 +1,222 @@
+class JSValue extends ExpressionNode {
+    
+    String print(String indent)
+    {
+        return indent + "JSValue\n";
+    }
+
+    JSReference evalLHS(Environment theEnv)
+    {
+        throw new RuntimeException("EvalLHS on non-lvalue");
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        throw new RuntimeException("Eval on JSValue");
+    }    
+    
+    JSValue unimplemented(String op)
+    {
+        throw new RuntimeException("unimplemented " + op + " called");
+    }
+    
+    JSValue gt(Environment theEnv, JSValue rV) {
+        JSValue lV = toPrimitive(theEnv, "Number");
+        rV = rV.toPrimitive(theEnv, "Number");
+        if ((lV instanceof JSString) && (rV instanceof JSString))
+            return lV.gt(theEnv, rV);
+        else
+            return lV.toJSDouble(theEnv).gt(theEnv, rV.toJSDouble(theEnv));
+    }
+
+    JSValue ge(Environment theEnv, JSValue rV) {
+        JSValue lV = toPrimitive(theEnv, "Number");
+        rV = rV.toPrimitive(theEnv, "Number");
+        if ((lV instanceof JSString) && (rV instanceof JSString))
+            return lV.ge(theEnv, rV);
+        else
+            return lV.toJSDouble(theEnv).ge(theEnv, rV.toJSDouble(theEnv));
+    }
+
+    JSValue lt(Environment theEnv, JSValue rV) {
+        JSValue lV = toPrimitive(theEnv, "Number");
+        rV = rV.toPrimitive(theEnv, "Number");
+        if ((lV instanceof JSString) && (rV instanceof JSString))
+            return lV.lt(theEnv, rV);
+        else
+            return lV.toJSDouble(theEnv).lt(theEnv, rV.toJSDouble(theEnv));
+    }
+
+    JSValue le(Environment theEnv, JSValue rV) {
+        JSValue lV = toPrimitive(theEnv, "Number");
+        rV = rV.toPrimitive(theEnv, "Number");
+        if ((lV instanceof JSString) && (rV instanceof JSString))
+            return lV.le(theEnv, rV);
+        else
+            return lV.toJSDouble(theEnv).le(theEnv, rV.toJSDouble(theEnv));
+    }
+
+    JSValue eq(Environment theEnv, JSValue rV) {
+        JSValue lV = toPrimitive(theEnv, "Number");
+        rV = rV.toPrimitive(theEnv, "Number");
+        if ((lV instanceof JSString) && (rV instanceof JSString))
+            return lV.eq(theEnv, rV);
+        else
+            return lV.toJSDouble(theEnv).eq(theEnv, rV.toJSDouble(theEnv));
+    }
+
+    JSValue ne(Environment theEnv, JSValue rV) {
+        JSValue lV = toPrimitive(theEnv, "Number");
+        rV = rV.toPrimitive(theEnv, "Number");
+        if ((lV instanceof JSString) && (rV instanceof JSString))
+            return lV.ne(theEnv, rV);
+        else
+            return lV.toJSDouble(theEnv).ne(theEnv, rV.toJSDouble(theEnv));
+    }
+    
+    JSValue plus(Environment theEnv) {
+        return toJSDouble(theEnv).plus(theEnv);
+    }
+
+    JSValue minus(Environment theEnv) {
+        return toJSDouble(theEnv).minus(theEnv);
+    }
+
+    JSValue twiddle(Environment theEnv) {
+        return toJSInteger(theEnv).twiddle(theEnv);
+    }
+
+    JSValue bang(Environment theEnv) {
+        return toJSBoolean(theEnv).bang(theEnv);
+    }
+
+    JSValue typeof(Environment theEnv) {
+        return unimplemented("typeof");
+    }
+
+    JSValue add(Environment theEnv, JSValue rV) {
+        JSValue lV = toPrimitive(theEnv, "");
+        rV = rV.toPrimitive(theEnv, "");
+        if ((lV instanceof JSString) || (rV instanceof JSString))
+            return lV.add(theEnv, rV);
+        else
+            return lV.toJSDouble(theEnv).add(theEnv, rV);
+    }
+    
+    JSValue subtract(Environment theEnv, JSValue rV) {
+        return toJSDouble(theEnv).subtract(theEnv, rV.toJSDouble(theEnv));
+    }
+    
+    JSValue multiply(Environment theEnv, JSValue rV) {
+        return toJSDouble(theEnv).multiply(theEnv, rV.toJSDouble(theEnv));
+    }
+    
+    JSValue divide(Environment theEnv, JSValue rV) {
+        return toJSDouble(theEnv).divide(theEnv, rV.toJSDouble(theEnv));
+    }
+    
+    JSValue remainder(Environment theEnv, JSValue rV) {
+        return toJSDouble(theEnv).remainder(theEnv, rV.toJSDouble(theEnv));
+    }
+    
+    JSValue and(Environment theEnv, JSValue rV) {
+        return toJSInteger(theEnv).and(theEnv, rV.toJSInteger(theEnv));
+    }
+    
+    JSValue or(Environment theEnv, JSValue rV) {
+        return toJSInteger(theEnv).or(theEnv, rV.toJSInteger(theEnv));
+    }
+    
+    JSValue xor(Environment theEnv, JSValue rV) {
+        return toJSInteger(theEnv).xor(theEnv, rV.toJSInteger(theEnv));
+    }
+    
+    JSValue shl(Environment theEnv, JSValue rV) {
+        return toJSInteger(theEnv).shl(theEnv, rV.toJSInteger(theEnv));
+    }
+    
+    JSValue shr(Environment theEnv, JSValue rV) {
+        return toJSInteger(theEnv).shr(theEnv, rV.toJSInteger(theEnv));
+    }
+    
+    JSValue ushl(Environment theEnv, JSValue rV) {
+        return toJSInteger(theEnv).ushl(theEnv, rV.toJSInteger(theEnv));
+    }     
+    
+    JSValue getProp(Environment theEnv, JSString id) {
+        return toJSObject(theEnv).getProp(theEnv, id);
+    }
+    
+    boolean hasProp(Environment theEnv, JSString id) {
+        return toJSObject(theEnv).hasProp(theEnv, id);
+    }
+
+    JSValue putProp(Environment theEnv, JSString id, JSValue rV) {
+        return toJSObject(theEnv).putProp(theEnv, id, rV);
+    }
+    
+    JSValue call(Environment theEnv, JSValue rV) {
+        throw new JSException(new JSString("[[call]] not implemented"));
+    }
+    
+    JSValue defaultValue(Environment theEnv, String hint) {
+/*
+When the [[DefaultValue]] method of O is called with hint String, the following steps are taken:
+1. Call the [[Get]] method of object O with argument "toString".
+2. If Result(1) is not an object, go to step 5.
+3. Call the [[Call]] method of Result(1), with O as the this value and an empty argument list.
+4. If Result(3) is a primitive value, return Result(3).
+5. Call the [[Get]] method of object O with argument "valueOf".
+6. If Result(5) is not an object, go to step 9.
+7. Call the [[Call]] method of Result(5), with O as the this value and an empty argument list.
+8. If Result(7) is a primitive value, return Result(7).
+9. Generate a runtime error.
+*/
+        JSValue v = null;
+        if (hint.equals("String")) {
+            v = getProp(theEnv, new JSString("toString"));
+            if (v instanceof JSObject) {
+                // invoke 'v.Call' with 'this' as the JS this
+            }
+            else {
+                v = getProp(theEnv, new JSString("valueOf"));
+                if (v instanceof JSObject) {                    
+                }
+                else 
+                    throw new JSException(new JSString("No default value"));
+            }
+        }
+        else { // hint.equals("Number")
+/*
+When the [[DefaultValue]] method of O is called with hint Number, the following steps are taken:
+1. Call the [[Get]] method of object O with argument "valueOf".
+2. If Result(1) is not an object, go to step 5.
+3. Call the [[Call]] method of Result(1), with O as the this value and an empty argument list.
+4. If Result(3) is a primitive value, return Result(3).
+5. Call the [[Get]] method of object O with argument "toString".
+6. If Result(5) is not an object, go to step 9.
+7. Call the [[Call]] method of Result(5), with O as the this value and an empty argument list.
+8. If Result(7) is a primitive value, return Result(7).
+9. Generate a runtime error.
+*/
+            
+        }
+        return null;
+    }
+    
+    JSValue toPrimitive(Environment theEnv, String hint) {
+        JSValue result = defaultValue(theEnv, hint);
+        if (result instanceof JSObject)
+            throw new JSException(new JSString("default value returned object"));
+        else
+            return result;
+    }
+       
+    
+    JSObject toJSObject(Environment theEnv)       { unimplemented("toJSObjet"); return null; }
+    JSDouble toJSDouble(Environment theEnv)       { unimplemented("toJSDouble"); return null; }
+    JSInteger toJSInteger(Environment theEnv)     { unimplemented("toJSInteger"); return null; }
+    JSString toJSString(Environment theEnv)       { unimplemented("toJSString"); return null; }
+    JSBoolean toJSBoolean(Environment theEnv)     { unimplemented("toJSBoolean"); return null; }
+
+}

mozilla/js/js2/java/JSValueList.java

@@ -0,0 +1,40 @@
+
+import java.util.Vector;
+
+class JSValueList extends JSValue {
+    
+    static JSValueList buildList(JSValue left, JSValue right)
+    {
+        JSValueList theList;
+        if (left instanceof JSValueList) {
+            theList = (JSValueList)left;
+            theList.add(right);
+        }
+        else
+            if (right instanceof JSValueList) {
+                theList = (JSValueList)right;
+                theList.add(left);
+            }
+            else {
+                theList = new JSValueList();
+                theList.add(left);
+                theList.add(right);
+            }
+        
+        return theList;                       
+    }
+    
+    void add(JSValue v)
+    {
+        if (v instanceof JSValueList) {
+            JSValueList vl = (JSValueList)v;
+            for (int i = 0; i < vl.contents.size(); i++)
+                contents.addElement((JSValue)(vl.contents.elementAt(i)));
+        }
+        else
+            contents.addElement(v);
+    }
+    
+    Vector contents = new Vector();
+    
+}

mozilla/js/js2/java/LogicalNode.java

@@ -0,0 +1,39 @@
+class LogicalNode extends BinaryNode {
+
+    LogicalNode(String aOp, ExpressionNode aLeft, ExpressionNode aRight)
+    {
+        super(aOp, aLeft, aRight);
+    }
+
+    JSValue eval(Environment theEnv)
+    {
+        JSBoolean b = left.eval(theEnv).toJSBoolean(theEnv);
+        if (op == "&&") {
+            if (b.isFalse())
+                return b;
+            else {
+                b = right.eval(theEnv).toJSBoolean(theEnv);
+                if (b.isFalse())
+                    return b;
+                else
+                    return JSBoolean.JSTrue;
+            }
+        }
+        if (op == "||") {
+            if (b.isTrue())
+                return b;
+            else {
+                b = right.eval(theEnv).toJSBoolean(theEnv);
+                if (b.isTrue())
+                    return b;
+                else
+                    return JSBoolean.JSFalse;
+            }
+        }
+        else {
+            System.out.println("missing logical op " + op);
+            return null;
+        }
+    }
+
+}

mozilla/js/js2/java/NativeFunction.java

@@ -0,0 +1,35 @@
+
+import java.util.Vector;
+
+class NativeFunction extends JSObject {
+    
+    NativeFunction(ControlNode aBody)
+    {
+        super("Function");
+        body = aBody;
+    }
+    
+    JSValue call(Environment theEnv, JSValue rV)
+    {
+        
+        JSScope args = new JSScope("Arguments");
+        theEnv.enterNewScope(args);
+        
+        for (int i = 0; i < parameters.size(); i++) {
+            if (rV instanceof JSValueList)
+                args.putProp(theEnv, (JSString)(parameters.elementAt(i)), (JSValue) ( ((JSValueList)rV).contents.elementAt(i)) );
+            else
+                args.putProp(theEnv, (JSString)(parameters.elementAt(i)), rV );
+        }
+        
+        ControlNode c = body;
+        while (c != null) c = c.eval(theEnv);
+        
+        theEnv.leaveScope();
+        return theEnv.resultValue;
+    }
+    
+    ControlNode body;
+    Vector parameters = new Vector();
+    
+}

mozilla/js/js2/java/NativeNumber.java

@@ -0,0 +1,18 @@
+class NativeNumber extends JSObject {
+    
+    NativeNumber(double p) {
+        super("Number");
+        d = p;
+    }
+    
+    JSValue defaultValue(Environment theEnv, String hint) {
+        if (hint.equals("String"))
+            return new JSString(Double.toString(d));
+        else
+            return new JSDouble(d);
+    }    
+    
+    double d;
+    
+    
+}

mozilla/js/js2/java/RelationalNode.java

@@ -0,0 +1,35 @@
+class RelationalNode extends BinaryNode {
+
+    RelationalNode(String aOp, ExpressionNode aLeft, ExpressionNode aRight)
+    {
+        super(aOp, aLeft, aRight);
+    }
+
+    JSValue eval(Environment theEnv)
+    {
+        JSValue lV = left.eval(theEnv);
+        JSValue rV = right.eval(theEnv);
+
+        if (op == ">")
+            return lV.gt(theEnv, rV);
+        else
+        if (op == ">=")
+            return lV.ge(theEnv, rV);
+        else
+        if (op == "<")
+            return lV.lt(theEnv, rV);
+        else
+        if (op == "<=")
+            return lV.le(theEnv, rV);
+        else
+        if (op == "==")
+            return lV.eq(theEnv, rV);
+        else
+        if (op == "!=")
+            return lV.ne(theEnv, rV);
+        else {
+            System.out.println("missing relational op");
+            return null;
+        }
+    }
+}

mozilla/js/js2/java/SwitchNode.java

@@ -0,0 +1,43 @@
+
+import java.util.Vector;
+
+class SwitchNode extends ControlNode {
+    
+
+    SwitchNode(ExpressionNode e)
+    {
+        super(e);
+    }
+    
+    void addCase(ExpressionNode e, ControlNode c)
+    {
+        if (e == null)
+            defaultCode = c;
+        else {
+            caseExpr.addElement(e);
+            caseCode.addElement(c);
+        }
+    }
+    
+    ControlNode eval(Environment theEnv)
+    {
+        JSValue v = expr.eval(theEnv);
+        int count = caseExpr.size();
+        for (int i = 0; i < count; i++) {
+            ExpressionNode e = (ExpressionNode)(caseExpr.elementAt(i));
+            JSBoolean b = v.eq(theEnv, e.eval(theEnv)).toJSBoolean(theEnv);                       
+            if (b.isTrue())
+                return (ControlNode)(caseCode.elementAt(i));
+        }
+        if (defaultCode != null)
+            return defaultCode;
+        else
+            return next;
+    }
+
+    Vector caseExpr = new Vector();
+    Vector caseCode = new Vector();
+    
+    ControlNode defaultCode;
+    
+}

mozilla/js/js2/java/ThrowNode.java

@@ -0,0 +1,13 @@
+class ThrowNode extends ControlNode {
+
+    ThrowNode(ExpressionNode e)
+    {
+        super(e);
+    }
+
+    ControlNode eval(Environment theEnv)
+    {
+        throw new JSException(expr.eval(theEnv));
+    }
+
+}

mozilla/js/js2/java/TryNode.java

@@ -0,0 +1,47 @@
+
+import java.util.Vector;
+
+class TryNode extends ControlNode {
+    
+    TryNode(ControlNode tryCode)
+    {
+        super(null);
+        tryBody = tryCode;
+    }
+    
+    void addFinally(ControlNode finallyCode)
+    {
+        finallyBody = finallyCode;
+    }
+    
+    void addCatchClause(ExpressionNode e, ControlNode c)
+    {
+        catchExpr.addElement(e);
+        catchCode.addElement(c);
+    }
+
+    ControlNode eval(Environment theEnv)
+    {
+        try {
+            ControlNode c = tryBody;
+            while (c != null) c = c.eval(theEnv);
+        }
+        catch (JSException x) {
+            int count = catchExpr.size();
+            for (int i = 0; i < count; i++) {
+                ExpressionNode e = (ExpressionNode)(catchExpr.elementAt(i));
+                String id = ((JSObject)e).oClass;
+                theEnv.scope.contents.put(id, x.getValue());    // XXX YAARGH !!!
+                return (ControlNode)(catchCode.elementAt(i));
+            }
+        }
+        return next;
+    }
+    
+    Vector catchExpr = new Vector();
+    Vector catchCode = new Vector();
+        
+    ControlNode tryBody;
+    ControlNode finallyBody;    
+
+}

mozilla/js/js2/java/UnaryNode.java

@@ -0,0 +1,62 @@
+class UnaryNode extends ExpressionNode {
+    
+    UnaryNode(String aOp, ExpressionNode aChild)
+    {
+        child = aChild;
+        op = aOp;
+    }
+    
+    String print(String indent)
+    {
+        StringBuffer result = new StringBuffer(indent);
+        result.append("UnaryNode ");
+        result.append(op);
+        result.append("\n");
+        indent += "    ";
+        if (child == null) {
+            result.append(indent);
+            result.append("null\n");
+        }
+        else
+            result.append(child.print(indent));
+        return result.toString();
+    }
+    
+    JSValue eval(Environment theEnv)
+    {
+        JSValue cV = child.eval(theEnv);
+
+        if (op == "+")
+            return cV.plus(theEnv);
+        else
+        if (op == "-")
+            return cV.minus(theEnv);
+        else
+        if (op == "~")
+            return cV.twiddle(theEnv);
+        else
+        if (op == "!")
+            return cV.bang(theEnv);
+        else
+        if (op == "typeof")
+            return cV.typeof(theEnv);
+        else {
+            System.out.println("missing unary op " + op);
+            return null;
+        }
+    }
+
+    String getOperator()
+    {
+        return op;
+    }
+    
+    ExpressionNode getChild()
+    {
+        return child;
+    }
+    
+    protected ExpressionNode child;
+    protected String op;
+    
+}

mozilla/js/js2/js2.cpp

@@ -0,0 +1,343 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// 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.
+
+
+//
+// JS2 shell.
+//
+
+#if 1
+#define DEBUGGER_FOO
+#define INTERPRET_INPUT
+#else
+#undef DEBUGGER_FOO
+#undef INTERPRET_INPUT
+#endif
+
+#include <assert.h>
+
+#include "world.h"
+#include "interpreter.h"
+#include "icodegenerator.h"
+
+#ifdef DEBUGGER_FOO
+#include "debugger.h"
+#endif
+        
+#if defined(XP_MAC) && !defined(XP_MAC_MPW)
+#include <SIOUX.h>
+#include <MacTypes.h>
+
+static char *mac_argv[] = {"js2", 0};
+
+static void initConsole(StringPtr consoleName,
+                        const char* startupMessage,
+                        int &argc, char **&argv)
+{
+    SIOUXSettings.autocloseonquit = false;
+    SIOUXSettings.asktosaveonclose = false;
+    SIOUXSetTitle(consoleName);
+
+    // Set up a buffer for stderr (otherwise it's a pig).
+    static char buffer[BUFSIZ];
+    setvbuf(stderr, buffer, _IOLBF, BUFSIZ);
+
+    JavaScript::stdOut << startupMessage;
+
+    argc = 1;
+    argv = mac_argv;
+}
+
+#endif
+
+namespace JavaScript {
+namespace Shell {
+    
+using namespace ICG;
+using namespace JSTypes;
+using namespace Interpreter;
+
+// Interactively read a line from the input stream in and put it into
+// s. Return false if reached the end of input before reading anything.
+static bool promptLine(LineReader &inReader, string &s, const char *prompt)
+{
+    if (prompt) {
+        stdOut << prompt;
+	  #ifdef XP_MAC_MPW
+        // Print a CR after the prompt because MPW grabs the entire
+        // line when entering an interactive command.
+        stdOut << '\n';
+	  #endif
+    }
+    return inReader.readLine(s) != 0;
+}
+
+World world;
+
+/* "filename" of the console */
+const String ConsoleName = widenCString("<console>");
+const bool showTokens = false;
+
+#ifdef DEBUGGER_FOO    
+Reader *sourceReader; /* Reader for console file */
+
+static
+const Reader *ResolveFile (const String& fileName)
+{
+    if (fileName == ConsoleName)
+        return sourceReader;
+    else
+    {
+        stdErr << "Could not locate source for file '" << fileName << "'\n";
+        return 0;
+    }
+    
+}
+
+JavaScript::Debugger::Shell jsd(world, stdin, JavaScript::stdOut,
+                                JavaScript::stdOut, &ResolveFile);
+#endif
+
+static JSValue print(Context *cx, const JSValues &argv)
+{
+    size_t n = argv.size();
+    if (n > 1) {                // the 'this' parameter is un-interesting
+        stdOut << argv[1];
+        for (size_t i = 2; i < n; ++i)
+            stdOut << ' ' << argv[i];
+    }
+    stdOut << "\n";
+    return kUndefinedValue;
+}
+
+static JSValue dump(Context *cx, const JSValues &argv)
+{
+    size_t n = argv.size();
+    if (n > 1) {                // the 'this' parameter is un-interesting
+        if (argv[1].isFunction()) {
+            JSFunction *f = static_cast<JSFunction *>(argv[1].function);
+            if (f->isNative())
+                stdOut << "Native function";
+            else
+                stdOut << *f->getICode();
+        }
+        else
+            stdOut << "Not a function";
+    }
+    stdOut << "\n";
+    return kUndefinedValue;
+}
+
+
+inline char narrow(char16 ch) { return char(ch); }
+
+static JSValue load(Context *cx, const JSValues &argv)
+{
+
+    JSValue result;
+    size_t n = argv.size();
+    if (n > 1) {
+        for (size_t i = 1; i < n; ++i) {
+            JSValue val = argv[i].toString();
+            if (val.isString()) {
+                String fileName(*val.string);
+                std::string str(fileName.length(), char());
+                std::transform(fileName.begin(), fileName.end(), str.begin(), narrow);
+                FILE* f = fopen(str.c_str(), "r");
+                if (f) {
+                    result = cx->readEvalFile(f, fileName);
+                    fclose(f);
+                }
+            }
+        }
+    }
+    return result;
+}
+
+#if 0       // need a XP version of this, rip off from Monkey?
+#include <sys/timeb.h>
+static JSValue time(Context *cx, const JSValues &argv)
+{
+    struct _timeb timebuffer;
+    _ftime(&timebuffer);
+
+    return JSValue((double)timebuffer.time * 1000 + timebuffer.millitm);
+}
+#endif
+
+static void readEvalPrint(FILE *in, World &world)
+{
+    JSScope global;
+    Context cx(world, &global);
+#ifdef DEBUGGER_FOO
+    jsd.attachToContext (&cx);
+#endif
+    global.defineNativeFunction(world.identifiers["print"], print);
+    global.defineNativeFunction(world.identifiers["dump"], dump);
+    global.defineNativeFunction(world.identifiers["load"], load);
+//   global.defineNativeFunction(world.identifiers["time"], time);
+
+    String buffer;
+    string line;
+    LineReader inReader(in);
+        
+    while (promptLine(inReader, line, buffer.empty() ? "js> " : "> ")) {
+        appendChars(buffer, line.data(), line.size());
+        try {
+            Arena a;
+            Parser p(world, a, buffer, ConsoleName);
+                
+            if (showTokens) {
+                Lexer &l = p.lexer;
+                while (true) {
+                    const Token &t = l.get(true);
+                    if (t.hasKind(Token::end))
+                        break;
+                    stdOut << ' ';
+                    t.print(stdOut, true);
+                }
+	            stdOut << '\n';
+            } else {
+                StmtNode *parsedStatements = p.parseProgram();
+				ASSERT(p.lexer.peek(true).hasKind(Token::end));
+                {
+                	PrettyPrinter f(stdOut, 30);
+                	{
+                		PrettyPrinter::Block b(f, 2);
+	                	f << "Program =";
+	                	f.linearBreak(1);
+	                	StmtNode::printStatements(f, parsedStatements);
+                	}
+                	f.end();
+                }
+        	    stdOut << '\n';
+#ifdef INTERPRET_INPUT
+#ifdef DEBUGGER_FOO
+                sourceReader = &(p.lexer.reader);
+#endif
+				// Generate code for parsedStatements, which is a linked 
+                // list of zero or more statements
+                ICodeModule* icm = cx.genCode(parsedStatements, ConsoleName);
+                if (icm) {
+stdOut << *icm;
+                    JSValue result = cx.interpret(icm, JSValues());
+                    stdOut << "result = " << result << "\n";
+                    delete icm;
+                }
+#endif
+            }
+            clear(buffer);
+        } catch (Exception &e) {
+            /* If we got a syntax error on the end of input,
+             * then wait for a continuation
+             * of input rather than printing the error message. */
+            if (!(e.hasKind(Exception::syntaxError) &&
+                  e.lineNum && e.pos == buffer.size() &&
+                  e.sourceFile == ConsoleName)) {
+                stdOut << '\n' << e.fullMessage();
+                clear(buffer);
+            }
+        }
+    }
+    stdOut << '\n';
+}
+
+
+/**
+ * Poor man's instruction tracing facility.
+ */
+class Tracer : public Context::Listener {
+    typedef InstructionStream::difference_type InstructionOffset;
+    void listen(Context* context, Context::Event event)
+    {
+        if (event & Context::EV_STEP) {
+            ICodeModule *iCode = context->getICode();
+            JSValues &registers = context->getRegisters();
+            InstructionIterator pc = context->getPC();
+            
+            
+            InstructionOffset offset = (pc - iCode->its_iCode->begin());
+            printFormat(stdOut, "trace [%02u:%04u]: ",
+                        iCode->mID, offset);
+
+            Instruction* i = *pc;
+            stdOut << *i;
+            if (i->op() != BRANCH && i->count() > 0) {
+                stdOut << " [";
+                i->printOperands(stdOut, registers);
+                stdOut << "]\n";
+            } else {
+                stdOut << '\n';
+            }
+        }
+    }
+};
+
+
+
+char * tests[] = {
+    "function fact(n) { if (n > 1) return n * fact(n-1); else return 1; } print(fact(6), \" should be 720\"); return;" ,
+    "a = { f1: 1, f2: 2}; print(a.f2++, \" should be 2\"); print(a.f2 <<= 1, \" should be 6\"); return;" ,
+    "class A { static var b = 3; static function s() { return b++; }function x() { return \"Ax\"; } function y() { return \"Ay\"; } }  var a:A = new A; print(a.s(), \" should be 3\"); print(A.b, \" should be 4\"); return;",
+    "class B extends A { function x() { return \"Bx\"; }  }  var b:B = new B; print(b.x(), \" should be Bx\"); print(b.y(), \" should be Ay\"); return;"
+};
+
+static void testCompile()
+{
+    JSScope glob;
+    Context cx(world, &glob);
+    glob.defineNativeFunction(world.identifiers["print"], print);
+    for (uint i = 0; i < sizeof(tests) / sizeof(char *); i++) {
+        String testScript = widenCString(tests[i]);
+        Arena a;
+        Parser p(world, a, testScript, widenCString("testCompile"));
+        StmtNode *parsedStatements = p.parseProgram();
+        ICodeGenerator icg(&world, &glob);
+        StmtNode *s = parsedStatements;
+        while (s) {
+            icg.genStmt(s);
+            s = s->next;
+        }
+        cx.interpret(icg.complete(), JSValues());
+    }
+}
+
+
+} /* namespace Shell */
+} /* namespace JavaScript */
+
+
+#if defined(XP_MAC) && !defined(XP_MAC_MPW)
+int main(int argc, char **argv)
+{
+    initConsole("\pJavaScript Shell", "Welcome to the js2 shell.\n", argc, argv);
+#else
+int main(int , char **)
+{
+#endif
+
+    using namespace JavaScript;
+    using namespace Shell;
+#if 1
+    testCompile();
+#endif
+    readEvalPrint(stdin, world);
+    return 0;
+    // return ProcessArgs(argv + 1, argc - 1);
+}

mozilla/js/js2/jsclasses.h

@@ -0,0 +1,316 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifndef jsclasses_h
+#define jsclasses_h
+
+#include "jstypes.h"
+
+namespace JavaScript {
+namespace JSClasses {
+
+    using JSTypes::JSValue;
+    using JSTypes::JSObject;
+    using JSTypes::JSType;
+    using JSTypes::JSScope;
+    using JSTypes::JSFunction;
+    using ICG::ICodeModule;
+    
+
+    struct JSSlot {
+        typedef enum { kNoFlag = 0, kIsConstructor = 0x01 } SlotFlags;   // <-- readonly, enumerable etc
+
+        JSType* mType;
+        uint32 mIndex;
+        SlotFlags mFlags;
+        
+        JSSlot() : mType(0), mFlags(kNoFlag)
+        {
+        }
+
+        bool isConstructor() const          { return (mFlags & kIsConstructor) != 0; }
+    };
+
+#if defined(XP_MAC)
+    // copied from default template parameters in map.
+    typedef gc_allocator<std::pair<const String, JSSlot> > gc_slot_allocator;
+#elif defined(XP_UNIX)
+    typedef JSTypes::gc_map_allocator gc_slot_allocator;
+#elif defined(_WIN32)
+    typedef gc_allocator<JSSlot> gc_slot_allocator;
+#endif
+
+    typedef std::map<String, JSSlot, std::less<const String>, gc_slot_allocator> JSSlots;
+
+
+    typedef std::pair<String, JSFunction*> MethodEntry;
+    typedef std::vector<MethodEntry> JSMethods;
+
+    /**
+     * Represents a class in the JavaScript 2 (ECMA 4) language.
+     * Since a class defines a scope, and is defined in a scope,
+     * a new scope is created whose parent scope is the scope of
+     * class definition.
+     */
+    class JSClass : public JSType {
+    protected:
+        JSScope* mScope;        
+        uint32 mSlotCount;
+        JSSlots mSlots;
+        uint32 mStaticCount;
+        JSSlots mStaticSlots;
+        JSValue* mStaticData;
+        JSMethods mMethods;
+    public:
+        JSClass(JSScope* scope, const String& name, JSClass* superClass = 0)
+            :   JSType(name, superClass),
+                mScope(new JSScope(scope)),
+                mSlotCount(superClass ? superClass->mSlotCount : 0),
+                mStaticCount(0),
+                mStaticData(0)
+        {
+            if (superClass) {
+                   // inherit superclass methods
+                JSMethods::iterator end = superClass->mMethods.end();
+                for (JSMethods::iterator i = superClass->mMethods.begin(); i != end; i++)
+                    mMethods.push_back(*i);
+            }    
+        }
+        
+        JSClass* getSuperClass()
+        {
+            return static_cast<JSClass*>(mBaseType);
+        }
+        
+        JSScope* getScope()
+        {
+            return mScope;
+        }
+
+        const JSSlot& defineSlot(const String& name, JSType* type)
+        {
+            JSSlot& slot = mSlots[name];
+            ASSERT(slot.mType == 0);
+            slot.mType = type;
+            slot.mIndex = mSlotCount++; // starts at 0.
+            return slot;
+        }
+        
+        const JSSlot& getSlot(const String& name)
+        {
+            return mSlots[name];
+        }
+        
+        bool hasSlot(const String& name)
+        {
+            return (mSlots.find(name) != mSlots.end());
+        }
+        
+        JSSlots& getSlots()
+        {
+            return mSlots;
+        }
+        
+        uint32 getSlotCount()
+        {
+            return mSlotCount;
+        }
+        
+        /**
+         * Define a static/class variable.
+         */
+        const JSSlot& defineStatic(const String& name, JSType* type)
+        {
+            JSSlot& slot = mStaticSlots[name];
+            ASSERT(slot.mType == 0);
+            slot.mType = type;
+            slot.mIndex = mStaticCount++;
+            return slot;
+        }
+
+        const JSSlot& defineConstructor(const String& name)
+        {
+            JSSlot& slot = mStaticSlots[name];
+            ASSERT(slot.mType == 0);
+            slot.mType = &JSTypes::Function_Type;
+            slot.mIndex = mStaticCount++;
+            slot.mFlags = JSSlot::kIsConstructor;
+            return slot;
+        }
+        
+        const JSSlot& getStatic(const String& name)
+        {
+            return mStaticSlots[name];
+        }
+        
+        bool hasStatic(const String& name, JSType*& type, bool &isConstructor)
+        {
+            JSSlots::const_iterator i = mStaticSlots.find(name);
+            if (i != mStaticSlots.end()) {
+                type = i->second.mType;
+                isConstructor = i->second.isConstructor();
+                return true;
+            }
+            return false;
+        }
+
+        bool hasStatic(const String& name)
+        {
+            return (mStaticSlots.find(name) != mStaticSlots.end());
+        }
+
+        bool complete()
+        {
+            mStaticData = new JSValue[mStaticCount];
+            return (mStaticData != 0);
+        }
+
+        JSValue& operator[] (uint32 index)
+        {
+            return mStaticData[index];
+        }
+        
+        virtual void printProperties(Formatter& f)
+        {
+            f << "Properties:\n";
+            JSObject::printProperties(f);
+            f << "Statics:\n";
+            printStatics(f);
+        }
+
+        void printStatics(Formatter& f)
+        {
+            JSClass* superClass = getSuperClass();
+            if (superClass) superClass->printStatics(f);
+            for (JSSlots::iterator i = mStaticSlots.begin(), end = mStaticSlots.end(); i != end; ++i) {
+                f << i->first << " : " << mStaticData[i->second.mIndex]  << "\n";
+            }
+        }
+
+        void defineMethod(const String& name, JSFunction *f)
+        {
+            uint32 slot;
+            if (hasMethod(name, slot))
+                mMethods[slot] = MethodEntry(name, f);
+            else
+                mMethods.push_back(MethodEntry(name, f));
+        }
+
+        bool hasMethod(const String& name, uint32& index)
+        {
+            JSMethods::iterator end = mMethods.end();
+            for (JSMethods::iterator i = mMethods.begin(); i != end; i++) {
+                if (i->first == name) {
+                    index = i - mMethods.begin();
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        JSFunction* getMethod(uint32 index)
+        {
+            return mMethods[index].second;
+        }
+    };
+
+    /**
+     * Represents an instance of a JSClass.
+     */
+    class JSInstance : public JSObject {
+    protected:
+        JSValue mSlots[1];
+    public:
+        void* operator new(size_t n, JSClass* thisClass)
+        {
+            uint32 slotCount = thisClass->getSlotCount();
+            if (slotCount > 0) n += sizeof(JSValue) * (slotCount - 1);
+            return gc_base::operator new(n);
+        }
+        
+#if !defined(XP_MAC)
+        void operator delete(void* /*ptr*/, JSClass* /*thisClass*/) {}
+#endif
+        
+        JSInstance(JSClass* thisClass)
+        {
+            mType = thisClass;
+            // initialize extra slots with undefined.
+            uint32 slotCount = thisClass->getSlotCount();
+            if (slotCount > 0) {
+                std::uninitialized_fill(&mSlots[1], &mSlots[1] + (slotCount - 1),
+                                        JSTypes::kUndefinedValue);
+            }
+            // for grins, use the prototype link to access methods.
+            setPrototype(thisClass->getScope());
+        }
+        
+        JSFunction* getMethod(uint32 index)
+        {
+            return getClass()->getMethod(index);
+        }
+
+        JSClass* getClass()
+        {
+            return static_cast<JSClass*>(mType);
+        }
+        
+        JSValue& operator[] (uint32 index)
+        {
+            return mSlots[index];
+        }
+
+        virtual void printProperties(Formatter& f)
+        {
+            f << "Properties:\n";
+            JSObject::printProperties(f);
+            f << "Slots:\n";
+            printSlots(f, getClass());
+        }
+
+    private:
+        void printSlots(Formatter& f, JSClass* thisClass)
+        {
+            JSClass* superClass = thisClass->getSuperClass();
+            if (superClass) printSlots(f, superClass);
+            JSSlots& slots = thisClass->getSlots();
+            for (JSSlots::iterator i = slots.begin(), end = slots.end(); i != end; ++i) {
+                f << i->first << " : " <<  mSlots[i->second.mIndex]  << "\n";
+            }
+        }
+    };
+    
+} /* namespace JSClasses */
+} /* namespace JavaScript */
+
+#endif /* jsclasses_h */

mozilla/js/js2/jsmath.cpp

@@ -0,0 +1,208 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#include <math.h>
+#include "jsmath.h"
+
+namespace JavaScript {
+namespace JSMathClass {
+
+using namespace JSTypes;
+
+#ifndef M_E
+#define M_E		2.7182818284590452354
+#endif
+#ifndef M_LOG2E
+#define M_LOG2E		1.4426950408889634074
+#endif
+#ifndef M_LOG10E
+#define M_LOG10E	0.43429448190325182765
+#endif
+#ifndef M_LN2
+#define M_LN2		0.69314718055994530942
+#endif
+#ifndef M_LN10
+#define M_LN10		2.30258509299404568402
+#endif
+#ifndef M_PI
+#define M_PI		3.14159265358979323846
+#endif
+#ifndef M_SQRT2
+#define M_SQRT2		1.41421356237309504880
+#endif
+#ifndef M_SQRT1_2
+#define M_SQRT1_2	0.70710678118654752440
+#endif
+
+
+/*
+    Concept copied from SpiderMonkey -
+    fd_XXX needs to be defined either as a call to the fdlibm routine
+    or the native C library routine depending on the platform
+*/
+
+#define JS_USE_FDLIBM_MATH 0
+
+
+#if !JS_USE_FDLIBM_MATH
+/*
+ * Use system provided math routines.
+ */
+
+
+#define fd_acos acos
+#define fd_asin asin
+#define fd_atan atan
+#define fd_atan2 atan2
+#define fd_ceil ceil
+#define fd_copysign copysign
+#define fd_cos cos
+#define fd_exp exp
+#define fd_fabs fabs
+#define fd_floor floor
+#define fd_fmod fmod
+#define fd_log log
+#define fd_pow pow
+#define fd_sin sin
+#define fd_sqrt sqrt
+#define fd_tan tan
+
+#endif
+
+JSValue math_abs(Context *cx, const JSValues& argv)
+{
+    if (argv.size() > 0) {
+        JSValue num = argv[1].toNumber();
+        if (num.isNaN()) return num;
+        if (num.isNegativeZero()) return kPositiveZero;
+        if (num.isNegativeInfinity()) return kPositiveInfinity;
+        if (num.f64 < 0) return JSValue(-num.f64);
+        return num;
+    }
+    return kUndefinedValue;
+}
+
+JSValue math_acos(Context *cx, const JSValues& argv)
+{
+    if (argv.size() > 0) {
+        JSValue num = argv[1].toNumber();
+        return JSValue(fd_acos(num.f64));
+    }
+    return kUndefinedValue;
+}
+
+JSValue math_asin(Context *cx, const JSValues& argv)
+{
+    if (argv.size() > 0) {
+        JSValue num = argv[1].toNumber();
+        return JSValue(fd_asin(num.f64));
+    }
+    return kUndefinedValue;
+}
+
+JSValue math_atan(Context *cx, const JSValues& argv)
+{
+    if (argv.size() > 0) {
+        JSValue num = argv[1].toNumber();
+        return JSValue(fd_atan(num.f64));
+    }
+    return kUndefinedValue;
+}
+
+JSValue math_atan2(Context *cx, const JSValues& argv)
+{
+    if (argv.size() > 1) {
+        JSValue num1 = argv[1].toNumber();
+        JSValue num2 = argv[1].toNumber();
+        return JSValue(fd_atan2(num1.f64, num2.f64));
+    }
+    return kUndefinedValue;
+}
+
+JSValue math_ceil(Context *cx, const JSValues& argv)
+{
+    if (argv.size() > 0) {
+        JSValue num = argv[1].toNumber();
+        return JSValue(fd_ceil(num.f64));
+    }
+    return kUndefinedValue;
+}
+
+struct MathFunctionEntry {
+    char *name;
+    JSNativeFunction::JSCode fn;
+} MathFunctions[] = {
+    { "abs",     math_abs },
+    { "acos",    math_acos },
+    { "asin",    math_asin },
+    { "atan",    math_atan },
+    { "atan2",   math_atan2 },
+    { "ceil",    math_acos },
+    { "acos",    math_acos },
+    { "acos",    math_acos }
+};
+
+struct MathConstantEntry {
+    char *name;
+    double value;
+} MathConstants[] = {
+    { "E",           M_E },
+    { "LOG2E",       M_LOG2E },
+    { "LOG10E",      M_LOG10E },
+    { "LN2",         M_LN2 },
+    { "LN10",        M_LN10 },
+    { "PI",          M_PI },
+    { "SQRT2",       M_SQRT2 },
+    { "SQRT1_2",     M_SQRT1_2 }
+};
+
+// There is no constructor for Math, we simply initialize
+//  the properties of the Math object
+void JSMath::initMathObject(JSScope *g)
+{
+    int i;
+    JSMath *m = new JSMath();
+    m->setClass(new JSString("Math"));
+
+    for (i = 0; i < sizeof(MathFunctions) / sizeof(MathFunctionEntry); i++)
+        m->setProperty(widenCString(MathFunctions[i].name), JSValue(new JSNativeFunction(MathFunctions[i].fn) ) );
+
+    for (i = 0; i < sizeof(MathConstants) / sizeof(MathConstantEntry); i++)
+        m->setProperty(widenCString(MathConstants[i].name), JSValue(MathConstants[i].value) );
+
+    g->setProperty(widenCString("Math"), JSValue(m));
+    
+}
+
+} /* JSMathClass */
+} /* JavaScript */

mozilla/js/js2/jsmath.h

@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifndef jsmath_h
+#define jsmath_h
+
+#include "jstypes.h"
+
+namespace JavaScript {
+namespace JSMathClass {
+
+    using JSTypes::JSObject;
+    using JSTypes::JSString;
+    using JSTypes::JSScope;
+
+    class JSMath : public JSObject {
+    private:
+        JSMath()    { }
+    public:
+        static void initMathObject(JSScope *g);
+    };
+    
+
+}   /* JSMathClass */
+}   /* JavaScript */
+
+
+#endif jsmath_h

mozilla/js/js2/jstypes.cpp

@@ -0,0 +1,775 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#include "jstypes.h"
+#include "jsclasses.h"
+#include "numerics.h"
+#include "icodegenerator.h"
+#include "interpreter.h"
+
+namespace JavaScript {
+namespace JSTypes {
+
+using namespace JSClasses;
+using namespace Interpreter;
+
+/********** Object Object Stuff **************************/
+
+JSValue object_toString(Context *cx, const JSValues& argv)
+{
+    if (argv.size() > 0) {
+        JSString *s = new JSString("[object ");
+        JSValue theThis = argv[0];
+        ASSERT(theThis.isObject());
+        s->append(theThis.object->getClass());
+        s->append("]");
+        return JSValue(s);
+    }
+    return kUndefinedValue;
+}
+
+JSValue objectConstructor(Context *cx, const JSValues& argv)
+{
+    ASSERT(argv.size() > 0);
+    JSValue theThis = argv[0];
+    
+    // the prototype and class have been established already
+
+    return theThis;
+}
+
+struct ObjectFunctionEntry {
+    char *name;
+    JSNativeFunction::JSCode fn;
+} ObjectFunctions[] = {
+    { "toString",     object_toString },
+};
+
+
+JSObject *JSObject::objectPrototypeObject = JSObject::initJSObject();
+String JSObject::ObjectString = widenCString("Object");
+
+// This establishes the ur-prototype, there's a timing issue
+// here - the JSObject static initializers have to run before
+// any other JSObject objects are constructed.
+JSObject *JSObject::initJSObject()
+{
+    JSObject *result = new JSObject();
+
+    for (int i = 0; i < sizeof(ObjectFunctions) / sizeof(ObjectFunctionEntry); i++)
+        result->setProperty(widenCString(ObjectFunctions[i].name), JSValue(new JSNativeFunction(ObjectFunctions[i].fn) ) );
+
+    return result;
+}
+
+// Install the 'Object' constructor into the scope, mostly irrelevant since making 
+// a new JSObject does all the work of setting the prototype and [[class]] values.
+void JSObject::initObjectObject(JSScope *g)
+{
+    JSNativeFunction *objCon = new JSNativeFunction(objectConstructor);
+
+    objCon->setProperty(widenCString("prototype"), JSValue(objectPrototypeObject));
+    
+
+
+
+    g->setProperty(ObjectString, JSValue(objCon));
+}
+
+
+
+/********** Function Object Stuff **************************/
+
+// An empty function that returns undefined
+JSValue functionPrototypeFunction(Context *cx, const JSValues& argv)
+{
+    return kUndefinedValue;
+}
+
+
+JSValue function_constructor(Context *cx, const JSValues& argv)
+{
+    // build a function from the arguments into the this.
+    ASSERT(argv.size() > 0);
+    JSValue theThis = argv[0];
+    ASSERT(theThis.isObject());
+
+    if (argv.size() == 2) {        
+        JSValue s = JSValue::valueToString(argv[1]);
+        theThis = new JSFunction(cx->compile((String)(*s.string)));
+    }
+
+    return theThis;
+}
+
+JSValue function_toString(Context *cx, const JSValues& argv)
+{
+    return JSValue(new JSString("function XXX() { }" ));
+}
+JSValue function_apply(Context *cx, const JSValues& argv)
+{
+    // XXX
+    return kUndefinedValue;
+}
+JSValue function_call(Context *cx, const JSValues& argv)
+{
+    // XXX
+    return kUndefinedValue;
+}
+
+
+
+String JSFunction::FunctionString = widenCString("Function");
+JSObject *JSFunction::functionPrototypeObject = NULL;   // the 'original Function prototype object'
+
+struct FunctionFunctionEntry {
+    char *name;
+    JSNativeFunction::JSCode fn;
+} FunctionFunctions[] = {
+    { "constructor",    function_constructor },
+    { "toString",       function_toString },
+    { "apply",          function_apply },
+    { "call",           function_call },
+};
+
+void JSFunction::initFunctionObject(JSScope *g)
+{
+    // first build the Function Prototype Object
+    functionPrototypeObject = new JSNativeFunction(functionPrototypeFunction);
+    for (int i = 0; i < sizeof(FunctionFunctions) / sizeof(FunctionFunctionEntry); i++)
+        functionPrototypeObject->setProperty(widenCString(FunctionFunctions[i].name), JSValue(new JSNativeFunction(FunctionFunctions[i].fn) ) );
+
+    // now the Function Constructor Object
+    JSNativeFunction *functionConstructorObject = new JSNativeFunction(function_constructor);
+    functionConstructorObject->setPrototype(functionPrototypeObject);
+    functionConstructorObject->setProperty(widenCString("length"), JSValue((int32)1));
+    functionConstructorObject->setProperty(widenCString("prototype"), JSValue(functionPrototypeObject));
+
+    // This is interesting - had to use defineVariable here to specify a type because
+    // when left as Any_Type (via setProperty), the Function predefined type interacted
+    // badly with this value. (I think setProperty perhaps should have reset the entry
+    // in mTypes) (?)
+    g->defineVariable(FunctionString, &Function_Type, JSValue(functionConstructorObject));
+}
+
+/**************************************************************************************/
+
+JSType Any_Type = JSType(widenCString("any"), NULL);
+JSType Integer_Type = JSType(widenCString("Integer"), &Any_Type);
+JSType Number_Type = JSType(widenCString("Number"), &Integer_Type);
+JSType Character_Type = JSType(widenCString("Character"), &Any_Type);
+JSType String_Type = JSType(widenCString("String"), &Character_Type);
+JSType Function_Type = JSType(widenCString("Function"), &Any_Type);
+JSType Array_Type = JSType(widenCString("Array"), &Any_Type);
+JSType Type_Type = JSType(widenCString("Type"), &Any_Type);
+JSType Boolean_Type = JSType(widenCString("Boolean"), &Any_Type);
+JSType Null_Type = JSType(widenCString("Null"), &Any_Type);
+JSType Void_Type = JSType(widenCString("void"), &Any_Type);
+JSType None_Type = JSType(widenCString("none"), &Any_Type);
+
+
+#ifdef IS_LITTLE_ENDIAN
+#define JSDOUBLE_HI32(x)        (((uint32 *)&(x))[1])
+#define JSDOUBLE_LO32(x)        (((uint32 *)&(x))[0])
+#else
+#define JSDOUBLE_HI32(x)        (((uint32 *)&(x))[0])
+#define JSDOUBLE_LO32(x)        (((uint32 *)&(x))[1])
+#endif
+
+#define JSDOUBLE_HI32_SIGNBIT   0x80000000
+#define JSDOUBLE_HI32_EXPMASK   0x7ff00000
+#define JSDOUBLE_HI32_MANTMASK  0x000fffff
+
+#define JSDOUBLE_IS_NaN(x)                                                    \
+    ((JSDOUBLE_HI32(x) & JSDOUBLE_HI32_EXPMASK) == JSDOUBLE_HI32_EXPMASK &&   \
+     (JSDOUBLE_LO32(x) || (JSDOUBLE_HI32(x) & JSDOUBLE_HI32_MANTMASK)))
+
+#define JSDOUBLE_IS_INFINITE(x)                                               \
+    ((JSDOUBLE_HI32(x) & ~JSDOUBLE_HI32_SIGNBIT) == JSDOUBLE_HI32_EXPMASK &&   \
+     !JSDOUBLE_LO32(x))
+
+#define JSDOUBLE_IS_FINITE(x)                                                 \
+    ((JSDOUBLE_HI32(x) & JSDOUBLE_HI32_EXPMASK) != JSDOUBLE_HI32_EXPMASK)
+
+#define JSDOUBLE_IS_NEGZERO(d)  (JSDOUBLE_HI32(d) == JSDOUBLE_HI32_SIGNBIT && \
+				 JSDOUBLE_LO32(d) == 0)
+
+
+// the canonical undefined value, etc.
+const JSValue kUndefinedValue;
+const JSValue kNaNValue = JSValue(nan);
+const JSValue kTrueValue = JSValue(true);
+const JSValue kFalseValue = JSValue(false);
+const JSValue kNullValue = JSValue((JSObject*)NULL);
+const JSValue kNegativeZero = JSValue(-0.0);
+const JSValue kPositiveZero = JSValue(0.0);
+const JSValue kNegativeInfinity = JSValue(negativeInfinity);
+const JSValue kPositiveInfinity = JSValue(positiveInfinity);
+
+
+const JSType *JSValue::getType() const
+{
+    switch (tag) {
+    case JSValue::i32_tag:
+        return &Integer_Type;
+    case JSValue::u32_tag:
+        return &Integer_Type;
+    case JSValue::integer_tag:
+        return &Integer_Type;
+    case JSValue::f64_tag:
+        return &Number_Type;
+    case JSValue::object_tag:
+        {
+            //
+            // XXX why isn't there a class for Object? XXX
+            //
+            JSClass *clazz = dynamic_cast<JSClass *>(object->getType());
+            if (clazz) 
+                return clazz;
+            else
+                return &Any_Type;
+        }
+    case JSValue::array_tag:
+        return &Array_Type;
+    case JSValue::function_tag:
+        return &Function_Type;
+    case JSValue::string_tag:
+        return &String_Type;
+    case JSValue::boolean_tag:
+        return &Boolean_Type;
+    case JSValue::undefined_tag:
+        return &Void_Type;
+    case JSValue::type_tag:
+        return &Type_Type;
+    default:
+        NOT_REACHED("Bad tag");
+        return &None_Type;
+    }
+}
+
+bool JSValue::isNaN() const
+{
+    ASSERT(isNumber());
+    switch (tag) {
+    case i32_tag:
+    case u32_tag:
+        return false;
+    case integer_tag:
+    case f64_tag:
+        return JSDOUBLE_IS_NaN(f64);
+    default:
+        NOT_REACHED("Broken compiler?");
+        return true;
+    }
+}
+              
+bool JSValue::isNegativeInfinity() const
+{
+    ASSERT(isNumber());
+    switch (tag) {
+    case i32_tag:
+    case u32_tag:
+        return false;
+    case integer_tag:
+    case f64_tag:
+        return (f64 < 0) && JSDOUBLE_IS_INFINITE(f64);
+    default:
+        NOT_REACHED("Broken compiler?");
+        return true;
+    }
+}
+              
+bool JSValue::isPositiveInfinity() const
+{
+    ASSERT(isNumber());
+    switch (tag) {
+    case i32_tag:
+    case u32_tag:
+        return false;
+    case integer_tag:
+    case f64_tag:
+        return (f64 > 0) && JSDOUBLE_IS_INFINITE(f64);
+    default:
+        NOT_REACHED("Broken compiler?");
+        return true;
+    }
+}
+              
+bool JSValue::isNegativeZero() const
+{
+    ASSERT(isNumber());
+    switch (tag) {
+    case i32_tag:
+    case u32_tag:
+        return false;
+    case integer_tag:
+    case f64_tag:
+        return JSDOUBLE_IS_NEGZERO(f64);
+    default:
+        NOT_REACHED("Broken compiler?");
+        return true;
+    }
+}
+              
+bool JSValue::isPositiveZero() const
+{
+    ASSERT(isNumber());
+    switch (tag) {
+    case i32_tag:
+        return (i32 == 0);
+    case u32_tag:
+        return (u32 == 0);
+    case integer_tag:
+    case f64_tag:
+        return (f64 == 0.0) && !JSDOUBLE_IS_NEGZERO(f64);
+    default:
+        NOT_REACHED("Broken compiler?");
+        return true;
+    }
+}
+              
+int JSValue::operator==(const JSValue& value) const
+{
+    if (this->tag == value.tag) {
+        #define CASE(T) case T##_tag: return (this->T == value.T)
+        switch (tag) {
+        CASE(i8); CASE(u8);
+        CASE(i16); CASE(u16);
+        CASE(i32); CASE(u32); CASE(f32);
+        CASE(i64); CASE(u64); CASE(f64);
+        CASE(object); CASE(array); CASE(function); CASE(string);
+        CASE(type); CASE(boolean);
+        #undef CASE
+        case integer_tag : return (this->f64 == value.f64);
+        // question:  are all undefined values equal to one another?
+        case undefined_tag: return 1;
+        }
+    }
+    return 0;
+}
+
+Formatter& operator<<(Formatter& f, JSObject& obj)
+{
+    obj.printProperties(f);
+    return f;
+}
+
+void JSObject::printProperties(Formatter& f)
+{
+    for (JSProperties::const_iterator i = mProperties.begin(); i != mProperties.end(); i++) {
+        f << (*i).first << " : " << (*i).second;
+        f << "\n";
+    }
+}
+
+Formatter& operator<<(Formatter& f, const JSValue& value)
+{
+    switch (value.tag) {
+    case JSValue::i32_tag:
+        f << float64(value.i32);
+        break;
+    case JSValue::u32_tag:
+        f << float64(value.u32);
+        break;
+    case JSValue::integer_tag:
+    case JSValue::f64_tag:
+        f << value.f64;
+        break;
+    case JSValue::object_tag:
+        printFormat(f, "Object @ 0x%08X\n", value.object);
+        f << *value.object;
+        break;
+    case JSValue::array_tag:
+        printFormat(f, "Array @ 0x%08X", value.object);
+        break;
+    case JSValue::function_tag:
+        printFormat(f, "Function @ 0x%08X", value.object);
+        break;
+    case JSValue::string_tag:
+        f << *value.string;
+        break;
+    case JSValue::boolean_tag:
+        f << ((value.boolean) ? "true" : "false");
+        break;
+    case JSValue::undefined_tag:
+        f << "undefined";
+        break;
+    case JSValue::type_tag:
+        printFormat(f, "Type @ 0x%08X\n", value.type);
+        f << *value.type;
+        break;
+    default:
+        NOT_REACHED("Bad tag");
+    }
+    return f;
+}
+
+JSValue JSValue::toPrimitive(ECMA_type /*hint*/) const
+{
+    JSObject *obj;
+    switch (tag) {
+    case i32_tag:
+    case u32_tag:
+    case integer_tag:
+    case f64_tag:
+    case string_tag:
+    case boolean_tag:
+    case undefined_tag:
+        return *this;
+
+    case object_tag:
+        obj = object;
+        break;
+    case array_tag:
+        obj = array;
+        break;
+    case function_tag:
+        obj = function;
+        break;
+
+    default:
+        NOT_REACHED("Bad tag");
+        return kUndefinedValue;
+    }
+
+    const JSValue &toString = obj->getProperty(widenCString("toString"));
+    if (toString.isObject()) {
+        if (toString.isFunction()) {
+        }
+        else    // right? The spec doesn't say
+            throw new JSException("Runtime error from toPrimitive");    // XXX
+    }
+
+    const JSValue &valueOf = obj->getProperty(widenCString("valueOf"));
+    if (!valueOf.isObject())
+        throw new JSException("Runtime error from toPrimitive");    // XXX
+    
+    return kUndefinedValue;
+    
+}
+
+
+JSValue JSValue::valueToString(const JSValue& value) // can assume value is not a string
+{
+    const char* chrp;
+    char buf[dtosStandardBufferSize];
+    switch (value.tag) {
+    case i32_tag:
+        chrp = doubleToStr(buf, dtosStandardBufferSize, value.i32, dtosStandard, 0);
+        break;
+    case u32_tag:
+        chrp = doubleToStr(buf, dtosStandardBufferSize, value.u32, dtosStandard, 0);
+        break;
+    case integer_tag:
+    case f64_tag:
+        chrp = doubleToStr(buf, dtosStandardBufferSize, value.f64, dtosStandard, 0);
+        break;
+    case object_tag:
+        chrp = "object";
+        break;
+    case array_tag:
+        chrp = "array";
+        break;
+    case function_tag:
+        chrp = "function";
+        break;
+    case string_tag:
+        return value;
+    case boolean_tag:
+        chrp = (value.boolean) ? "true" : "false";
+        break;
+    case undefined_tag:
+        chrp = "undefined";
+        break;
+    default:
+        NOT_REACHED("Bad tag");
+    }
+    return JSValue(new JSString(chrp));
+}
+
+JSValue JSValue::valueToNumber(const JSValue& value) // can assume value is not a number
+{
+    switch (value.tag) {
+    case i32_tag:
+        return JSValue((float64)value.i32);
+    case u32_tag:
+        return JSValue((float64)value.u32);
+    case integer_tag:
+    case f64_tag:
+        return value;
+    case string_tag: 
+        {
+            JSString* str = value.string;
+            const char16 *numEnd;
+	        double d = stringToDouble(str->begin(), str->end(), numEnd);
+            return JSValue(d);
+        }
+    case object_tag:
+    case array_tag:
+    case function_tag:
+        // XXX more needed :
+        // toNumber(toPrimitive(hint Number))
+        return kUndefinedValue;
+    case boolean_tag:
+        return JSValue((value.boolean) ? 1.0 : 0.0);
+    case undefined_tag:
+        return kNaNValue;
+    default:
+        NOT_REACHED("Bad tag");
+        return kUndefinedValue;
+    }
+}
+
+JSValue JSValue::valueToInteger(const JSValue& value)
+{
+    JSValue result = valueToNumber(value);
+    ASSERT(result.tag == f64_tag);
+    result.tag = i64_tag;
+    bool neg = (result.f64 < 0);
+    result.f64 = floor((neg) ? -result.f64 : result.f64);
+    result.f64 = (neg) ? -result.f64 : result.f64;
+    return result;
+}
+
+
+JSValue JSValue::valueToBoolean(const JSValue& value)
+{
+    switch (value.tag) {
+    case i32_tag:
+        return JSValue(value.i32 != 0);
+    case u32_tag:
+        return JSValue(value.u32 != 0);
+    case integer_tag:
+    case f64_tag:
+        return JSValue(!(value.f64 == 0.0) || JSDOUBLE_IS_NaN(value.f64));
+    case string_tag: 
+        return JSValue(value.string->length() != 0);
+    case boolean_tag:
+        return value;
+    case object_tag:
+    case array_tag:
+    case function_tag:
+        return kTrueValue;
+    case undefined_tag:
+        return kFalseValue;
+    default:
+        NOT_REACHED("Bad tag");
+        return kUndefinedValue;
+    }
+}
+
+
+static const double two32 = 4294967296.0;
+static const double two31 = 2147483648.0;
+
+JSValue JSValue::valueToInt32(const JSValue& value)
+{
+    double d;
+    switch (value.tag) {
+    case i32_tag:
+        return value;
+    case u32_tag:
+        d = value.u32;
+        break;
+    case integer_tag:
+    case f64_tag:
+        d = value.f64;
+        break;
+    case string_tag: 
+        {
+            JSString* str = value.string;
+            const char16 *numEnd;
+	        d = stringToDouble(str->begin(), str->end(), numEnd);
+        }
+        break;
+    case boolean_tag:
+        return JSValue((int32)((value.boolean) ? 1 : 0));
+    case object_tag:
+    case array_tag:
+    case undefined_tag:
+        // toNumber(toPrimitive(hint Number))
+        return kUndefinedValue;
+    default:
+        NOT_REACHED("Bad tag");
+        return kUndefinedValue;
+    }
+    if ((d == 0.0) || !JSDOUBLE_IS_FINITE(d) )
+        return JSValue((int32)0);
+    d = fmod(d, two32);
+    d = (d >= 0) ? d : d + two32;
+    if (d >= two31)
+	    return JSValue((int32)(d - two32));
+    else
+	    return JSValue((int32)d);
+    
+}
+
+JSValue JSValue::valueToUInt32(const JSValue& value)
+{
+    double d;
+    switch (value.tag) {
+    case i32_tag:
+        return JSValue((uint32)value.i32);
+    case u32_tag:
+        return value;
+    case f64_tag:
+        d = value.f64;
+        break;
+    case string_tag: 
+        {
+            JSString* str = value.string;
+            const char16 *numEnd;
+	        d = stringToDouble(str->begin(), str->end(), numEnd);
+        }
+        break;
+    case boolean_tag:
+        return JSValue((uint32)((value.boolean) ? 1 : 0));
+    case object_tag:
+    case array_tag:
+    case undefined_tag:
+        // toNumber(toPrimitive(hint Number))
+        return kUndefinedValue;
+    default:
+        NOT_REACHED("Bad tag");
+        return kUndefinedValue;
+    }
+    if ((d == 0.0) || !JSDOUBLE_IS_FINITE(d))
+        return JSValue((uint32)0);
+    bool neg = (d < 0);
+    d = floor(neg ? -d : d);
+    d = neg ? -d : d;
+    d = fmod(d, two32);
+    d = (d >= 0) ? d : d + two32;
+    return JSValue((uint32)d);
+}
+
+
+JSValue JSValue::convert(JSType *toType)
+{
+    if (toType == &Any_Type)    // yuck, something wrong with this
+                                // maybe the base types should be 
+                                // a family of classes, not just instances
+                                // of JSType ???
+        return *this;
+    else if (toType == &Integer_Type)
+        return valueToInteger(*this);
+    else {
+        JSClass *toClass = dynamic_cast<JSClass *>(toType);
+        if (toClass) {
+            if (tag == object_tag) {
+                JSClass *fromClass = dynamic_cast<JSClass *>(object->getType());
+                if (fromClass) {
+                    while (fromClass != toClass) {
+                        fromClass = fromClass->getSuperClass();
+                        if (fromClass == NULL)
+                            throw new JSException("Can't cast to unrelated class");
+                    }
+                    return *this;
+                }
+                else
+                    throw new JSException("Can't cast a generic object to a class");
+            }
+            else
+                throw new JSException("Can't cast a non-object to a class");
+        }
+    }
+    return kUndefinedValue;
+}
+
+
+JSFunction::~JSFunction()
+{
+    delete mICode;
+}
+
+JSString::JSString(const String& str)
+{
+    size_t n = str.size();
+    resize(n);
+    traits_type::copy(begin(), str.begin(), n);
+}
+
+JSString::JSString(const String* str)
+{
+    size_t n = str->size();
+    resize(n);
+    traits_type::copy(begin(), str->begin(), n);
+}
+
+JSString::JSString(const char* str)
+{
+    size_t n = ::strlen(str);
+    resize(n);
+    std::transform(str, str + n, begin(), JavaScript::widen);
+}
+
+void JSString::append(const char* str)
+{
+    size_t n = ::strlen(str);
+    size_t oldSize = size();
+    resize(oldSize + n);
+    std::transform(str, str + n, begin() + oldSize, JavaScript::widen);
+}
+
+void JSString::append(const JSStringBase* str)
+{
+    size_t n = str->size();
+    size_t oldSize = size();
+    resize(oldSize + n);
+    traits_type::copy(begin() + oldSize, str->begin(), n);
+}
+
+JSString::operator String()
+{
+    return String(begin(), size());
+}
+
+
+// # of sub-type relationship between this type and the other type 
+// (== MAX_INT if other is not a base type)
+
+int32 JSType::distance(const JSType *other) const
+{
+    if (other == this) 
+        return 0; 
+    if (mBaseType == NULL)
+        return NoRelation;
+    int32 baseDistance = mBaseType->distance(other);
+    if (baseDistance != NoRelation)
+        ++baseDistance;
+    return baseDistance;
+}
+
+
+} /* namespace JSTypes */    
+} /* namespace JavaScript */

mozilla/js/js2/jstypes.h

@@ -0,0 +1,579 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifndef jstypes_h
+#define jstypes_h
+
+#include "utilities.h"
+#include "gc_allocator.h"
+#include <vector>
+#include <map>
+#include <stack>
+
+
+/* forward declare classes from JavaScript::ICG */
+namespace JavaScript {
+namespace ICG {
+    class ICodeModule;
+} /* namespace ICG */
+namespace Interpreter {
+    class Context;
+} /* namespace Interpreter */
+} /* namespace JavaScript */
+
+namespace JavaScript {
+namespace JSTypes {
+
+    using ICG::ICodeModule;
+    using Interpreter::Context;
+    
+    class JSObject;
+    class JSArray;
+    class JSFunction;
+    class JSScope;
+    class JSString;
+    class JSType;
+    class Context;
+    
+    /**
+     * All JavaScript data types.
+     */        
+    struct JSValue {
+        union {
+            int8 i8;
+            uint8 u8;
+            int16 i16;
+            uint16 u16;
+            int32 i32;
+            uint32 u32;
+            int64 i64;
+            uint64 u64;
+            float32 f32;
+            float64 f64;
+            JSObject* object;
+            JSArray* array;
+            JSFunction *function;
+            JSString *string;
+            JSType *type;
+            bool boolean;
+        };
+        
+        /* These are the ECMA types, for use in 'toPrimitive' calls */
+        enum ECMA_type {
+            Undefined, Null, Boolean, Number, Object, String, 
+            NoHint
+        };
+
+        enum {
+            i8_tag, u8_tag,
+            i16_tag, u16_tag,
+            i32_tag, u32_tag,
+            i64_tag, u64_tag,
+            f32_tag, f64_tag,
+            integer_tag,
+            object_tag, array_tag, function_tag, string_tag, boolean_tag, type_tag,
+            undefined_tag
+        } tag;
+        
+        JSValue() : f64(0.0), tag(undefined_tag) {}
+        explicit JSValue(int32 i32) : i32(i32), tag(i32_tag) {}
+        explicit JSValue(uint32 u32) : u32(u32), tag(u32_tag) {}
+        explicit JSValue(float64 f64) : f64(f64), tag(f64_tag) {}
+        explicit JSValue(JSObject* object) : object(object), tag(object_tag) {}
+        explicit JSValue(JSArray* array) : array(array), tag(array_tag) {}
+        explicit JSValue(JSFunction* function) : function(function), tag(function_tag) {}
+        explicit JSValue(JSString* string) : string(string), tag(string_tag) {}
+        explicit JSValue(bool boolean) : boolean(boolean), tag(boolean_tag) {}
+        explicit JSValue(JSType* type) : type(type), tag(type_tag) {}
+
+        int32& operator=(int32 i32)                     { return (tag = i32_tag, this->i32 = i32); }
+        uint32& operator=(uint32 u32)                   { return (tag = u32_tag, this->u32 = u32); }
+        float64& operator=(float64 f64)                 { return (tag = f64_tag, this->f64 = f64); }
+        JSObject*& operator=(JSObject* object)          { return (tag = object_tag, this->object = object); }
+        JSArray*& operator=(JSArray* array)             { return (tag = array_tag, this->array = array); }
+        JSFunction*& operator=(JSFunction* function)    { return (tag = function_tag, this->function = function); }
+        JSString*& operator=(JSString* string)          { return (tag = string_tag, this->string = string); }
+        bool& operator=(bool boolean)                   { return (tag = boolean_tag, this->boolean = boolean); }
+        JSType*& operator=(JSType* type)                { return (tag = type_tag, this->type = type); }
+        
+        bool isFunction() const                         { return (tag == function_tag); }
+        bool isObject() const                           { return ((tag == object_tag) || (tag == function_tag) || (tag == array_tag) || (tag == type_tag)); }
+        bool isString() const                           { return (tag == string_tag); }
+        bool isBoolean() const                          { return (tag == boolean_tag); }
+        bool isNumber() const                           { return (tag == f64_tag) || (tag == integer_tag); }
+
+                                                        /* this is correct wrt ECMA, The i32 & u32 kinds
+                                                           will have to be converted (to doubles?) anyway because
+                                                           we can't have overflow happening in generic arithmetic */
+
+        bool isUndefined() const                        { return (tag == undefined_tag); }
+        bool isNull() const                             { return ((tag == object_tag) && (this->object == NULL)); }
+        bool isNaN() const;
+        bool isNegativeInfinity() const;
+        bool isPositiveInfinity() const;
+        bool isNegativeZero() const;
+        bool isPositiveZero() const;
+        bool isType() const                             { return (tag == type_tag); }
+
+        JSValue toString() const                        { return (isString() ? *this : valueToString(*this)); }
+        JSValue toNumber() const                        { return (isNumber() ? *this : valueToNumber(*this)); }
+        JSValue toInt32() const                         { return ((tag == i32_tag) ? *this : valueToInt32(*this)); }
+        JSValue toUInt32() const                        { return ((tag == u32_tag) ? *this : valueToUInt32(*this)); }
+        JSValue toBoolean() const                       { return ((tag == boolean_tag) ? *this : valueToBoolean(*this)); }
+
+        JSValue toPrimitive(ECMA_type hint = NoHint) const;
+
+        JSValue convert(JSType *toType);
+
+        
+        static JSValue valueToString(const JSValue& value);
+        static JSValue valueToNumber(const JSValue& value);
+        static JSValue valueToInteger(const JSValue& value);
+        static JSValue valueToInt32(const JSValue& value);
+        static JSValue valueToUInt32(const JSValue& value);
+        static JSValue valueToBoolean(const JSValue& value);
+
+
+        const JSType *getType() const;                  // map from tag type to JS2 type
+
+        int operator==(const JSValue& value) const;
+    };
+
+    Formatter& operator<<(Formatter& f, const JSValue& value);
+
+#if defined(XP_MAC)
+    // copied from default template parameters in map.
+    typedef gc_allocator<std::pair<const String, JSValue> > gc_map_allocator;
+#elif defined(XP_UNIX)
+    // FIXME: in libg++, they assume the map's allocator is a byte allocator,
+    // which is wrapped in a simple_allocator. this is crap.
+    typedef char _Char[1];
+    typedef gc_allocator<_Char> gc_map_allocator;
+#elif defined(_WIN32)
+    // FIXME: MSVC++'s notion. this is why we had to add _Charalloc().
+    typedef gc_allocator<JSValue> gc_map_allocator;
+#endif        
+        
+    /**
+     * GC-scannable array of values.
+     */
+    typedef std::vector<JSValue, gc_allocator<JSValue> > JSValues;
+
+    extern const JSValue kUndefinedValue;
+    extern const JSValue kNaNValue;
+    extern const JSValue kTrueValue;
+    extern const JSValue kFalseValue;
+    extern const JSValue kNullValue;
+    extern const JSValue kNegativeZero;
+    extern const JSValue kPositiveZero;
+    extern const JSValue kNegativeInfinity;
+    extern const JSValue kPositiveInfinity;
+
+    extern JSType Any_Type;
+    extern JSType Integer_Type;
+    extern JSType Number_Type;
+    extern JSType Character_Type;
+    extern JSType String_Type;
+    extern JSType Function_Type;
+    extern JSType Array_Type;
+    extern JSType Type_Type;
+    extern JSType Boolean_Type;
+    extern JSType Null_Type;
+    extern JSType Void_Type;
+    extern JSType None_Type;
+
+    typedef std::map<String, JSValue, std::less<String>, gc_map_allocator> JSProperties;
+
+    /**
+     * Basic behavior of all JS objects, mapping a name to a value,
+     * with prototype-based inheritance.
+     */
+    class JSObject : public gc_base {
+    protected:
+        JSProperties mProperties;
+        JSObject* mPrototype;
+        JSType* mType;
+        JSString* mClass;       // this is the internal [[Class]] property
+
+        static JSObject *initJSObject();
+        static String ObjectString;
+        static JSObject *objectPrototypeObject;
+
+        void init(JSObject* prototype);
+
+    public:
+        JSObject()                      { init(objectPrototypeObject); }
+        JSObject(JSValue &constructor)  { init(constructor.object->getProperty(widenCString("prototype")).object); }
+        JSObject(JSObject *prototype)   { init(prototype); }
+    
+        static void initObjectObject(JSScope *g);
+
+        bool hasProperty(const String& name)
+        {
+            return (mProperties.count(name) != 0);
+        }
+
+        const JSValue& getProperty(const String& name)
+        {
+            JSProperties::const_iterator i = mProperties.find(name);
+            if (i != mProperties.end())
+                return i->second;
+            if (mPrototype)
+                return mPrototype->getProperty(name);
+            return kUndefinedValue;
+        }
+
+        // return the property AND the object it's found in
+        // (would rather return references, but couldn't get that to work)
+        const JSValue getReference(JSValue &prop, const String& name)
+        {
+            JSProperties::const_iterator i = mProperties.find(name);
+            if (i != mProperties.end()) {
+                prop = i->second;
+                return JSValue(this);
+            }
+            if (mPrototype)
+                return mPrototype->getReference(prop, name);
+            return kUndefinedValue;
+        }
+        
+        JSValue& setProperty(const String& name, const JSValue& value)
+        {
+            return (mProperties[name] = value);
+        }
+        
+        const JSValue& deleteProperty(const String& name)
+        {
+            JSProperties::iterator i = mProperties.find(name);
+            if (i != mProperties.end()) {
+                mProperties.erase(i);
+                return kTrueValue;
+            }
+            if (mPrototype)
+                return mPrototype->deleteProperty(name);
+            return kFalseValue;
+        }
+
+        void setPrototype(JSObject* prototype)
+        {
+            mPrototype = prototype;
+        }
+        
+        JSObject* getPrototype()
+        {
+            return mPrototype;
+        }
+
+        JSType* getType()
+        {
+            return mType;
+        }
+
+        JSString* getClass()
+        {
+            return mClass;
+        }
+
+        void setClass(JSString* s)
+        {
+            mClass = s;
+        }
+
+        virtual void printProperties(Formatter& f);
+    };
+    
+    Formatter& operator<<(Formatter& f, JSObject& obj);
+
+    /**
+     * Private representation of a JavaScript array.
+     */
+    class JSArray : public JSObject {
+        JSValues elements;
+    public:
+        JSArray() : elements(1) {}
+        JSArray(uint32 size) : elements(size) {}
+        JSArray(const JSValues &v) : elements(v) {}
+            
+        uint32 length()
+        {
+            return elements.size();
+        }
+            
+        JSValue& operator[](const JSValue& index)
+        {
+            // for now, we can only handle f64 index values.
+            uint32 n = (uint32)index.f64;
+            // obviously, a sparse representation might be better.
+            uint32 size = elements.size();
+            if (n >= size) expand(n, size);
+            return elements[n];
+        }
+            
+        JSValue& operator[](uint32 n)
+        {
+            // obviously, a sparse representation might be better.
+            uint32 size = elements.size();
+            if (n >= size) expand(n, size);
+            return elements[n];
+        }
+            
+        void resize(uint32 size)
+        {
+            elements.resize(size);
+        }
+            
+    private:
+        void expand(uint32 n, uint32 size)
+        {
+            do {
+                size *= 2;
+            } while (n >= size);
+            elements.resize(size);
+        }
+    };
+        
+    /**
+     * Private representation of a JS function. This simply
+     * holds a reference to the iCode module that is the
+     * compiled code of the function.
+     */
+    class JSFunction : public JSObject {
+        static String FunctionString;
+        static JSObject *functionPrototypeObject;
+        ICodeModule* mICode;
+    protected:
+        JSFunction() : mICode(0) {}
+
+   	    typedef JavaScript::gc_traits_finalizable<JSFunction> traits;
+	    typedef gc_allocator<JSFunction, traits> allocator;
+		
+    public:
+        static void JSFunction::initFunctionObject(JSScope *g);
+
+        JSFunction(ICodeModule* iCode);
+        ~JSFunction();
+    
+        void* operator new(size_t) { return allocator::allocate(1); }
+
+        ICodeModule* getICode()    { return mICode; }
+        virtual bool isNative()    { return false; }
+    };
+
+    class JSNativeFunction : public JSFunction {
+    public:
+        typedef JSValue (*JSCode)(Context *cx, const JSValues& argv);
+        JSCode mCode;
+        JSNativeFunction(JSCode code) : mCode(code) {}
+        virtual bool isNative()    { return true; }
+    };
+        
+    class JSBinaryOperator : public JSFunction {
+    public:
+        typedef JSValue (*JSBinaryCode)(const JSValue& arg1, const JSValue& arg2);
+        JSBinaryCode mCode;
+        JSBinaryOperator(JSBinaryCode code) : mCode(code) {}
+        virtual bool isNative()    { return true; }
+    };
+        
+#ifndef STLPORT
+# if defined(XP_UNIX)
+    // bastring.cc defines a funky operator new that assumes a byte-allocator.
+    typedef string_char_traits<char16> JSCharTraits;
+    typedef gc_allocator<_Char> JSStringAllocator;
+# else
+    typedef std::char_traits<char16> JSCharTraits;
+    typedef gc_allocator<char16> JSStringAllocator;
+# endif
+#else
+    typedef std::char_traits<char16> JSCharTraits;
+    typedef gc_allocator<char16> JSStringAllocator;
+#endif
+
+    typedef std::basic_string<char16, JSCharTraits, JSStringAllocator> JSStringBase;
+
+    /**
+     * Garbage collectable UNICODE string.
+     */
+    class JSString : public JSStringBase, public gc_base {
+    public:
+        JSString() {}
+        explicit JSString(const JSStringBase& str) : JSStringBase(str) {}
+        explicit JSString(const JSStringBase* str) : JSStringBase(*str) {}
+        explicit JSString(const String& str);
+        explicit JSString(const String* str);
+        explicit JSString(const char* str);
+
+        operator String();
+
+        void append(const char* str);
+        void append(const JSStringBase* str);
+    };
+
+    class JSException : public gc_base {
+    public:
+        JSException(char *mess) : value(JSValue(new JSString(mess))) { }
+        JSException(JSValue v) : value(v) { }
+        JSValue value;
+    };
+    
+    inline Formatter& operator<<(Formatter& f, const JSString& str)
+    {
+        printString(f, str.begin(), str.end());
+        return f;
+    }
+
+   /**
+     * Provides a set of nested scopes. 
+     */
+    class JSScope : public JSObject {
+    protected:
+        JSScope* mParent;
+        JSProperties mTypes;
+    public:
+        JSScope(JSScope* parent = 0, JSObject* prototype = 0)
+            : mParent(parent)
+        {
+            if (prototype)
+                setPrototype(prototype);
+        }
+        
+        JSScope* getParent()
+        {
+            return mParent;
+        }
+    
+        bool isDefined(const String& name)
+        {
+            if (hasProperty(name))
+                return true;
+            if (mParent)
+                return mParent->isDefined(name);
+            return false;
+        }
+        
+        const JSValue& getVariable(const String& name)
+        {
+            const JSValue& ret = getProperty(name);
+            if (ret.isUndefined() && mParent) 
+                return mParent->getVariable(name);
+            return ret;
+        }
+        
+        JSValue& setVariable(const String& name, const JSValue& value)
+        {
+            return (mProperties[name] = value);
+        }
+        
+        JSValue& defineVariable(const String& name, JSType* type, const JSValue& value)
+        {
+            if (type != &Any_Type)
+                mTypes[name] = type;
+            return (mProperties[name] = value);
+        }
+
+        JSValue& defineVariable(const String& name, JSType* type)
+        {
+            if (type != &Any_Type)
+                mTypes[name] = type;
+            return (mProperties[name] = kUndefinedValue);
+        }
+
+        void setType(const String& name, JSType* type)
+        {
+            // only type variables that are defined in this scope.
+            JSProperties::iterator i = mProperties.find(name);
+            if (i != mProperties.end())
+                mTypes[name] = type;
+            else
+                if (mParent)
+                    mParent->setType(name, type);
+        }
+
+        JSType* getType(const String& name)
+        {
+            JSType* result = &Any_Type;
+            // only consider types for variables defined in this scope.
+            JSProperties::const_iterator i = mProperties.find(name);
+            if (i != mProperties.end()) {
+                i = mTypes.find(name);
+                if (i != mTypes.end())
+                    result = i->second.type;
+            } else {
+                // see if variable is defined in parent scope.
+                if (mParent)
+                    result = mParent->getType(name);
+            }
+            return result;
+        }
+        
+        JSValue& defineFunction(const String& name, ICodeModule* iCode)
+        {
+            JSValue value(new JSFunction(iCode));
+            return defineVariable(name, &Function_Type, value);
+        }
+
+        JSValue& defineNativeFunction(const String& name, JSNativeFunction::JSCode code)
+        {
+            JSValue value(new JSNativeFunction(code));
+            return defineVariable(name, &Function_Type, value);
+        }
+    };
+
+    class JSType : public JSObject {
+    protected:
+        String mName;
+        JSType *mBaseType;
+    public:
+        JSType(const String &name, JSType *baseType) : mName(name), mBaseType(baseType)
+        {
+            mType = &Type_Type;
+        }
+
+        enum { NoRelation = 0x7FFFFFFF };
+
+        const String& getName() const { return mName; }
+
+        int32 distance(const JSType *other) const;
+    };
+
+    
+    inline void JSObject::init(JSObject* prototype) { mPrototype = prototype; mType = &Any_Type; mClass = new JSString(ObjectString); }
+    
+    inline JSFunction::JSFunction(ICodeModule* iCode) : mICode(iCode), JSObject(functionPrototypeObject) { setClass(new JSString(FunctionString)); }
+
+
+} /* namespace JSTypes */    
+} /* namespace JavaScript */
+
+
+#endif /* jstypes_h */

mozilla/js/js2/macbuild/JS2.prefix

@@ -0,0 +1 @@
+#define XP_MAC 1

mozilla/js/js2/macbuild/JS2Debug.prefix

@@ -0,0 +1,2 @@
+#define XP_MAC 1
+#define DEBUG 1

mozilla/js/js2/macbuild/JS2MPW.prefix

@@ -0,0 +1,2 @@
+#define XP_MAC 1
+#define XP_MAC_MPW 1

mozilla/js/js2/macbuild/JS2MPWDebug.prefix

@@ -0,0 +1,3 @@
+#define XP_MAC 1
+#define XP_MAC_MPW 1
+#define DEBUG 1

mozilla/js/js2/macbuild/gc_config.h

@@ -0,0 +1,91 @@
+/*
+	MacOS_config.h
+	
+	Configuration flags for Macintosh development systems.
+	
+ 	<Revision History>
+ 	
+ 	11/16/95  pcb  Updated compilation flags to reflect latest 4.6 Makefile.
+	
+	by Patrick C. Beard.
+ */
+/* Boehm, November 17, 1995 12:10 pm PST */
+
+#ifdef __MWERKS__
+
+// for CodeWarrior Pro with Metrowerks Standard Library (MSL).
+// #define MSL_USE_PRECOMPILED_HEADERS 0
+#include <ansi_prefix.mac.h>
+#ifndef __STDC__
+#define __STDC__ 0
+#endif
+
+#endif /* __MWERKS__ */
+
+// these are defined again in gc_priv.h.
+#undef TRUE
+#undef FALSE
+
+#define ALL_INTERIOR_POINTERS	// follows interior pointers.
+#define SILENT					// no collection messages.
+//#define DONT_ADD_BYTE_AT_END	// no padding.
+//#define SMALL_CONFIG			// whether to use a smaller heap.
+#define NO_SIGNALS				// signals aren't real on the Macintosh.
+#define USE_TEMPORARY_MEMORY	// use Macintosh temporary memory.
+//#define FIND_LEAK				// use as a leak detector.
+//#define LARGE_CONFIG			// try a big heap, for fun.
+
+// CFLAGS= -O -DNO_SIGNALS -DSILENT -DALL_INTERIOR_POINTERS
+//
+//LIBGC_CFLAGS= -O -DNO_SIGNALS -DSILENT \
+//    -DREDIRECT_MALLOC=GC_malloc_uncollectable \
+//    -DDONT_ADD_BYTE_AT_END -DALL_INTERIOR_POINTERS
+//   Flags for building libgc.a -- the last two are required.
+//
+// Setjmp_test may yield overly optimistic results when compiled
+// without optimization.
+// -DSILENT disables statistics printing, and improves performance.
+// -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
+//   altered stubborn objects, at substantial performance cost.
+//   Use only for incremental collector debugging.
+// -DFIND_LEAK causes the collector to assume that all inaccessible
+//   objects should have been explicitly deallocated, and reports exceptions.
+//   Finalization and the test program are not usable in this mode.
+// -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
+//   (Clients should also define SOLARIS_THREADS and then include
+//   gc.h before performing thr_ or GC_ operations.)
+//   This is broken on nonSPARC machines.
+// -DALL_INTERIOR_POINTERS allows all pointers to the interior
+//   of objects to be recognized.  (See gc_priv.h for consequences.)
+// -DSMALL_CONFIG tries to tune the collector for small heap sizes,
+//   usually causing it to use less space in such situations.
+//   Incremental collection no longer works in this case.
+// -DLARGE_CONFIG tunes the collector for unusually large heaps.
+//   Necessary for heaps larger than about 500 MB on most machines.
+//   Recommended for heaps larger than about 64 MB.
+// -DDONT_ADD_BYTE_AT_END is meaningful only with
+//   -DALL_INTERIOR_POINTERS.  Normally -DALL_INTERIOR_POINTERS
+//   causes all objects to be padded so that pointers just past the end of
+//   an object can be recognized.  This can be expensive.  (The padding
+//   is normally more than one byte due to alignment constraints.)
+//   -DDONT_ADD_BYTE_AT_END disables the padding.
+// -DNO_SIGNALS does not disable signals during critical parts of
+//   the GC process.  This is no less correct than many malloc 
+//   implementations, and it sometimes has a significant performance
+//   impact.  However, it is dangerous for many not-quite-ANSI C
+//   programs that call things like printf in asynchronous signal handlers.
+// -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
+//   new syntax "operator new[]" for allocating and deleting arrays.
+//   See gc_cpp.h for details.  No effect on the C part of the collector.
+//   This is defined implicitly in a few environments.
+// -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
+//   as aliases for X, GC_realloc, and GC_free, respectively.
+//   Calloc is redefined in terms of the new malloc.  X should
+//   be either GC_malloc or GC_malloc_uncollectable.
+//   The former is occasionally useful for working around leaks in code
+//   you don't want to (or can't) look at.  It may not work for
+//   existing code, but it often does.  Neither works on all platforms,
+//   since some ports use malloc or calloc to obtain system memory.
+//   (Probably works for UNIX, and win32.)
+// -DNO_DEBUG removes GC_dump and the debugging routines it calls.
+//   Reduces code size slightly at the expense of debuggability.

mozilla/js/js2/numerics.h

@@ -0,0 +1,153 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// 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.
+
+#ifndef numerics_h
+#define numerics_h
+
+#include "utilities.h"
+#include <cmath>
+
+/* Use platform-defined floating-point routines.
+ * On platforms with faulty floating-point code
+ * ifdef these out and replace by custom implementations. */
+
+#ifndef STLPORT
+# ifndef _WIN32
+    using std::abs;
+    using std::floor;
+    using std::ceil;
+    using std::fmod;
+    using std::sqrt;
+    using std::sin;
+    using std::cos;
+    using std::tan;
+    using std::asin;
+    using std::acos;
+    using std::atan;
+# endif
+#endif
+
+namespace JavaScript {
+
+//
+// Double-precision constants
+//
+
+	extern double positiveInfinity;
+	extern double negativeInfinity;
+	extern double nan;
+
+//
+// Portable double-precision floating point to string and back conversions
+//
+
+	double ulp(double x);
+	int hi0bits(uint32 x);
+
+	class BigInt {
+		enum {maxLgGrossSize = 15};		// Maximum value of lg2(grossSize)
+		static uint32 *freeLists[maxLgGrossSize+1];
+		
+	    uint lgGrossSize;				// lg2(grossSize)
+	  public:
+	    bool negative;					// True if negative.  Ignored by most BigInt routines!
+	  private:
+	    uint32 grossSize;				// Number of words allocated for <words>
+	    uint32 size;					// Actual number of words.  If the number is nonzero, the most significant word must be nonzero.
+	    								// If the number is zero, then size is also 0.
+	    uint32 *words;					// <size> words of the number, in little endian order
+	    
+	    void allocate(uint lgGrossSize);
+	    void recycle();
+	    void initCopy(const BigInt &b);
+	    void move(BigInt &b);
+	  public:
+	    BigInt(): words(0) {}
+	    explicit BigInt(uint lgGrossSize) {allocate(lgGrossSize);}
+	    BigInt(const BigInt &b) {initCopy(b);}
+		void operator=(const BigInt &b) {ASSERT(!words); initCopy(b);}
+	    ~BigInt() {if (words) recycle();}
+	    
+	    void setLgGrossSize(uint lgGrossSize);
+	    void init(uint32 i);
+		void init(double d, int32 &e, int32 &bits);
+		void mulAdd(uint m, uint a);
+		void operator*=(const BigInt &m);
+		void pow2Mul(int32 k);
+		void pow5Mul(int32 k);
+		bool isZero() const {ASSERT(words); return !size;}
+		int cmp(const BigInt &b) const;
+		void initDiff(const BigInt &m, const BigInt &n);
+		uint32 quoRem2(int32 k);
+		int32 quoRem(const BigInt &S);
+		uint32 divRem(uint32 divisor);
+		double b2d(int32 &e) const;
+		double ratio(const BigInt &denominator) const;
+		void s2b(const char *s, int32 nd0, int32 nd, uint32 y9);
+		
+		uint32 nWords() const {return size;}
+		uint32 word(uint32 i) const {ASSERT(i < size); return words[i];}
+	};
+
+
+	// Modes for converting floating-point numbers to strings.
+	//
+	// Some of the modes can round-trip; this means that if the number is converted to
+	// a string using one of these mode and then converted back to a number, the result
+	// will be identical to the original number (except that, due to ECMA, -0 will get converted
+	// to +0).  These round-trip modes return the minimum number of significand digits that
+	// permit the round trip.
+	//
+	// Some of the modes take an integer parameter <precision>.
+	//
+	// Keep this in sync with doubleToAsciiModes[].
+	enum DToStrMode {
+	    dtosStandard,					// Either fixed or exponential format; round-trip
+	    dtosStandardExponential,		// Always exponential format; round-trip
+	    dtosFixed,						// Round to <precision> digits after the decimal point; exponential if number is large
+	    dtosExponential,				// Always exponential format; <precision> significant digits
+	    dtosPrecision					// Either fixed or exponential format; <precision> significant digits
+	};
+
+
+	// Maximum number of characters (including trailing null) that a dtosStandard or dtosStandardExponential
+	// conversion can produce.  This maximum is reached for a number like -1.2345678901234567e+123.
+	const int dtosStandardBufferSize = 25;
+
+	// Maximum number of characters (including trailing null) that one of the other conversions
+	// can produce.  This maximum is reached for TO_FIXED, which can generate up to 21 digits before the decimal point.
+	#define dtosVariableBufferSize(precision) ((precision)+24 > dtosStandardBufferSize ? (precision)+24 : dtosStandardBufferSize)
+
+	// "-0.0000...(1073 zeros after decimal point)...0001\0" is the longest string that we could produce,
+	// which occurs when printing -5e-324 in binary.  We could compute a better estimate of the size of
+	// the output string and malloc fewer bytes depending on d and base, but why bother?
+	const int dtobasesBufferSize = 1078;
+
+	double strToDouble(const char *str, const char *&numEnd);
+	double stringToDouble(const char16 *str, const char16 *strEnd, const char16 *&numEnd);
+	double stringToInteger(const char16 *str, const char16 *strEnd, const char16 *&numEnd, uint base);
+
+	char *doubleToStr(char *buffer, size_t bufferSize, double value, DToStrMode mode, int precision);
+	size_t doubleToBaseStr(char *buffer, double value, uint base);
+	void appendDouble(String &dst, double value, DToStrMode mode = dtosStandard, int precision = 0);
+	inline String &operator+=(String &s, double value) {appendDouble(s, value); return s;}
+	void printDouble(Formatter &f, double value, DToStrMode mode = dtosStandard, int precision = 0);
+	inline Formatter &operator<<(Formatter &f, double value) {printDouble(f, value); return f;}
+}
+#endif

mozilla/js/js2/systemtypes.h

@@ -0,0 +1,93 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// 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.
+
+#ifndef systemtypes_h
+#define systemtypes_h
+
+#include <cstddef>
+
+#ifdef _WIN32
+ // Turn off warnings about identifiers too long in browser information
+ #pragma warning(disable: 4786)
+#endif
+
+// Define int8, int16, int32, int64, uint8, uint16, uint32, uint64, and uint.
+typedef unsigned int uint;
+typedef unsigned char uchar;
+
+typedef signed char int8;
+typedef unsigned char uint8;
+typedef short int16;
+typedef unsigned short uint16;
+#if !defined(XP_MAC) && !defined(_WIN32)
+ typedef int int32;
+ typedef unsigned int uint32;
+#else
+ typedef long int32;
+ typedef unsigned long uint32;
+#endif
+#ifdef _WIN32
+ typedef __int64 int64;
+ typedef unsigned __int64 uint64;
+#else
+ typedef long long int64;
+ typedef unsigned long long uint64;
+#endif
+
+// Define this if the machine natively supports 64-bit integers
+#define NATIVE_INT64
+
+// Define float32 and float64.
+typedef double float64;
+typedef float float32;
+
+// A UTF-16 character
+// Use wchar_t on platforms on which wchar_t has 16 bits; otherwise use int16.
+// Note that in C++ wchar_t is a distinct type rather than a typedef for some integral type.
+// Like char, a char16 can be either signed or unsigned at the implementation's discretion.
+#ifdef __GNUC__
+ // GCC's wchar_t is 32 bits, so we can't use it.
+ typedef uint16 char16;
+ typedef uint16 uchar16;
+#else
+ typedef wchar_t char16;
+ #ifndef _WIN32 // Microsoft VC6 bug: wchar_t should be a built-in type, not a typedef
+  typedef unsigned wchar_t uchar16;
+ #else
+  typedef wchar_t uchar16;
+ #endif
+#endif
+
+#ifdef _WIN32
+ #define IS_LITTLE_ENDIAN
+#endif
+#ifdef __i386__
+ #define IS_LITTLE_ENDIAN
+#endif
+
+
+// basicAlignment is the maximum alignment required by any native type.  An object aligned to
+// a multiple of basicAlignment can hold any native type.  malloc should return a pointer whose
+// lgBasicAlignment least significant bits are clear.
+// Currently basicAlignment is set to 8 to allow doubles and int64s to have their natural alignment;
+// may be customized for individual platforms.
+const uint lgBasicAlignment = 3;
+const uint basicAlignment = 1u<<lgBasicAlignment;
+
+#endif /* systemtypes_h */

mozilla/js/js2/tests/classes.js

@@ -0,0 +1,28 @@
+class A {
+    static var x = 0;
+
+    static function f()
+    {
+        return A.x++;
+    }
+}    
+
+class Point3D {
+    var x = 0, y = 0, z = 0;
+
+    function set(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    
+    function setX(x) { this.x = x; }
+    function getX() { return this.x; }
+    
+    function setY(y) { this.y = y; }
+    function getY() { return this.y; }
+    
+    function setZ(z) { this.z = z; }
+    function getZ() { return this.z; }
+}

mozilla/js/js2/tools/gencode.pl

@@ -0,0 +1,596 @@
+#!perl
+
+use strict;
+
+my $tab = "    ";
+my $init_tab = $tab;
+my $enum_decs = "";
+my $class_decs = "";
+my @name_array;
+my $opcode_maxlen = 0;
+
+#
+# fields are:
+#
+# * super: Class to inherit from, if super is Instruction_(1|2|3), the script
+#          will automatically append the correct template info based on |params|
+# * super_has_print: Set to 1 if you want to inherit the print() and print_args()
+#                    methods from the superclass, set to 0 (or just don't set)
+#                    to generate print methods.
+# * rem: Remark you want to show up after the enum def, and inside the class.
+# * params: The parameter list expected by the constructor, you can specify a
+#           default value, using the syntax, [ ("Type = default") ].
+#
+# class names will be generated based on the opcode mnemonic.  See the
+# subroutine get_classname for the implementation.  Basically underscores will
+# be removes and the class name will be WordCapped, using the positions where the
+# underscores were as word boundries.  The only exception occurs when a word is
+# two characters, in which case both characters will be capped,
+# as in BRANCH_GT -> BranchGT.
+#
+
+#
+# template definitions for compare, arithmetic, and conditional branch ops
+#
+my $binary_op =
+  {
+   super  => "Instruction_3",
+   super_has_print => 1,
+   rem    => "dest, source1, source2",
+   params => [ ("TypedRegister", "TypedRegister", "TypedRegister") ]
+  };
+
+my $math_op =
+  {
+   super  => "Arithmetic",
+   super_has_print => 1,
+   rem    => "dest, source1, source2",
+   params => [ ("TypedRegister", "TypedRegister", "TypedRegister") ]
+  };
+
+my $cbranch_op =
+  {
+   super  => "GenericBranch",
+   super_has_print => 1,
+   rem    => "target label, condition",
+   params => [ ("Label*", "TypedRegister") ]
+  };
+
+my $unary_op =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, source",
+   params => [ ("TypedRegister", "TypedRegister") ]
+  };
+
+
+#
+# op defititions
+#
+my %ops;
+$ops{"NOP"} = 
+  {
+   super  => "Instruction",
+   rem    => "do nothing and like it",
+  };
+$ops{"DEBUGGER"} = 
+  {
+   super  => "Instruction",
+   rem    => "drop to the debugger",
+  };
+$ops{"GENERIC_BINARY_OP"} =
+  {
+   super  => "Instruction_4",
+   rem    => "dest, op, source1, source2",
+   params => [ ("TypedRegister", "BinaryOperator::BinaryOp", "TypedRegister", "TypedRegister") ]
+  };
+$ops{"MOVE"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, source",
+   params => [ ("TypedRegister", "TypedRegister") ]
+  };
+$ops{"LOAD_IMMEDIATE"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, immediate value (double)",
+   params => [ ("TypedRegister", "double" ) ]
+  };
+$ops{"LOAD_BOOLEAN"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, immediate value (boolean)",
+   params => [ ("TypedRegister", "bool" ) ]
+  };
+$ops{"LOAD_STRING"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, immediate value (string)",
+   params => [ ("TypedRegister", "JSString*" ) ]
+  };
+$ops{"LOAD_NAME"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, name",
+   params => [ ("TypedRegister", "const StringAtom*" ) ]
+  };
+$ops{"SUPER"} =
+  {
+   super  => "Instruction_1",
+   rem    => "dest",
+   params => [ ("TypedRegister" ) ]
+  };
+$ops{"SAVE_NAME"} =
+  {
+   super  => "Instruction_2",
+   rem    => "name, source",
+   params => [ ("const StringAtom*", "TypedRegister") ]
+  };
+$ops{"NEW_OBJECT"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, constructor",
+   params => [ ("TypedRegister", "TypedRegister") ]
+  };
+$ops{"NEW_CLASS"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, class",
+   params => [ ("TypedRegister", "JSClass*") ]
+  };
+$ops{"NEW_FUNCTION"} =
+  {
+   super  => "Instruction_2",
+   rem    => "dest, ICodeModule", 
+   params => [ ("TypedRegister", "ICodeModule*") ]
+  };
+$ops{"NEW_ARRAY"} =
+  {
+   super  => "Instruction_1",
+   rem    => "dest",
+   params => [ ("TypedRegister") ]
+  };
+$ops{"DELETE_PROP"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, object, prop name",
+   params => [ ("TypedRegister", "TypedRegister", "const StringAtom*") ]
+  };
+$ops{"GET_PROP"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, object, prop name",
+   params => [ ("TypedRegister", "TypedRegister", "const StringAtom*") ]
+  };
+$ops{"SET_PROP"} =
+  {
+   super  => "Instruction_3",
+   rem    => "object, name, source",
+   params => [ ("TypedRegister", "const StringAtom*", "TypedRegister") ]
+  };
+$ops{"GET_SLOT"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, object, slot number",
+   params => [ ("TypedRegister", "TypedRegister", "uint32") ]
+  };
+$ops{"SET_SLOT"} =
+  {
+   super  => "Instruction_3",
+   rem    => "object, slot number, source",
+   params => [ ("TypedRegister", "uint32", "TypedRegister") ]
+  };
+$ops{"GET_STATIC"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, class, index",
+   params => [ ("TypedRegister", "JSClass*", "uint32") ]
+  };
+$ops{"SET_STATIC"} =
+  {
+   super  => "Instruction_3",
+   rem    => "class, index, source",
+   params => [ ("JSClass*", "uint32", "TypedRegister") ]
+  };
+$ops{"STATIC_XCR"} =
+  {
+   super  => "Instruction_4",
+   rem    => "dest, class, index, value",
+   params => [ ("TypedRegister", "JSClass*", "uint32", "double") ]
+  };
+$ops{"SLOT_XCR"} =
+  {
+   super  => "Instruction_4",
+   rem    => "dest, source, slot number, value",
+   params => [ ("TypedRegister", "TypedRegister", "uint32", "double") ]
+  };
+$ops{"PROP_XCR"} =
+  {
+   super  => "Instruction_4",
+   rem    => "dest, source, name, value",
+   params => [ ("TypedRegister", "TypedRegister", "const StringAtom*", "double") ]
+  };
+$ops{"ELEM_XCR"} =
+  {
+   super  => "Instruction_4",
+   rem    => "dest, base, index, value",
+   params => [ ("TypedRegister", "TypedRegister", "TypedRegister", "double") ]
+  };
+$ops{"NAME_XCR"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, name, value",
+   params => [ ("TypedRegister", "const StringAtom*", "double") ]
+  };
+$ops{"VAR_XCR"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, source, value",
+   params => [ ("TypedRegister", "TypedRegister", "double") ]
+  };
+$ops{"GET_ELEMENT"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, base, index",
+   params => [ ("TypedRegister", "TypedRegister", "TypedRegister") ]
+  };
+$ops{"SET_ELEMENT"} =
+  {
+   super  => "Instruction_3",
+   rem    => "base, index, value",
+   params => [ ("TypedRegister", "TypedRegister", "TypedRegister") ]
+  };
+$ops{"ADD"}        = $math_op;
+$ops{"SUBTRACT"}   = $math_op;
+$ops{"MULTIPLY"}   = $math_op;
+$ops{"DIVIDE"}     = $math_op;
+$ops{"REMAINDER"}  = $math_op;
+$ops{"SHIFTLEFT"}  = $math_op;
+$ops{"SHIFTRIGHT"} = $math_op;
+$ops{"USHIFTRIGHT"}= $math_op;
+$ops{"AND"}        = $math_op;
+$ops{"OR"}         = $math_op;
+$ops{"XOR"}        = $math_op;
+$ops{"COMPARE_LT"} = $binary_op;
+$ops{"COMPARE_LE"} = $binary_op;
+$ops{"COMPARE_EQ"} = $binary_op;
+$ops{"COMPARE_NE"} = $binary_op;
+$ops{"COMPARE_GE"} = $binary_op;
+$ops{"COMPARE_GT"} = $binary_op;
+$ops{"COMPARE_IN"} = $binary_op;
+$ops{"STRICT_EQ"}  = $binary_op;
+$ops{"STRICT_NE"}  = $binary_op;
+$ops{"INSTANCEOF"} = $binary_op;
+$ops{"BITNOT"}     = $unary_op;
+$ops{"NOT"}        = $unary_op;
+$ops{"TEST"}       = $unary_op;
+$ops{"NEGATE"}     = $unary_op;
+$ops{"POSATE"}     = $unary_op;
+$ops{"BRANCH"} =
+  {
+   super  => "GenericBranch",
+   rem    => "target label",
+   params => [ ("Label*") ]
+  };
+$ops{"BRANCH_TRUE"} = $cbranch_op;
+$ops{"BRANCH_FALSE"} = $cbranch_op;
+$ops{"RETURN"} =
+  {
+   super    => "Instruction_1",
+   rem      => "return value",
+   params   => [ ("TypedRegister") ]
+  };
+$ops{"RETURN_VOID"} =
+  {
+   super => "Instruction",
+   rem   => "Return without a value"
+  };
+$ops{"CALL"} =
+  {
+   super  => "Instruction_4",
+   rem    => "result, base, target, args",
+   params => [ ("TypedRegister", "TypedRegister", "TypedRegister", "RegisterList") ]
+  };
+$ops{"GET_METHOD"} =
+  {
+   super  => "Instruction_3",
+   rem    => "result, target base, index",
+   params => [ ("TypedRegister", "TypedRegister", "uint32") ]
+  };
+$ops{"THROW"} =
+  {
+   super    => "Instruction_1",
+   rem      => "exception value",
+   params   => [ ("TypedRegister") ]
+  };
+$ops{"TRYIN"} =
+  {
+   super  => "Instruction_2",
+   rem    => "catch target, finally target",
+   params => [ ("Label*", "Label*") ]
+  };
+$ops{"TRYOUT"} = 
+  {
+   super  => "Instruction",
+   rem    => "mmm, there is no try, only do",
+  };
+$ops{"JSR"} =
+  {
+   super  => "GenericBranch",
+   rem    => "target",
+   params => [ ("Label*") ]
+  };
+$ops{"RTS"} =
+  {
+   super => "Instruction",
+   rem   => "Return to sender",
+  };
+$ops{"WITHIN"} =
+  {
+   super  => "Instruction_1",
+   rem    => "within this object",
+   params => [ ("TypedRegister") ]
+  };
+$ops{"WITHOUT"} =
+  {
+   super  => "Instruction",
+   rem    => "without this object",
+  };
+$ops{"CAST"} =
+  {
+   super  => "Instruction_3",
+   rem    => "dest, rvalue, toType",
+   params => [ ("TypedRegister", "TypedRegister", "JSType*") ]
+  };
+
+#
+# nasty perl code, you probably don't need to muck around below this line
+#
+
+my $k;
+
+if (!$ARGV[0]) {
+    # no args, collect all opcodes
+    for $k (sort(keys(%ops))) {
+        &collect($k);
+    }
+} else {
+    # collect defs for only the opcodes specified on the command line
+    while ($k = pop(@ARGV)) {
+        &collect (uc($k));
+    }
+}
+
+&spew;
+
+sub collect {
+    # grab the info from the $k record in $ops, and append it to
+    # $enum_decs, @name_array, and $class_decs.
+    my ($k) = @_;
+
+    if (length($k) > $opcode_maxlen) {
+        $opcode_maxlen = length($k);
+    }
+
+    my $c = $ops{$k};
+    if (!$c) {
+        die ("Unknown opcode, $k\n");
+    }
+
+    my $opname = $k;
+    my $cname = get_classname ($k);
+    my $super = $c->{"super"};
+    my $constructor = $super;
+	my @params;
+	
+	if ($c->{"params"}) {
+		@params = @{$c->{"params"}};
+	} else {
+		@params = ();
+	}
+    
+    my $rem = $c->{"rem"};
+    my ($dec_list, $call_list, $template_list) =
+      &get_paramlists(@params);
+    my @types = split (", ", $template_list);
+
+    my $constr_params = $call_list ? $opname . ", " . $call_list : $opname;
+
+    if ($super =~ /Instruction_\d/) {
+        $super .= "<" . $template_list . ">";
+    }    
+    
+    push (@name_array, $opname);
+    $enum_decs .= "$init_tab$tab$opname, /* $rem */\n";
+    if ($super) {
+        $class_decs .= ($init_tab . "class $cname : public $super {\n" .
+                        $init_tab . "public:\n" .
+                        $init_tab . $tab . "/* $rem */\n" .
+                        $init_tab . $tab . "$cname ($dec_list) :\n" .
+                        $init_tab . $tab . $tab . "$super\n" .
+                        "$init_tab$tab$tab($constr_params) " .
+                        "{};\n");
+
+        if (!$c->{"super_has_print"}) {
+            $class_decs .= ($init_tab . $tab . 
+                             "virtual Formatter& print(Formatter& f) {\n" .
+                             $init_tab . $tab . $tab . "f << opcodeNames[$opname]" .
+                             &get_print_body(@types) . ";\n" .
+                             $init_tab . $tab . $tab . "return f;\n" .
+                             $init_tab . $tab . "}\n");
+
+            my $printops_body = &get_printops_body(@types);
+            my $printops_decl =  "virtual Formatter& printOperands(Formatter& f, ";
+
+            $printops_decl .= ($dec_list =~ /RegisterList/) ?
+                               "const JSValues& registers" :
+                               "const JSValues& /*registers*/";
+            $printops_decl .= ") {\n";
+
+            $class_decs .= ($init_tab . $tab . 
+                            $printops_decl .
+                            $printops_body .
+                            $init_tab . $tab . $tab . "return f;\n" .
+                            $init_tab . $tab . "}\n");
+
+        } else {
+            $class_decs .= $init_tab . $tab . 
+              "/* print() and printOperands() inherited from $super */\n";
+        }
+
+        $class_decs .= $init_tab . "};\n\n";
+    }
+}
+
+sub spew {
+    # print the info in $enum_decs, @name_aray, and $class_decs to stdout.
+    my $opname;
+    
+    print "// THIS FILE IS MACHINE GENERATED! DO NOT EDIT BY HAND!\n\n";
+    
+    print "#if !defined(OPCODE_NAMES)\n\n";
+
+    print $tab . "enum {\n$enum_decs$tab};\n\n";
+    
+    print $class_decs;
+    
+    print "#else\n\n";
+
+    print $tab . "char *opcodeNames[] = {\n";
+
+    for $opname (@name_array) {
+        print "$tab$tab\"$opname";
+        for (0 .. $opcode_maxlen - length($opname) - 1) {
+            print " ";
+        }
+        print "\",\n"
+    }
+    print "$tab};\n\n";
+
+    print "#endif\n\n"
+}
+
+sub get_classname {
+    # munge an OPCODE_MNEMONIC into a ClassName
+    my ($enum_name) = @_;
+    my @words = split ("_", $enum_name);
+    my $cname = "";
+    my $i = 0;
+    my $word;
+
+    for $word (@words) {
+        if ((length($word) == 2) && ($i != 0)) {
+            $cname .= uc($word);
+        } else {
+            $cname .= uc(substr($word, 0, 1)) . lc(substr($word, 1));
+        }
+        $i++;
+    }
+    
+    return $cname;
+}
+
+sub get_paramlists {
+    # parse the params entry (passed into @types) into various parameter lists
+    # used in the class declaration
+    my @types = @_;
+    my @dec;
+    my @call;
+    my @tostr;
+    my @template;
+    my $op = 1;
+    my $type;
+
+    for $type (@types) {
+        my $pfx;
+        my $deref;
+        my $member;
+        my $default;
+
+        ($type, $default) = split (" = ", $type);
+        if ($default ne "") {
+            $default = " = " . $default;
+        }
+
+        $pfx = $deref = "";
+        $member = "mOp$op";
+
+        push (@dec, "$type aOp$op" . "$default");
+        push (@call, "aOp$op");
+        push (@template, $type);
+        $op++;
+    }
+
+    return (join (", ", @dec), join (", ", @call), join (", ", @template));
+}
+
+sub get_print_body {
+    # generate the body of the print() function
+    my (@types) = @_;
+    my $type;
+    my @oplist;
+    my $op = 1;
+    my $in = $init_tab . $tab . $tab;
+
+    for $type (@types) {
+
+        if ($type eq "TypedRegister") {
+
+           push (@oplist, "mOp$op" );
+
+ #           push (@oplist, "\"R\" << ((mOp$op.first == NotARegister) ? -1 : mOp$op.first)");
+
+        } elsif ($type eq "Label*") {
+            push (@oplist, "\"Offset \" << ((mOp$op) ? mOp$op->mOffset : NotAnOffset)")
+        } elsif ($type =~ /String/) {
+            push (@oplist, "\"'\" << *mOp$op << \"'\"");
+        } elsif ($type =~ /JSType\*/) {
+            push (@oplist, "\"'\" << mOp$op->getName() << \"'\"");
+        } elsif ($type =~ /bool/) {
+            push (@oplist, "\"'\" << ((mOp$op) ? \"true\" : \"false\") << \"'\"");
+        } elsif ($type =~ /ICodeModule/) {
+            push (@oplist, "\"ICodeModule\"");
+        } elsif ($type =~ /JSClass\*/) {
+            push (@oplist, "mOp$op->getName()");
+        } else {
+            push (@oplist, "mOp$op");
+        }
+
+        $op++;
+    }
+
+    my $rv = join (" << \", \" << ", @oplist);
+    if ($rv ne "") {
+        $rv = " << \"\\t\" << " . $rv;
+    }
+    
+    return $rv;
+}
+
+sub get_printops_body {
+    # generate the body of the printOperands() function
+    my (@types) = @_;
+    my $type;
+    my @oplist;
+    my $op = 1;
+    my $in = $init_tab . $tab . $tab;
+
+    for $type (@types) {
+
+        if ($type eq "TypedRegister") {
+            push (@oplist, "mOp$op.first");
+#            push (@oplist, "\"R\" << mOp$op.first << '=' << registers[mOp$op.first]");
+        } elsif ($type eq "RegisterList") {
+            push (@oplist, "ArgList(mOp$op, registers)");
+        }
+
+        $op++;
+    }
+
+    my $rv = join (" << \", \" << ", @oplist);
+    if ($rv ne "") {
+        $rv = $init_tab . $tab . $tab . "f << " . $rv . ";\n";
+    }
+    
+    return $rv;
+}

mozilla/js/js2/vmtypes.cpp

@@ -0,0 +1,178 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#include "utilities.h"
+#include "vmtypes.h"
+
+namespace JavaScript {
+namespace VM {
+
+using namespace JSTypes;
+
+#define OPCODE_NAMES
+#include "icode.h"
+
+Formatter& operator<< (Formatter& f, Instruction& i)
+{
+    return i.print(f);
+}
+
+Formatter& operator<< (Formatter& f, RegisterList& rl)
+{
+    TypedRegister* e = rl.end();
+    
+    f << "(";
+    for (RegisterList::iterator r = rl.begin(); r != e; r++) {
+        f << "R" << r->first; 
+        if ((r + 1) != e)
+            f << ", ";
+    }
+    f << ")";
+    
+    return f;
+}
+
+Formatter& operator<< (Formatter& f, const ArgList& al)
+{
+    const RegisterList& rl = al.mList;
+    const JSValues& registers = al.mRegisters;
+    f << "(";
+    RegisterList::const_iterator i = rl.begin(), e = rl.end();
+    if (i != e) {
+        TypedRegister r = *i++;
+        f << "R" << r.first << '=' << registers[r.first];
+        while (i != e) {
+            r = *i++;
+            f << ", R" << r.first << '=' << registers[r.first];
+        }
+    }
+    f << ")";
+    
+    return f;
+}
+
+Formatter& operator<< (Formatter& f, TypedRegister& r)
+{
+    if (r.first == NotARegister)
+        f << "<NaR>";
+    else
+        f << "R" << r.first;
+    return f;
+}
+
+Formatter& operator<< (Formatter &f, InstructionStream &is)
+{
+
+    for (InstructionIterator i = is.begin(); 
+         i != is.end(); i++) {
+        /*
+        bool isLabel = false;
+
+        for (LabelList::iterator k = labels.begin(); 
+             k != labels.end(); k++)
+            if ((ptrdiff_t)(*k)->mOffset == (i - is.begin())) {
+                f << "#" << (uint32)(i - is.begin()) << "\t";
+                isLabel = true;
+                break;
+            }
+
+        if (!isLabel)
+            f << "\t";
+
+        f << **i << "\n";
+        */
+
+        printFormat(stdOut, "%04u", (uint32)(i - is.begin()));
+        f << ": " << **i << "\n";
+    
+    }
+
+    return f;
+}
+
+BinaryOperator::BinaryOp BinaryOperator::mapICodeOp(ICodeOp op) {
+    // a table later... or maybe we need a grand opcode re-unification 
+    switch (op) {
+    case ADD        : return Add;
+    case SUBTRACT   : return Subtract;
+    case MULTIPLY   : return Multiply;
+    case DIVIDE     : return Divide;
+    case REMAINDER  : return Remainder;
+    case SHIFTLEFT  : return LeftShift;
+    case SHIFTRIGHT : return RightShift;
+    case USHIFTRIGHT: return LogicalRightShift;
+
+    case AND        : return BitwiseAnd;
+    case OR         : return BitwiseOr;
+    case XOR        : return BitwiseXor;
+    
+    case COMPARE_LT : return Less;
+    case COMPARE_LE : return LessOrEqual;
+    case COMPARE_EQ : return Equal;
+    case STRICT_EQ  : return Identical;
+    default :
+        NOT_REACHED("Unsupported binary op");
+        return (BinaryOp)-1;
+    }
+}
+
+Formatter& operator<< (Formatter &f, BinaryOperator::BinaryOp &b)
+{
+    switch (b) {
+    case BinaryOperator::Add:               return f << "Add";
+    case BinaryOperator::Subtract:          return f << "Subtract";
+    case BinaryOperator::Multiply:          return f << "Multiply";
+    case BinaryOperator::Divide:            return f << "Divide";
+    case BinaryOperator::Remainder:         return f << "Remainder";
+    case BinaryOperator::LeftShift:         return f << "LeftShift";
+    case BinaryOperator::RightShift:        return f << "RightShift";
+    case BinaryOperator::LogicalRightShift: return f << "LogicalRightShift";
+
+    case BinaryOperator::BitwiseAnd:        return f << "BitwiseAnd";
+    case BinaryOperator::BitwiseOr:         return f << "BitwiseOr";
+    case BinaryOperator::BitwiseXor:        return f << "BitwiseXor";
+    
+    case BinaryOperator::Less:              return f << "Less";
+    case BinaryOperator::LessOrEqual:       return f << "LessOrEqual";
+    case BinaryOperator::Equal:             return f << "Equal";
+    case BinaryOperator::Identical:         return f << "Identical";
+    default :
+        NOT_REACHED("inner peace, either");
+        return f;
+    }
+}
+
+} /* namespace VM */
+} /* namespace JavaScript */
+
+

mozilla/js/js2/vmtypes.h

@@ -0,0 +1,304 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * 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): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifndef vmtypes_h
+#define vmtypes_h
+
+#include "numerics.h" /* needed for formatter << double */
+#include "jstypes.h"
+#include "jsclasses.h"
+#include "world.h"
+#include <vector>
+
+/* forward declare classes from JavaScript::ICG */
+namespace JavaScript {
+namespace ICG {
+    class ICodeModule;
+} /* namespace ICG */
+} /* namespace JavaScript */
+
+namespace JavaScript {
+namespace VM {
+
+    using namespace JSTypes;
+    using namespace JSClasses;
+    
+    /********************************************************************/
+
+    typedef uint32 ICodeOp;
+    extern char *opcodeNames[];
+
+    /* super-class for all instructions */
+    class Instruction
+    {
+    public:
+        Instruction(ICodeOp aOpcode) : mOpcode(aOpcode) {}
+        
+        virtual Formatter& print(Formatter& f) = 0;
+        virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) = 0;
+        
+        ICodeOp op() { return mOpcode; }
+        
+        virtual int32 count() { return 0; }
+        
+    protected:
+        ICodeOp mOpcode;
+        
+    };
+
+    /********************************************************************/
+
+    enum { NotARegister = 0xFFFFFFFF };
+    enum { NotALabel = 0xFFFFFFFF };
+    enum { NotAnOffset = 0xFFFFFFFF };
+    enum { NotABanana = 0xFFFFFFFF };
+    
+    /********************************************************************/
+    
+    typedef uint32 Register;
+    typedef std::pair<Register, JSType*> TypedRegister;
+    typedef std::vector<TypedRegister> RegisterList;        
+    typedef std::vector<Instruction *> InstructionStream;
+    typedef InstructionStream::iterator InstructionIterator;
+    typedef std::map<String, TypedRegister, std::less<String> > VariableMap;
+
+    
+    /**
+     * Helper to print Call operands.
+     */
+    struct ArgList {
+        const RegisterList& mList;
+        const JSValues& mRegisters;
+        ArgList(const RegisterList& rl, const JSValues& registers)
+            :   mList(rl), mRegisters(registers) {}
+    };        
+    
+    /********************************************************************/
+    
+    Formatter& operator<< (Formatter& f, Instruction& i);
+    Formatter& operator<< (Formatter& f, RegisterList& rl);
+    Formatter& operator<< (Formatter& f, const ArgList& al);
+    Formatter& operator<< (Formatter& f, InstructionStream& is);
+    Formatter& operator<< (Formatter& f, TypedRegister& r);
+    
+    /********************************************************************/
+    
+    class Label {
+    public:
+        Label(InstructionStream* aBase) :
+            mBase(aBase), mOffset(NotALabel) {}
+        
+        InstructionStream *mBase;
+        uint32 mOffset;
+    };
+    
+    typedef std::vector<Label *> LabelList;
+    typedef LabelList::iterator LabelIterator;
+
+    /********************************************************************/
+
+    /* 1, 2 and 3 operand opcode templates */
+    
+    template <typename Operand1>
+    class Instruction_1 : public Instruction {
+    public:
+        Instruction_1(ICodeOp aOpcode, Operand1 aOp1) : 
+            Instruction(aOpcode), mOp1(aOp1) { }            
+        Operand1& o1() { return mOp1; }
+
+        virtual int32 count() { return 1; }
+        
+    protected:
+        Operand1 mOp1;
+    };
+    
+    template <typename Operand1, typename Operand2>
+    class Instruction_2 : public Instruction {
+    public:
+        Instruction_2(ICodeOp aOpcode, Operand1 aOp1, Operand2 aOp2) :
+            Instruction(aOpcode), mOp1(aOp1), mOp2(aOp2) {}
+        Operand1& o1() { return mOp1; }
+        Operand2& o2() { return mOp2; }
+
+        virtual int32 count() { return 2; }
+        
+    protected:
+        Operand1 mOp1;
+        Operand2 mOp2;
+    };
+    
+    template <typename Operand1, typename Operand2, typename Operand3>
+    class Instruction_3 : public Instruction {
+    public:
+        Instruction_3(ICodeOp aOpcode, Operand1 aOp1, Operand2 aOp2,
+                      Operand3 aOp3) :
+            Instruction(aOpcode), mOp1(aOp1), mOp2(aOp2), mOp3(aOp3) { }
+        Operand1& o1() { return mOp1; }
+        Operand2& o2() { return mOp2; }
+        Operand3& o3() { return mOp3; }
+
+        virtual int32 count() { return 3; }
+        
+    protected:
+        Operand1 mOp1;
+        Operand2 mOp2;
+        Operand3 mOp3;
+    };
+    
+    template <typename Operand1, typename Operand2, typename Operand3, typename Operand4>
+    class Instruction_4 : public Instruction {
+    public:
+        Instruction_4(ICodeOp aOpcode, Operand1 aOp1, Operand2 aOp2,
+                      Operand3 aOp3, Operand4 aOp4) :
+            Instruction(aOpcode), mOp1(aOp1), mOp2(aOp2), mOp3(aOp3), mOp4(aOp4) { }
+        Operand1& o1() { return mOp1; }
+        Operand2& o2() { return mOp2; }
+        Operand3& o3() { return mOp3; }
+        Operand4& o4() { return mOp4; }
+
+        virtual int32 count() { return 4; }
+        
+    protected:
+        Operand1 mOp1;
+        Operand2 mOp2;
+        Operand3 mOp3;
+        Operand4 mOp4;
+    };
+        
+    /********************************************************************/
+
+    /* Instruction groups */
+    
+    class Arithmetic : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
+    public:
+        Arithmetic (ICodeOp aOpcode, TypedRegister aDest, TypedRegister aSrc1,
+                    TypedRegister aSrc2) :
+            Instruction_3<TypedRegister, TypedRegister, TypedRegister>(aOpcode, aDest, aSrc1, aSrc2) {}
+
+        virtual Formatter& print(Formatter& f)
+        {
+            f << opcodeNames[mOpcode] << "\tR" << mOp1.first << ", R" << mOp2.first << ", R" << mOp3.first;
+            return f;
+        }
+        
+        virtual Formatter& printOperands(Formatter& f, const JSValues& registers)
+        {
+            f << "R" << mOp1.first << '=' << registers[mOp1.first] << ", " << "R" << mOp2.first << '=' << registers[mOp2.first] << ", " << "R" << mOp3.first << '=' << registers[mOp3.first];
+            return f;
+        }
+    };
+    
+    class Unary : public Instruction_2<TypedRegister, TypedRegister> {
+    public:
+        Unary(ICodeOp aOpcode, TypedRegister aDest, TypedRegister aSrc) :
+            Instruction_2<TypedRegister, TypedRegister>(aOpcode, aDest, aSrc) {}
+        virtual Formatter& print (Formatter& f) {
+            f << opcodeNames[mOpcode] << "\tR" << mOp1.first << ", R" << mOp2.first;
+            return f;
+        }
+
+        virtual Formatter& printOperands(Formatter& f, const JSValues& registers)
+        {
+            f << "R" << mOp1.first << '=' << registers[mOp1.first] << ", " << "R" << mOp2.first << '=' << registers[mOp2.first];
+            return f;
+        }
+    };
+    
+    class GenericBranch : public Instruction_2<Label*, TypedRegister> {
+    public:
+        GenericBranch (ICodeOp aOpcode, Label* aLabel, 
+                       TypedRegister aR = TypedRegister(NotARegister, &Any_Type) ) :
+            Instruction_2<Label*, TypedRegister>(aOpcode, aLabel, aR) {}
+        virtual Formatter& print (Formatter& f) {
+            f << opcodeNames[mOpcode] << "\tOffset " << mOp1->mOffset;
+            if (mOp2.first == NotARegister) {
+                f << ", R~";
+            } else {
+                f << ", R" << mOp2.first;
+            }
+            return f;
+        }
+
+        virtual Formatter& printOperands(Formatter& f, const JSValues& registers)
+        {
+            if (mOp2.first != NotARegister)
+                f << "R" << mOp2.first << '=' << registers[mOp2.first];
+            return f;
+        }
+
+        void resolveTo (uint32 aOffset) { mOp1->mOffset = aOffset; }
+        uint32 getOffset() { return mOp1->mOffset; }
+        void setTarget(Label *label) { mOp1 = label; }
+    };
+
+    /********************************************************************/
+
+    class BinaryOperator {
+    public:
+
+        // Wah, here's a third enumeration of opcodes - ExprNode, ICodeOp and now here, this can't be right??
+        typedef enum { 
+            BinaryOperatorFirst,
+            Add = BinaryOperatorFirst, Subtract, Multiply, Divide,
+            Remainder, LeftShift, RightShift, LogicalRightShift,
+            BitwiseOr, BitwiseXor, BitwiseAnd, Less, LessOrEqual,
+            Equal, Identical, BinaryOperatorCount
+        } BinaryOp;
+
+        BinaryOperator(const JSType *t1, const JSType *t2, JSBinaryOperator *function) :
+            t1(t1), t2(t2), function(function) { }
+
+        BinaryOperator(const JSType *t1, const JSType *t2, JSFunction *function) :
+            t1(t1), t2(t2), function(function) { }
+
+        static BinaryOp mapICodeOp(ICodeOp op);
+
+        const JSType *t1;
+        const JSType *t2;
+        JSFunction *function;
+
+    };
+
+    typedef std::vector<BinaryOperator *> BinaryOperatorList;
+    
+    Formatter& operator<<(Formatter &f, BinaryOperator::BinaryOp &b);
+
+    /********************************************************************/
+
+    #include "icode.h"
+
+} /* namespace VM */
+
+} /* namespace JavaScript */
+
+#endif /* vmtypes_h */

mozilla/js/js2/winbuild/buildgc.bat

@@ -0,0 +1,5 @@
+cd ..\..\..\..
+cvs co mozilla/gc/boehm
+cd mozilla\gc\boehm
+nmake -f NT_MAKEFILE gc.lib
+cd ..\..\js\js2\winbuild

mozilla/js/js2/winbuild/js2.dsp

@@ -0,0 +1,234 @@
+# Microsoft Developer Studio Project File - Name="js2" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=js2 - Win32 Partial Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "js2.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "js2.mak" CFG="js2 - Win32 Partial Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "js2 - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "js2 - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "js2 - Win32 Partial Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "js2 - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib gc.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\gc\boehm"
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "js2 - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GR /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "DEBUG" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG" /d "DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib gc.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\gc\boehm"
+
+!ELSEIF  "$(CFG)" == "js2 - Win32 Partial Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "js2___Win32_Partial_Debug"
+# PROP BASE Intermediate_Dir "js2___Win32_Partial_Debug"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "js2___Win32_Partial_Debug"
+# PROP Intermediate_Dir "js2___Win32_Partial_Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "DEBUG" /FR /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG" /d "DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG" /d "DEBUG"
+BSC32=bscmake.exe
+# SUBTRACT BASE BSC32 /nologo
+# SUBTRACT BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib gc.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\gc\boehm"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib gc.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\gc\boehm"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "js2 - Win32 Release"
+# Name "js2 - Win32 Debug"
+# Name "js2 - Win32 Partial Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\debugger.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\hash.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\icodegenerator.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\interpreter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\js2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\jsmath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\jstypes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\numerics.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\parser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\utilities.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\vmtypes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\world.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\cpucfg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\gc_allocator.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\hash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\icode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\icodegenerator.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\interpreter.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\jsclasses.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\jsmath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\jstypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\numerics.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\parser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\systemtypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\utilities.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\vmtypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\world.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

mozilla/js/js2/winbuild/js2.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "js2"=.\js2.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

mozilla/js/js2/world.cpp

@@ -0,0 +1,39 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// 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 oqr
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// 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.
+
+#include "world.h"
+namespace JS = JavaScript;
+
+
+// Return an existing StringAtom corresponding to the String s if there is
+// one; if not, create a new StringAtom with String s and return that StringAtom.
+JS::StringAtom &JS::StringAtomTable::operator[](const String &s)
+{
+	HT::Reference r(ht, s);
+	if (r)
+		return *r;
+	else
+		return ht.insert(r, s);
+}
+
+
+JS::World::World()
+{
+	Token::initKeywords(*this);
+}