#

# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

#

#! /usr/bin/perl

#

# Series 60 SDK build script.

#

# Reads the configuration from sdk_build.conf file located in the same

# directory as the build script. The comments in the configuration file

# descripe its format.

#

# The important feature of this script is that it's not only part of the

# nightly build, but also part of the SDK development environment.

#

#   First, it re-generates the diffs after developer has

#   modified a platform file. It uses the diff utility

#   provided by the Symbian build environment (as opposed

#   to taking it from the PATH, be it MKS Toolkit, cygwin

#   or whatever else you may have installed). That makes

#   sure that the diff is produced in a standard format.

#   Also, if the diff didn't really change (the script will

#   ignore non-essential changes in the diff, such as time

#   stamps in the header) the diff file in platform_mod

#   doesn't get updated.

#

#   Second, the developers can (and do) re-run this script in

#   their work area, and that will produce the same result as

#   when it runs on top of a clean build area. Maybe not 100%

#   the same, but accurate enough to provide, say 95% guarantee

#   that if the build compiles on the developer's machine, it

#   will do the same in the nightly build. That will help us

#   to avoid broken builds.

#

#   Third, the script has minimal dependency on the

#   environment (i.e. environment variables, where the

#   CodeWarrior/VisualStudio/Perl are installed, etc.)

#   A typical problem of the build scripts is that they

#   make too many assumptions about the environment, and

#   it's only a matter of time when one build script starts

#   conflicting with another. Most developers build multiple

#   products on their machines. I've been in the situations

#   when one development environment breaks another. Very

#   frustrating and inefficient.

#

use Cwd;

use File::Copy;

use File::Temp;

use File::Path;

use File::Find;

use FindBin;

use Env qw(JAVA_HOME EPOCROOT BUILD_ROOT MWCIncludes PATH);

push (@INC, $FindBin::RealBin);

require "sdk_env.pl";

