#!/usr/bin/env perl
#!/bin/sh

#  -*-Perl-*-  (for Emacs)    vim:set filetype=perl:  (for vim)
#======================================================================#
#! /Good_Path/perl -w
# line 17

# Name:   pc_build
# Author: wd (wdobler [at] gmail [dot] com)
# Date:   23-Jun-2009
# Modified: 18-jun-2019/MR: added option --target=<targetname> (-t=<targetname>) for choosing a target
# SVN: $Id$
# Description:
#   Compile the Pencil Code, using settings from the 'Makefile' section in
#   the appropriate configuration files.
# Usage:
#   pc_build [-v|-h]
#   pc_build [-f <file1,file2,...>] [-H <host_ID>]
#   pc_build [<options>] [<MAKE_VAR1=val1> [<MAKE_VAR2>=val2 ...]]
# Options:
#   -h, --help      This help.
#   -d, --debug     Show debug output.
#       --clean     Run 'make clean'.
#       --cleanall  Run 'pc_setupsrc; make cleanall'.
#   -f <files>,
#       --config-files=<files>
#                   Use the given <files> (a comma-separated list) as
#                   configuration files, rather than trying to find a
#                   config file based on a host ID.
#                   If not provided and the environment variable PENCIL_CONFIG_FILES is set,
#                   the value of the latter is taken over for <files>.
#   -H <id>
#       --host-id=<id>
#                   Use the given <id> as host ID.
#   -i              Show system host ID and exit. This ignores local
#                   configuration of the host ID via command-line flags,
#                   environment variables, and 'host-ID' files.
#   -I              Show all matching host IDs, in the order in which they
#                   are tried, and exit.
#   -j, --jobs=<N>  Use make with a maximum of N parallelization jobs.
#       --parallel  Use make with unlimited parallelization.
#   -D, --debug-config
#                   Show the config files (existing or not) that would be
#                   read, then exit
#       --notify    Tell us (audibly and visually) when compilation is done.
#       --fast      Shortcut for the option FFLAGS+='-O0'.
#   -l, --last-config
#                   Build with the same config files as before.
#   -p, --previous-flags
#                   Build with the same flags as the previous time.
#   -q, --quiet     Be quiet.
#   -s, --serial    Use make w/o parallelization.
#   -t, --target=<target>
#                   Choose a target, default: "default-to-be" (=EXECUTABLES).
#                   For targets "*.x", extension can be omitted.
#                   Target "ALL": all executables in subdirectory "src".
#   -v, --version   Print version number.
# Examples:
#   pc_build
#       use host ID mechanism to identify the appropriate config file.
#   pc_build REAL_PRECISION=double
#       run 'make REAL_PRECISION=double', i.e. compile for double precision
#   pc_build -f compilers/GNU-GCC_MPI
#       will use the configuration files
#       ${PENCIL_HOME}/config/compilers/GNU-GCC.conf and
#       ${PENCIL_HOME}/config/mpi/default.conf (unless you have analogous
#       files under ~/.pencil/config to override the ones in ${PENCIL_HOME}).
#   pc_build -f /home/USER/myconfig
#       will use the configuration file /home/USER/myconfig.conf if it
#       exists.
#   pc_build -H workhorse
#       will look for, and use the configuration file for host ID
#       'workhorse'. If no config file is found, pc_build exits with an
#       error message.
#   pc_build --debug-config
#       will not build, but instead helps to choose an appropriate
#       location for a config file for the given computer

# To do / ideas:
#   - Allow make-style assignment arguments:
#       pc_build FC=myf90 FFLAGS+='-O0 -g'
#   - Allow handing down flags to 'make' with
#       -Wm,<flag1>,<flag2>,...
#       --make-flags=<flag1>,<flag2>,...
#   - Allow setting the search path

# Copyright (C) 2015  Wolfgang Dobler
#
# This program is free software; you can redistribute it and/or modify it
# under the same conditions as Perl or under the GNU General Public
# License, version 3 or later.

