# Description: iMaker main Perl script & common routines

$(error |MAKE=$(MAKE)|MAKE_VERSION=$(MAKE_VERSION)|SHELL=$(SHELL)|MAKECMDGOALS=$(MAKECMDGOALS)|)

#line 24

use subs qw(CORE::GLOBAL::die);

use Cwd;

use Digest::MD5 qw(md5_hex);

use File::Basename;

use File::Copy;

use File::Find;

use File::Path;

use File::Spec;

use File::Temp qw(tempfile);

use POSIX qw(strftime);

use Text::ParseWords;

use Time::Local;

sub InitMkglobals();

sub PrintEnv($);

sub Max(@);

sub Min(@);

sub Trim($;$);

sub Quote($);

sub Unquote($);

sub Int2Hex($;$);

sub Byte2Str($@);

sub Str2Byte($);

sub Str2Xml($);

sub Ascii2Uni($);

sub Uni2Ascii($);

sub GetTimestamp();

sub Sec2Min($);

sub Wcard2Restr($);

sub Wcard2Regex($);

sub ParseCmdWords($);

sub DPrint($@);

sub Echo($$$);

sub PathConv($;$$$);

sub ParseFiles($);

sub GlobFiles($;$);

sub GetBasename($);

sub GetDirname($);

sub GetAbsDirname($;$$$);

sub GetAbsFname($;$$$);

sub GetRelFname($;$$);

sub GetWriteFname($);

sub GetFreeDrive(;$);

sub SubstDrive($$);

sub UnsubstDrive($);

sub Search($$$$$$\@\$);

sub Find($$$$$\$);

sub ChangeDir($);

sub DeleteDir($;$);

sub FindDir($$$$);

sub MakeDir($);

sub MakeChangeDir($);

sub SetWorkdir($);

sub OpenFile(*$$;$);

sub Test($);

sub CutFile($$$$$);

sub Copy($$;$);

sub CopyIby($$);

sub DeleteFile($;$);

sub FindFile($$$$);

sub HeadFile($$$);

sub TailFile($$$);

sub TypeFile($;$);

sub ReadFile($$);

sub WriteFile($$$;$$);

sub UnzipFile($$);

sub Zip($$$$@);

sub Move($$);

sub Touch($@);

sub SetLogfile($);

sub RunSystemCmd($;$$$);

sub ParseSystemCmd($$$$$);

sub GenExclfile($$$$$);

sub GenIbyfile($$$);

sub GenObyfile($$$$@);

sub GenMakefile($$$$$);

sub GenWidgetConf($$$$);

sub AddImageHeader($$$$$);

sub Sleep($);

sub FindSOSFiles($$$$);

sub CheckTool(@);

sub OpCacheInstall($$$);

sub SisInstall($$$$$$$$);

sub GetIPar(;$);

sub PEval($);

sub PeekICmd($);

sub SkipICmd();

sub GetICmd();

sub EndICmd();

sub SplitStep($);

sub RunStep($);

sub RunIExtCmd($);

sub GetConfmkList(;$);

sub GetFeatvarIncdir($);

sub SetVerbose($;$);

sub CloseLog();

sub RunIMakerCmd($$$$$@);

sub RunMakeCmd($$);

sub HandleCmdArg($);

sub HandleExtCmdArg($);

sub MenuRuncmd($);

sub Menu($);

sub Install($$$);

use constant READBUFSIZE => 2097152;  # 2 MB

use constant STARTSTR => '>>>[START]=========8<==========8<==========8<==========8<==========8<==========';

use constant ENDSTR   => '==========>8==========>8==========>8==========>8==========>8===========[END]<<<';

# device[VARID]==... !!

#

use constant BOOTBINARYSTATEMENT => qr/^\s*bootbinary\s*(?:=+|\s)\s*(?:"(.+?)"|(\S+))/i;

use constant FILESPECSTATEMENT =>

    qr/^\s*(?:data|device|dll|extension|file|primary|secondary|variant)\S*?\s*(?:=+|\s)\s*(?:"(.+?)"|(\S+))\s+(?:"(.+?)"|(\S+))(\s+.+?)?\s*$/i;