MAIN:{

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

# Log levels

$LOG_DEBUG = 2;

$LOG_VERBOSE = 1;

$LOG_NORMAL = 0;

$LOG_QUIET = -1;

$LOG_SILENT = -2;

# Build types

$BUILD_TYPE_CPP = 1;

$BUILD_TYPE_MIDP = 2;

$BUILD_TYPE_ALL = 3;

# Editable configuration

$LOGLEVEL = $LOG_NORMAL;

$DO_PATCH = 0;

$DO_DIFF = 0;

$BUILD_PLATFORM = 0;

$BUILD_JAVA = 0;

$BUILD_SDK = 0;

$LOG = 0;

$CLEAN = 0;

$REBUILD = 0;

$BUILD_TYPE = $BUILD_TYPE_ALL;

$CHECK_BUILD = 0;

$DO_UNPATCH = 0;

$FINALIZE_S60EX = 0;

# Non-edtable configuration

$FS = '/';  # File separator

$PS = ';';  # Path separator

@PLATFORMS = ("winscw");

@VARIANTS  = ("udeb", "urel");

@SDK_MODULES = (

  "NMIT",

  "msgsimulation",

  "xrpcrt",

  "wsock",

  "emumenubar",

  "bluetoothdriver",

  #"Tools",

);

$PATCH_LIST_FNAME = "sdk_build.conf";

$PLATFORM = get_plat_name ();

$SDK_PROJ_NAME = "PublicSDK/sdkcreationmw"; 

$PATCH_DIR = "$SDK_PROJ_NAME/sdkplatformupdates/";

$BUILD_SCRIPTS_DIR = $BUILD_ROOT . "$SDK_PROJ_NAME/sdkbuild";

$S60_TOOLS_DIR = $BUILD_ROOT . "$SDK_PROJ_NAME/sdkruntimes";

$BACKUP_PREFIX = ".#";

$PATCH_EXT = "diff";

$DIED_MSG = "ERROR!";

$WARNING = "WARNING:";

$NOTE = "NOTE:";

$NULL_NAME = "NULL";

$patch_list_path = "$BUILD_ROOT$PATCH_DIR/$PATCH_LIST_FNAME";

$TMP_CONF = "$BUILD_SCRIPTS_DIR/__tmp.conf";

$DIFF_EXE =  "$BUILD_SCRIPTS_DIR/diff.exe";

$PATCH_EXE = "$BUILD_SCRIPTS_DIR/patch.exe";

$REDIFF_CMD = "$DIFF_EXE -N -c5";

$LOG_FILE = sprintf ("sdk_build-%d%02d%02d_%02d-%02d-%02d.log",

                     $year + 1900, $mon + 1, $mday, $hour, $min, $sec);

# Define Java build configuration

$JAVA_SRC_ROOT = "${BUILD_ROOT}PublicSDK/sdkcreationmw/sdkconnectivityfw/emuconnectmanager/epdt_java";

$JAVA_BUILD_DIR = "${JAVA_SRC_ROOT}";

$JAVA_DIST_DIR = "${JAVA_SRC_ROOT}/build/ecmt";

$JAVA_TARGET_DIR = "${BUILD_ROOT}epoc32/tools/ecmt";

@JAVA_CLEAN_DIRS = (

  "$JAVA_TARGET_DIR/config",

  "$JAVA_TARGET_DIR/language",

  "$JAVA_TARGET_DIR/lib",

  "$JAVA_TARGET_DIR/log",

  "$JAVA_TARGET_DIR/plugins"

);

# parse the command line

  parse_cmd_line (@ARGV);

  $BUILD_ROOT = $ENV{BUILD_ROOT};

  $EPOCROOT = $ENV{EPOCROOT};

  @bld_info = ();

  if ($LOG && !(open (LOG_FH, "> $LOG_FILE"))) {

    warn "Could'n open log file $LOG_FILE. Logging is turned OFF.\n";

    $LOG = 0;

  }

  # Make sure that the required executables are there

  if (!-e $DIFF_EXE) {

    err ($DIFF_EXE . " is missing");

    exit 1;

  }

  if (!-e $PATCH_EXE) {

    err ($PATCH_EXE . " is missing");

    exit 1;

  }

  msg ("Build script started at " . localtime());

  msg ("Cmd line: $0 @ARGV");

  open PATCH_LIST, $patch_list_path or die "$DIED_MSG Could not find $patch_list_path!";

  if ($DO_PATCH) {

    # IMPORTANT! SDK now maintains two startup-lists, which both are modified

    # versions of the original one, but patched differently. To achieve this

    # we have to first make a copy of the original list. The copy is made of

    # .orig, if such exists - if not (i.e. very first patch), then from then

    # original file.

    # Unfortunately there is no simple way to do this without hardcoding.

    #

    #$starter_path = "${BUILD_ROOT}sf/os/devicesrv/sysstatemgmt/starter/starterserver/data";

    #$starter_list = "starter.rss";

    #$starter_list2 = "starter_full.rss";

    #if (not -e "$starter_path/$starter_list2") {

     # dbg ("making a copy of the startup-list");

     # if (-e "$starter_path/$starter_list.orig") {

      #  copy_or_die ("$starter_path/$starter_list.orig", "$starter_path/$starter_list2");

     # } else {

      #  copy_or_die ("$starter_path/$starter_list", "$starter_path/$starter_list2");

     # }

   # }

    #else {

     # dbg ("full startup-list already exists");

   # }

   #  This starter is commented by Dhanvantri For Integration  

   # $starter_non_critical_path = "${BUILD_ROOT}sf/os/devicesrv/sysstatemgmt/starter/starterserver/data";

   # $starter_non_critical_list = "starter_non_critical_1.rss";

   # $starter_non_critical_list2 = "starter_non_critical_1_full.rss";

   # if (not -e "$starter_non_critical_path/$starter_non_critical_list2") {

   #   dbg ("making a copy of the startup-list");

   #   if (-e "$starter_non_critical_path/$starter_non_critical_list.orig") {

   #     copy_or_die ("$starter_non_critical_path/$starter_non_critical_list.orig", "$starter_non_critical_path/$starter_non_critical_list2");

    #  } else {

     #   copy_or_die ("$starter_non_critical_path/$starter_non_critical_list", "$starter_non_critical_path/$starter_non_critical_list2");

     # }

   # }

   # else {

    #  dbg ("full startup-list for non critical section already exists");

    #}

  }

  # Collect full path names for all pathes.

  @all_patches = find_all ("$BUILD_ROOT$PATCH_DIR");

  $lineno = 0;

  while (<PATCH_LIST>) {

    $lineno++;

    chomp;

    # Input lines might end in backslashes to indicate continuation

    if (s/\\$//) {

        $_ .= <PATCH_LIST>;

        redo unless eof;

    }

    s/\#.*$//;                 # Get rid of the comments

    next if (/^\s*$/);         # Skip empty lines

    my @fdata = split /:/;     # Split the input line

    foreach (@fdata) {         # Ignore spaces before and after delimiters

      s/^\s+//;

      s/\s+$//;

    }

    my $path = shift @fdata;

    next if ($path eq "");

    # The first field is a name of the patch file.

    # By default it's "diff"

    my $relative_path = $path;

    my $patch_file = get_patch_fname ($path, @all_patches);

    if ($patch_file eq "") {

      $patch_file = "$BUILD_ROOT" . "$PATCH_DIR" . "$path.$PATCH_EXT";

      dbg ("Looking for: $patch_file");

      if (not -e $patch_file) {

        # This means that there is an entry in the patch list file

        # but there is no actual patch file under patch dir.

        # If so skip the line. The exception is DO_DIFF case since do_diff

        # can create patch files.

        if ($DO_DIFF) {

          $patch_file = "";

        }

        else {

          msg("$WARNING $PATCH_LIST_FNAME:$lineno: Missing patch file for $path");

          next;

        }

      }

    }

    else {

      $patch_file .= ".$PATCH_EXT";

    }

    # This shouldn't happen: there is a patch file name but no name for file

    # to be patched. If so skip this line.

    next if ($path eq "");

    $path = "$BUILD_ROOT" . $path;

    if ($LOGLEVEL >= $LOG_VERBOSE) {

      if (-e "$patch_file") {

        dbg ("patch file: $patch_file");

      } else {

        dbg ("patch file does not exist: $patch_file");

      }

      dbg ("fdata: @fdata");

    }

    # Diff'ing files only. It will generate new "diff" files.

    if ($DO_DIFF) {

      chdir_or_die ($BUILD_ROOT);

      do_diff ($path, $patch_file);

      next;

    }

    # Patch platform files

    if ($DO_PATCH) {

      my $res_file = $patch_file;

      $res_file =~ s/\.$PATCH_EXT$//;

      # Make a backup copy of the current version of the patched file.

      if (-e $path) {

        my $backup_path = get_last_backup_path ($path);

        if (!run("$DIFF_EXE $res_file $path", $NULL_NAME)) {

          dbg("$path is identical to $res_file");

        }

        elsif (-e $backup_path &&

            !run("$DIFF_EXE $backup_path $path", $NULL_NAME)) {

          dbg("$path is identical to $backup_path");

        } else {

          # file has changed, create a backup copy

          my $backup_path = get_new_backup_path ($path);

          dbg ("backup to $backup_path");

          copy ("$path", "$backup_path") or

            msg("$WARNING failed to copy $path -> $backup_path");

        }

      }

      # If patch file does not exist, patch means a copy

      if (-e "$patch_file") {

        patch_files ($path, $patch_file);

      } else {

        copy_or_die ($res_file, $path);

        msg ("Copied $path");

      }

    }

    if ($DO_UNPATCH) {

      do_unpatch($path, $patch_file);

    }

    # Process build info

    if ($#fdata >= 0) {

      if ($BUILD_PLATFORM || $CHECK_BUILD) {

        process_bld_info ($path, @fdata);

      }

    }

  }

  close PATCH_LIST;

  # if temp conf-file was used (i.e. -t option given), remove tmp-file

  if ($patch_list_path == $TMP_CONF) {

    dbg("deleting $TMP_CONF");

    unlink $TMP_CONF;

  }

  # Build Java first

  if ($BUILD_JAVA) {

    build_java ();

  }

  # build SDK modules

  # NOTE: some of the hooks in the platform code depend on the headers

  # exported by, for example, MsgRelay module

  if ($BUILD_SDK) {

    foreach $m (@SDK_MODULES) {

      if ($m =~ m/^wsock$/i) {

        # hack to make EXPORT work reliably

        my $now = time;

        my $esk = "$S60_TOOLS_DIR/wsock/data/wsock.esk";

        dbg ("touching $esk");

        utime ($now, $now, $esk) or msg ("$WARNING couldn't touch $esk\n");

      }

      # the rest is a standard procedure for all modules

      build_series60_tools_component ($m); 

    }

  }

  if ($BUILD_PLATFORM) {

    dbg ("Build info: @bld_info");

    do_platform_build (@bld_info);

  }

  #rebuild Java Subsystem in S60 (System AMS) except for C++ SDK

  if($BUILD_PLATFORM && $BUILD_TYPE != $BUILD_TYPE_CPP){

  	dbg ("Building java platform:");

  	do_java_platform_build();

  }

  if ($CHECK_BUILD) {

    foreach $m (@SDK_MODULES) {

      check_series60_tools_component ($m);

    }

    dbg ("Build info: @bld_info");

    check_platform_build (@bld_info);

  }

  	#TODO: Cleaning may not be required for 9.l check and add components in the below function

  	#do_s60_rndtools_cleaning();

	msg ("Build script finished at " . localtime());

  close ($LOG_FH) if $LOG;

}