use strict;
use warnings;
BEGIN {
    # Make sure ${PENCIL_HOME}/lib/perl is in the Perl path
    if (-d "$ENV{PENCIL_HOME}/lib/perl") {
        unshift @INC, "$ENV{PENCIL_HOME}/lib/perl";
    } else {
        if ($0 =~ m!(.*[/\\])!) { unshift @INC, "$1../lib/perl"; }
    }
}

use Pencil::Util;
Pencil::Util::use_pencil_perl_modules(
    'Pencil::ConfigFinder',
    'Pencil::ConfigParser'
    ) or die;

use POSIX qw(strftime);
use Getopt::Long;
# Allow for '-Plp' as equivalent to '-P lp' etc:
Getopt::Long::config("bundling");

my $cmd_name = $0;
my @all_arguments = @ARGV;

my (%opts);                     # Options hash for GetOptions

## Process command line
GetOptions(\%opts,
           qw( -h   --help
               -d   --debug
                    --clean
                    --cleanall
               -f=s --config-files=s
               -H=s --host-id=s
               -i
               -j=n --jobs=n
                    --parallel
               -I
               -D   --debug-config
                    --notify
                    --fast
               -l   --last-config
               -p   --previous-flags
               -q   --quiet
               -s   --serial
               -t=s --target=s
               -v   --version )
          ) or die "Aborting.\n";

my $debug = ($opts{'d'} || $opts{'debug'} || '');
if ($debug) {
    printopts(\%opts);
    print "\@ARGV = '@ARGV'\n";
}

if ($opts{'h'} || $opts{'help'})    { die usage();   }
if ($opts{'v'} || $opts{'version'}) { die version(); }

my $clean        = (              $opts{'clean'}          || '');
my $cleanall     = (              $opts{'cleanall'}       || '');
my $config_files = ($opts{'f'} || $opts{'config-files'}   || undef);
my $host_id      = ($opts{'H'} || $opts{'host-id'}        || undef);
my $debug_config = ($opts{'D'} || $opts{'debug-config'}   || '');
my $show_system_host_id = ($opts{'i'}                     || '');
my $show_host_ids = ($opts{'I'}                           || '');
my $jobs         = ($opts{'j'} || $opts{'jobs'}           || undef);
my $parallel     = (              $opts{'parallel'}       || 0);
my $notify       = (              $opts{'notify'}         || '');
my $fast         = (              $opts{'fast'}           || '');
my $last_config  = ($opts{'l'} || $opts{'last-config'}    || '');
my $prev_flags   = ($opts{'p'} || $opts{'previous-flags'} || '');
my $quiet        = ($opts{'q'} || $opts{'quiet'}          || '');
my $serial       = ($opts{'s'} || $opts{'serial'}         || '');
my $target       = ($opts{'t'} || $opts{'target'}         || undef);

if (!defined $target){
    $target = 'default_to_be';
}
else{
    $target = (split("=",$target))[-1];
    $target =~ s/(^.*)\.x *$/$1/;
}

if ($show_system_host_id) {
    my $id = Pencil::ConfigFinder::get_host_id_system_info();
    print $id."\n";
    exit 0;
}

if ($show_host_ids) {
    foreach my $id (Pencil::ConfigFinder::get_host_ids()) {
        print $id."\n";
    }
    exit 0;
}

my @config_files;
mention($Pencil::ConfigFinder::debug);
$Pencil::ConfigFinder::debug = 1 if ($debug or $debug_config);

if (!defined $config_files) {
    if ($last_config && -e "src/.config-files" && !(-z "src/.config-files")) {
        open(CFH, '<', "src/.config-files");
        $config_files = <CFH>;
        close(CFH);
    } else {
        if (defined $ENV{'PENCIL_CONFIG_FILES'}) {
            $config_files = $ENV{'PENCIL_CONFIG_FILES'};
        }
    }
    if (defined $config_files) {
       $config_files =~ s/^\s+|\s+$//g;
       print STDERR "Use config file <$config_files>\n" unless ($quiet);
    }
}