our ($gArgv, $gCmdcnt, @gCmdoutbuf, %gConfmkList, $gEpocdrive, $gEpocroot, $gError, $gErrwarn, $gEvalerr,

    %gExportvar, $gFiltercmd, @gFindresult, $gICmd, @gIcmd, $gImakerext, $gImgtype, $gKeepgoing, @gLogbuf,

    $gLogfile, %gLogfiles, $gMakecmd, @gMakeinfo, $gOutfilter, $gParamcnt, $gPrintcmd, @gReport, $gStartmk,

    $gStarttime, $gStep, @gStepDur, %gStepIcmd, %gSubstdrv, $gTgterr, %gTool, $gVerbose, $gWinOS, $gWorkdir,

    $gWorkdrive, @iVar);

###############################################################################

#

sub InitMkglobals()

{

    $gCmdcnt     = 0;

    @gCmdoutbuf  = ();

    $gFiltercmd  = qr/\S/;

    @gFindresult = ();

    $gICmd       = "";

    @gIcmd       = ();

    $gImgtype    = "";

    $gOutfilter  = "";

    $gParamcnt   = 0;

    $gPrintcmd   = 0;

    $gStep       = "";

    @gStepDur    = ();

    %gStepIcmd   = ();

    @iVar        = ();  # General purpose variable to be used from $(call peval,...)

}

    ($gArgv, $gEvalerr, $gStarttime, $gWinOS) = (scalar(@ARGV), 0, time(), $^O =~ /MSWin/i);

    $_ = "default input and pattern-searching space";

    eval("use Archive::Zip qw(:ERROR_CODES)");

    eval("use constant AZ_OK => -1") if $@;

    eval("use Archive::Zip::Tree");

    if ($gWinOS) { eval("

        use Win32API::File qw(:DDD_);

        use Win32::File;

        use constant WIN32_FILE_HIDDEN => Win32::File::HIDDEN");

    } else { eval("

        use constant DDD_REMOVE_DEFINITION => -1;

        use constant WIN32_FILE_HIDDEN => -1");

    }

}

INIT {

    $gWorkdir   = Cwd::cwd();

    $gWorkdrive = ($gWorkdir =~ /^([a-z]:)/i ? uc($1) : "");

    $ENV{EPOCROOT} = ($gWinOS ? "\\" : "$gWorkdir/") if !$ENV{EPOCROOT};

    $ENV{IMAKER_CMDARG} = "" if !defined($ENV{IMAKER_CMDARG});

    $ENV{IMAKER_CYGWIN} = 0 if !$ENV{IMAKER_CYGWIN};

    InitMkglobals();

    %gConfmkList = ();

    $gEpocdrive  = ($ENV{EPOCROOT} =~ /^([a-z]:)/i ? uc($1) : $gWorkdrive);

    ($gEpocroot  = GetAbsDirname($ENV{EPOCROOT})) =~ s/\/+$//;

    $gError      = 0;

    $gErrwarn    = 0;

    %gExportvar  = (); $gExportvar{""} = 0;

    $gKeepgoing  = 0;

    @gLogbuf     = ();

    $gLogfile    = "";

    %gLogfiles   = ();

    $gMakecmd    = "";

    @gMakeinfo   = ("?", "?", "?");

    @gReport     = ();

    $gStartmk    = 0;

    %gSubstdrv   = ();

    $gTgterr     = 0;

    %gTool       = (); map{ $gTool{$_} => $_ } ("cpp", "elf2e32", "interpretsis", "opcache", "unzip");

    $gVerbose    = 1;

    # Overload die

    *CORE::GLOBAL::die = sub {

        $gError = 1 if !$gEvalerr;

        return if (PeekICmd("iferror") && !$gEvalerr);

        CORE::die(@_) if ($gEvalerr || !$gKeepgoing);

        $gErrwarn = 1;

        warn(@_);

    };

    # Handler for __DIE__ signal

    $SIG{__DIE__} = sub {

        return if $gEvalerr;

        $gErrwarn = 1;

        warn(@_);

        exit(1);

    };

    # Handler for __WARN__ signal

    $SIG{__WARN__} = sub {

        if (($gEvalerr != 1) && ($gKeepgoing < 3) && ($_[0] ne "\n")) {

            select(STDERR);

            my $msg = ($gStep ? "($gStep): " : "") . $_[0];

            if ($gErrwarn && ($gKeepgoing < 2)) {

                   DPrint(0, "*** Error: $msg") }

            else { DPrint(127, "Warning: $msg") }

            select(STDOUT);

        }

        $gErrwarn = 0;

    };

    if (!$gArgv) {

        warn("iMaker is running under Cygwin!\n")

        my $perlver = sprintf("%vd", $^V);

        warn("iMaker uses Perl version $perlver! Recommended versions are 5.6.1, 5.8.x and 5.10.x.\n")

            if ($perlver !~ /^5\.(?:6\.1|(?:8|10)\.\d+)$/);

    if ($gArgv) {

        my $iopt = shift(@ARGV);

        print(map("$_\n", GetFeatvarIncdir("@ARGV"))), exit(0) if ($iopt eq "--incdir");

        print(map("$_\n", @ARGV)), exit(0) if ($iopt eq "--splitarg");

        die("Unknown internal imaker.pl option: `$iopt'.\n");

    }

    delete($ENV{MAKE}) if $gWinOS;

    map { delete($ENV{$_}) } qw(MAKECMDGOALS MAKEFILES MAKEFLAGS MAKELEVEL MAKE_VERSION);

    $ENV{CONFIGROOT} = GetAbsDirname($ENV{CONFIGROOT} || "$gEpocroot/epoc32/rom/config");

    $ENV{ITOOL_DIR}  = GetAbsDirname($ENV{ITOOL_DIR}  || "$gEpocroot/epoc32/tools/rom");

    $ENV{IMAKER_DIR} = GetAbsDirname($ENV{IMAKER_DIR});

    $ENV{IMAKER_EXPORTMK}  = "";

    $ENV{IMAKER_MAKE}      = ($gWinOS ? "$ENV{IMAKER_DIR}/mingw_make.exe" : $ENV{MAKE} || "make") if !$ENV{IMAKER_MAKE};

    $ENV{IMAKER_MAKESHELL} = ($ENV{COMSPEC} || "cmd.exe") if (!$ENV{IMAKER_MAKESHELL} && $gWinOS);

    $ENV{IMAKER_MKCONF}    = $ENV{CONFIGROOT} . ',image_conf_(.+?)\.mk$,_(?:ncp)?\d+\.mk$,1' if !$ENV{IMAKER_MKCONF};

    my $pathsep = ($gWinOS ? ";" : ":");

    $ENV{PATH}  = join(";", grep(!/[\\\/]cygwin[\\\/]/i, split(/;+/, $ENV{PATH}))) if (!$ENV{IMAKER_CYGWIN} && $gWinOS);

    ($ENV{PATH} = Trim($ENV{PATH})) =~ s/"$/";/ if $gWinOS;  # http://savannah.gnu.org/bugs/index.php?25412

    $ENV{PATH}  = PathConv("$ENV{ITOOL_DIR}", $gWinOS) . $pathsep . PathConv("$gEpocroot/epoc32/tools", $gWinOS) .

        $pathsep . ($gWinOS ? PathConv("$gEpocroot/epoc32/gcc/bin", 1) . ";" : "") . $ENV{PATH};

    $ENV{PERL5LIB} = $ENV{IMAKER_DIR} . ($ENV{PERL5LIB} ? "$pathsep$ENV{PERL5LIB}" : "");

    die($@) if !defined($gImakerext = do("$ENV{IMAKER_DIR}/imaker_extension.pm")) && $@;

    my ($version, $verfile) = ("", "$ENV{IMAKER_DIR}/imaker_version.mk");

    open(FILE, "<$verfile") and map { $version = $1 if /^\s*IMAKER_VERSION\s*[+:?]?=\s*(.*?)\s*$/ } <FILE>;

    close(FILE);

    if ($version) { DPrint(1, "$version\n") }

    else { warn("Can't read iMaker version from `$verfile'.\n") }

    if ($ENV{IMAKER_CMDARG} =~ /^\s*--?(install|clean)=?(.*?)\s*$/i) {

        Install(lc($1) eq "clean", "$ENV{IMAKER_DIR}/../group/bld.inf", $2);

        exit(0);

    }

    $gMakecmd = "$ENV{IMAKER_MAKE} -R --no-print-directory" .

        ($ENV{IMAKER_MAKESHELL} ? " SHELL=\"$ENV{IMAKER_MAKESHELL}\"" : "");

    my $cmdout = qx($gMakecmd -f "$0" 2>&1);

    ($cmdout = (defined($cmdout) ? $cmdout : "")) =~ s/\n+$//;

    die("Can't run Make properly: `$cmdout'\n")

        if ($cmdout !~ /\|MAKE=(.*?)\|MAKE_VERSION=(.*?)\|SHELL=(.*?)\|/);

    @gMakeinfo = ($1, $2, $3);

    warn(($gMakeinfo[1] eq "" ? "Can't resolve Make version" : "iMaker uses Make version $gMakeinfo[1]") .

        ", recommended version is 3.81.\n") if ($gMakeinfo[1] !~ /^\s*3\.81/);

    RunIMakerCmd("$gMakecmd TIMESTAMP=" . GetTimestamp() .

        " -I \"$ENV{CONFIGROOT}\" -f \"$ENV{IMAKER_DIR}/imaker.mk\"", $ENV{IMAKER_CMDARG}, "", 0, 0, ());

}

###############################################################################

#

sub PrintEnv($)

{

    return if !@gMakeinfo;

    DPrint(shift(), "=" x 79 . "\n" .

        "User        : " . (getlogin() || "?") . "@" . ($ENV{HOSTNAME} || $ENV{COMPUTERNAME} || "?") . " on $^O\n" .

        "Time        : " . localtime() . "\n" .

        "Current dir : `$gWorkdir'\n" .

        "iMaker tool : `$ENV{IMAKER_TOOL}' -> `$0'\n" .

        "Cmdline args: `$ENV{IMAKER_CMDARG}'\n" .

        "Perl        : `$^X' version " . sprintf("%vd\n", $^V) .

        "PERL5LIB    : `$ENV{PERL5LIB}'\n" .

        "PERL5OPT    : `" . (defined($ENV{PERL5OPT}) ? "$ENV{PERL5OPT}'\n" : "'\n") .

        "Make        : `$gMakeinfo[0]' version $gMakeinfo[1]\n" .

        "Make shell  : `$gMakeinfo[2]'\n" .

        "EPOCROOT    : `$ENV{EPOCROOT}'\n" .

        "CONFIGROOT  : `$ENV{CONFIGROOT}'\n" .

        "PATH        : `$ENV{PATH}'\n");

    @gMakeinfo = ();

}

sub Max(@)

{

    my $max = (shift() || 0);

    map { $max = $_ if $_ > $max } @_;

    return($max);

}

sub Min(@)

{

    my $min = (shift() || 0);

    map { $min = $_ if $_ < $min } @_;

    return($min);

}

sub Trim($;$)

{

    (my $str = shift()) =~ s/^\s+|\s+$//g;

    $str =~ s/\s+(?=\s)//g if shift();

    return($str);

}

sub Quote($)

{

    local $_ = shift();

    return("") if !defined();

    s/\\( |n|t)/\\\\$1/g;

    return($_);

}

sub Unquote($)

{

    local $_ = shift();

    return("") if !defined();

    s/(?<!\\)(?<=\\n)\s+(\\n)?//g;

    s/(?<!\\)\s+(?=\\n)//g;

    s/(?<!\\)\\ / /g;

    s/(?<!\\)\\n/\n/g;

    s/(?<!\\)\\t/\t/g;

    s/\\\\( |n|t)/\\$1/g;

    s/\x00//g;

    return($_);

}

sub Int2Hex($;$)

{

    my ($int, $len) = @_;

    return((defined($len) ? $len : ($len = ($int < 4294967296 ? 8 : 16))) < 9 ? sprintf("%0${len}X", $int) :

        sprintf("%0" . ($len - 8) . "X%08X", int($int / 4294967296), $int % 4294967296));  # 4294967296 = 4 G

}

sub Byte2Str($@)

{

    my ($base, @byte) = @_;

    return(join("", map(($_ % 16 ? "" : sprintf("%04X:", $base + $_)) . sprintf(" %02X", $byte[$_]) .

        (!(($_ + 1) % 16) || ($_ == (@byte - 1)) ? "\n" : ""), (0 .. (@byte - 1)))));

}

sub Str2Byte($)

{

    my ($str, $ind, @byte) = (shift(), 0, ());

    $str =~ s/,$/, /;

    map {

        $ind++;

        s/^\s+|\s+$//g;

        if (/^\d+$/ && $_ < 256) {

            push(@byte, $_);

        } elsif (/^0x[0-9A-F]+$/i && hex() < 256) {

            push(@byte, hex());

        } else {

            die("Invalid $ind. byte: `$_'.\n");

            return;

        }

    } split(/,/, $str);

    return(@byte);

}

sub Str2Xml($)

{

    my $str = shift();

    $str =~ s/(.)/{'"'=>'&quot;', '&'=>'&amp;', "'"=>'&apos;', '<'=>'&lt;', '>'=>'&gt;'}->{$1} || $1/ge;

    return($str);

}

sub Ascii2Uni($)

{

    (local $_ = shift()) =~ s/(?<!\r)\n/\r\n/g;  # Use CR+LF newlines

    s/(.)/$1\x00/gs;

    return("\xFF\xFE$_");

}

sub Uni2Ascii($)

{

    (local $_ = shift()) =~ s/(.)\x00/$1/gs;

    s/\r\n/\n/g;

    return(substr($_, 2));

}

sub GetTimestamp()

{

    my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = localtime();

    return(sprintf("%04d%02d%02d%02d%02d%02d%02d",

        $year + 1900, $mon + 1, $mday, $hour, $min, $sec, int(($yday + ($year == 109 ? 3 : -3)) / 7) + 1));

}

sub Sec2Min($)

{

    my $sec = shift();

    return(sprintf("%02d:%02d", $sec / 60, $sec % 60));

}

sub Wcard2Restr($)

{

    (my $wcard = shift()) =~ s/(.)/{"*"=>".*", "?"=>"."}->{$1} || "\Q$1\E"/ge;

    return($wcard);

}

sub Wcard2Regex($)

{

    my $restr = Wcard2Restr(shift());

    return(qr/$restr/i);

}

sub ParseCmdWords($)

{

    my $line = Trim(shift());

    $line =~ s/\\/\\\\/g if $gWinOS;

    return(Text::ParseWords::parse_line('\s+', 0, $line));

}

###############################################################################

#

sub DPrint($@)

{

    my ($verbose, @outlist) = @_;

    map { tr/\x00\x1F/#/ } @outlist;

    print(@outlist) if !$verbose || ($verbose & $gVerbose);

    push(@gLogbuf, @outlist) if ($verbose < 32) || ($verbose & $gVerbose);

    return if ($gLogfile eq "" || !@gLogbuf);

    print(LOG @gLogbuf);

    @gLogbuf = ();

}

sub Echo($$$)

{

    return if SkipICmd();

    my ($verbose, $str) = (shift(), shift());

    DPrint($verbose, shift() ? "$str\n" : Unquote($str));

}

###############################################################################

# File operations

sub PathConv($;$$$)

{

    my $path = shift();