# =======================================================================

  sub usage

# =======================================================================

  {

    print "Usage: sdk_build [-p | --patch] [-d | --diff] [-u | --unpatch]\

                 [-b | --build] [-m | --module [mod]] [-a | --all]\

                 [-r | --rebuild] [-c | --clean] [-e | -- err] [-l | --log]\

                 [-s | --silent] [-q | --quiet] [-v | --verbose]\

                 [-f | --config <file>] [-h | --help]\

                 [-t | --target <file>]\

                 [--env] [--midp] [--cpp] [--udeb] [--urel] [--s60ex]\

Options:\

  -p, --patch         patch the platform files\

  -d, --diff          diff the platform files and update patches\

  -u, --unpatch       undo patches and return platform to it's original state\

  -b, --build         build patched platform modules (implies -p)\

  -m, --module [mod]  build SDK modules (or one module if specified)\

  -j, --java          build Java mofules (EcmtManager, ...)\

  -a, --all           build everything (implies -b, -p, -m and -j)\

  -r, --rebuild       do complete rebuild rather than incremental build\

  -c, --clean         delete the output and intermediate files\

  -e, --err           check build errors\

  -l, --log           create log file in the current directory\

  -q, --quiet         be quiet\

  -s, --silent        be completely silent\

  -v, --verbose       be verbose (repeatable)\

  -f, --config <file> use <file> instead of patches/$PATCH_LIST_FNAME\

  -t, --target <file> patch/diff/unpatch a single target: <file>\

  -h, --help          print this help message and exit\

  --midp              MIDP build (don't build C++ specific components)\

  --cpp               C++ build (don't build MIDP specific components)\

  --udeb              only build debug (UDEB) targets\

  --urel              only build release (UREL) targets\

  --s60ex             finalize S60 C++ example applications\

  --env               print (some) build environment and exit\n";

  }

# =======================================================================

  sub parse_cmd_line

# =======================================================================

  {

    if ($#_ < 0) {

      usage ();

      exit;

    } else {

      $CONF_FILE_GIVEN = 0;

      $TARGET_FILE_GIVEN = 0;

      my $n = $#_ + 1;  # total number of options

      my $u = 0;        # number of unknown options

      while(defined (@_[0])) {

        my $arg = shift;

        if ($arg eq "-v" || $arg eq "--verbose")  { $LOGLEVEL++; }

        elsif ($arg eq "--env") {

          $LOGLEVEL = $LOG_VERBOSE;

          dbg("Environment variables:\n  JAVA_HOME: $ENV{JAVA_HOME}\n  EPOCROOT: $ENV{EPOCROOT}\n  BUILD_ROOT: $ENV{BUILD_ROOT}\n  MWCIncludes: $ENV{MWCIncludes}\n  PATH: $ENV{PATH}\n  INCLUDE: $ENV{INCLUDE}\n  LIB: $ENV{LIB}\n");

          exit;

        }

        elsif ($arg eq "--midp") {

          if ($BUILD_TYPE == $BUILD_TYPE_CPP) {

            err ("--midp and --cpp options are mutually exclusive");

            exit 1;

          }

          $BUILD_TYPE = $BUILD_TYPE_MIDP;

        }

        elsif ($arg eq "--cpp" || $arg eq "--c++") {

          if ($BUILD_TYPE == $BUILD_TYPE_MIDP) {

            err ("--midp and --cpp options are mutually exclusive");

            exit 1;

          }

          $BUILD_TYPE = $BUILD_TYPE_CPP;

        }

        elsif ($arg eq "--udeb") { @VARIANTS  = ("udeb"); }

        elsif ($arg eq "--urel") { @VARIANTS  = ("urel"); }

        elsif ($arg eq "-m" || $arg eq "--module" ) {

          $BUILD_SDK = 1;

          if ($DO_DIFF) {

            err ("--diff and --module options are mutually exclusive");

            exit 1;

          }

          # optional module name

          if (defined(@_[0])) {

            my $mod = @_[0];

            if (!($mod =~ m/^-/)) {

              @SDK_MODULES = (shift);

            }

          }

        }

        elsif ($arg eq "-b" || $arg eq "--build" ) {

          $BUILD_PLATFORM = 1;

          if (!$DO_UNPATCH) {

          $DO_PATCH = 1;

          }

          if ($DO_DIFF) {

            err ("--diff and --build options are mutually exclusive");

            exit 1;

          }