if (defined $config_files) {
    my @files = split(/[,\s\+]+/s, $config_files);
    @config_files = Pencil::ConfigFinder::locate_config_files(@files);
} else {
    my $config_file;
    if (defined $host_id) {
        $config_file = Pencil::ConfigFinder::find_config_file_for_host($host_id);
    } else {
        $config_file = Pencil::ConfigFinder::find_config_file();
    }
    die "Fatal: Couldn't find config file.\n" unless (defined $config_file);
    $config_files=$config_file;
    push @config_files, $config_file;
    print STDERR "Found config file <$config_files[0]>\n" unless ($quiet);
}
die "No configuration file found\n" unless @config_files;

open(CFH, '>', "src/.config-files") or die $!;
print CFH $config_files;
close(CFH);

if ($debug_config) {
    if (($opts{'f'} || $opts{'config-files'}) && @config_files) {
        print "Using <";
        print @config_files;
        print ">\n";
    }
    # The desired output is now printed
    exit 0;
}

my $log_file = 'pc_commands.log';
if ($prev_flags) {
    my $cmd = `grep -w pc_build pc_commands.log | tail -1`;
    exec $cmd;
    exit 0;
}

log_command_line($cmd_name, \@all_arguments);

if ($fast) {
    push @ARGV, 'FFLAGS+=-O0';
}

my @extra_make_args = @ARGV;

if ($cleanall) {
    system('pc_setupsrc');
    make('cleanall');
    exit 0;
}

if ($clean) {
    make('clean');
    exit 0;
}

my $parser = new Pencil::ConfigParser(@config_files);
$parser->debug(1) if ($debug);

unless (-e './src/cparam.f90') {
    print STDERR "Running pc_setupsrc\n";
    system('pc_setupsrc');
}

my @make_args = @{$parser->get_makefile_args()};
push @make_args, @extra_make_args;

