426 lines
10 KiB
Perl
426 lines
10 KiB
Perl
#!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;
|