# Handle MAKE_VAR1=-j4, etc.
# NOTE: This should be implemented with -Wm,<options>, akin to
# pencil-test's -Wa or gcc's -Wl options
map { s/^\s*MAKE_VAR\d*\s*=\s*// } @make_args;
if ($serial) {
    my $ind;
    for( $ind = 0; $ind < scalar @make_args; $ind +=1 ) {
        if ($make_args[$ind] =~ ' *(?:-j|--jobs=\d*) *'){
             splice(@make_args, $ind, 1); last;
        }
    }
}
if ($parallel) { push @make_args, "-j"; }
if (defined ($jobs)) { push @make_args, "--jobs=".$jobs; }

if ($target eq "ALL") { $target = 'fast'; }

if ($debug) {
    push @make_args, "--debug";
}

my $make_cmd_line = "'".join("' '", @make_args, $target)."'";
print STDERR "Running make ", $make_cmd_line, "\n" unless ($quiet);
write_log_line('# make '.$make_cmd_line);
make(@make_args, $target);

# ---------------------------------------------------------------------- #
sub make {
# Run 'make' with the given arguments
    my @make_args = @_;
    system('make', @make_args) == 0
      or die "'make @make_args' failed: <$!>\n";
}
# ---------------------------------------------------------------------- #
sub mention {
# Reference a variable without doing anything.
# Use this to suppress ''Name "Pencil::ConfigFinder::debug" used only
# once'' warning
    my @args = @_;
}
# ---------------------------------------------------------------------- #
sub write_log_line {
# Write one line to the log file.
    my ($line) = @_;
    my $out;

    if (!-e $log_file) {
        open($out, '> '.$log_file);
        print $out "# Log file of Pencil Code commands.\n";
        print $out "# This compiles with the same parameters as last time in this directory:\n";
        print $out "# pc_build -p\n";
        close $out;
    }

    open($out, '>> '.$log_file)
      or return warn_politely("Cannot write to $log_file");
    print $out "$line", "\n";
    close $out;
}
# ---------------------------------------------------------------------- #
sub log_command_line {
# Write the current command line to log file that can be run in order to
# compile with exactly the same parameters.
    my ($cmd, $args_ref) = @_;
    my @args = quote_spaces(@$args_ref);
    my $out;

    my $timestamp = POSIX::strftime("%Y-%m-%d %H:%M:%S", localtime);
    write_log_line("\n# ".$timestamp);
    write_log_line("$cmd @args");
}
# ---------------------------------------------------------------------- #
sub comment_out_all_lines {
# Create a new file.
# If $log_file exists, copy each line from $log_file to the new file,
# commenting out all non-empty, non-commented lines.
# Otherwise write a descriptive header to the new file.
# Access permissions of the new files are the same as for the old file,
# or determined from the user's umask.
# Return a file handle and the file name for the new file.
    my ($log_file) = @_;

    use File::Temp qw/ :mktemp /;

    my ($out, $tmp_file) = mkstemp('pc_build_tmp_XXXXX');

    my $permissions;
    if (-e $log_file) {
        $permissions =  (stat "$log_file")[2] & 07777;
        open(my $in, '<', $log_file)
          or return warn_politely("Cannot read from $log_file");
        while (defined(my $line = <$in>)) {
            if ($line !~ /^\s*#/) {
                $line = "# ".$line;
            }
            print $out $line;
        }
        close $in;
    } else {
        # rw-rw-rw- is 0666, but umask may disallow some of those bits
        $permissions = 0666 & ~umask();
        (my $header = <<'HERE') =~ s/^\s{8}//gm;
        # Log file of Pencil Code commands.
        # This compiles with the same parameters as last time in this directory:
        # pc_build -p
HERE
        print $out $header;
    }

    chmod($permissions, $out);

    return ($out, $tmp_file);
}
# ---------------------------------------------------------------------- #
sub warn_politely {
# Print a warning and return ''
    my ($warning) = @_;

    chomp $warning;
    warn "$warning\n";
    return '';
}
# ---------------------------------------------------------------------- #
sub quote_spaces {
# Put any string containing spaces in ''.
# This is primitive and won't help for command line arguments containing
# the single quote character.
    my @strings = @_;

    my @quoted = ();
    foreach my $string (@strings) {
        if ($string =~ /\s/) {
            $string = "'$string'";
        }
        push @quoted, $string;
    }

    return @quoted;
}
# ---------------------------------------------------------------------- #
sub printopts {
# Print command line options
    my ($optsref) = @_;
    my %opts = %$optsref;
    foreach my $opt (keys(%opts)) {
        print STDERR "\$opts{$opt} = '$opts{$opt}'\n";
    }
}
# ---------------------------------------------------------------------- #
sub usage {
# Extract description and usage information from this file's header.
    my $thisfile = __FILE__;
    local $/ = '';              # Read paragraphs
    open(FILE, "< $thisfile") or die "Cannot open $thisfile\n";
    while (<FILE>) {
        # Paragraph _must_ contain 'Description:' or 'Usage:'
        next unless /^\s*\#\s*(Description|Usage):/m;
        # Drop 'Author:', etc. (anything before 'Description:' or 'Usage:')
        s/.*?\n(\s*\#\s*(Description|Usage):\s*\n.*)/$1/s;
        # Don't print comment sign:
        s/^\s*# ?//mg;
        last;                        # ignore body
    }
    return $_ || "<No usage information found>\n";
}
# ---------------------------------------------------------------------- #
sub version {
# Return CVS data and version info.
    my $doll='\$';              # Need this to trick CVS
    my $cmdname = (split('/', $0))[-1];
    my $rev = '$Revision: 1.12 $';
    my $date = '$Date: 2008/07/07 21:37:16 $';
    $rev =~ s/${doll}Revision:\s*(\S+).*/$1/;
    $date =~ s/${doll}Date:\s*(\S+).*/$1/;

    return "$cmdname version $rev ($date)\n";
}
# ---------------------------------------------------------------------- #
END {
    Pencil::Util::notify('building') if $notify;
}
# ---------------------------------------------------------------------- #

# End of file build