Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 398 insertions, 0 deletions

diff --git a/src/VBox/Devices/EFI/Firmware/BaseTools/Scripts/UpdateBuildVersions.py b/src/VBox/Devices/EFI/Firmware/BaseTools/Scripts/UpdateBuildVersions.py
new file mode 100755
index 00000000..a02214a9
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/BaseTools/Scripts/UpdateBuildVersions.py
@@ -0,0 +1,398 @@
+## @file
+# Update build revisions of the tools when performing a developer build
+#
+# This script will modife the C/Include/Common/BuildVersion.h file and the two
+# Python scripts, Python/Common/BuildVersion.py and Python/UPT/BuildVersion.py.
+# If SVN is available, the tool will obtain the current checked out version of
+# the source tree for including the --version commands.
+
+#  Copyright (c) 2014 - 2015, Intel Corporation. All rights reserved.<BR>
+#
+#  SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+""" This program will update the BuildVersion.py and BuildVersion.h files used to set a tool's version value """
+from __future__ import absolute_import
+
+import os
+import shlex
+import subprocess
+import sys
+
+from argparse import ArgumentParser, SUPPRESS
+from tempfile import NamedTemporaryFile
+from types import IntType, ListType
+
+
+SYS_ENV_ERR = "ERROR : %s system environment variable must be set prior to running this tool.\n"
+
+__execname__ = "UpdateBuildVersions.py"
+SVN_REVISION = "$LastChangedRevision: 3 $"
+SVN_REVISION = SVN_REVISION.replace("$LastChangedRevision:", "").replace("$", "").strip()
+__copyright__ = "Copyright (c) 2014, Intel Corporation. All rights reserved."
+VERSION_NUMBER = "0.7.0"
+__version__ = "Version %s.%s" % (VERSION_NUMBER, SVN_REVISION)
+
+
+def ParseOptions():
+    """
+    Parse the command-line options.
+    The options for this tool will be passed along to the MkBinPkg tool.
+    """
+    parser = ArgumentParser(
+        usage=("%s [options]" % __execname__),
+        description=__copyright__,
+        conflict_handler='resolve')
+
+    # Standard Tool Options
+    parser.add_argument("--version", action="version",
+                        version=__execname__ + " " + __version__)
+    parser.add_argument("-s", "--silent", action="store_true",
+                        dest="silent",
+                        help="All output will be disabled, pass/fail determined by the exit code")
+    parser.add_argument("-v", "--verbose", action="store_true",
+                        dest="verbose",
+                        help="Enable verbose output")
+    # Tool specific options
+    parser.add_argument("--revert", action="store_true",
+                        dest="REVERT", default=False,
+                        help="Revert the BuildVersion files only")
+    parser.add_argument("--svn-test", action="store_true",
+                        dest="TEST_SVN", default=False,
+                        help="Test if the svn command is available")
+    parser.add_argument("--svnFlag", action="store_true",
+                        dest="HAVE_SVN", default=False,
+                        help=SUPPRESS)
+
+    return(parser.parse_args())
+
+
+def ShellCommandResults(CmdLine, Opt):
+    """ Execute the command, returning the output content """
+    file_list = NamedTemporaryFile(delete=False)
+    filename = file_list.name
+    Results = []
+
+    returnValue = 0
+    try:
+        subprocess.check_call(args=shlex.split(CmdLine), stderr=subprocess.STDOUT, stdout=file_list)
+    except subprocess.CalledProcessError as err_val:
+        file_list.close()
+        if not Opt.silent:
+            sys.stderr.write("ERROR : %d : %s\n" % (err_val.returncode, err_val.__str__()))
+            if os.path.exists(filename):
+                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)
+            sys.stderr.flush()
+        returnValue = err_val.returncode
+
+    except IOError as err_val:
+        (errno, strerror) = err_val.args
+        file_list.close()
+        if not Opt.silent:
+            sys.stderr.write("I/O ERROR : %s : %s\n" % (str(errno), strerror))
+            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)
+            if os.path.exists(filename):
+                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)
+            sys.stderr.flush()
+        returnValue = errno
+
+    except OSError as err_val:
+        (errno, strerror) = err_val.args
+        file_list.close()
+        if not Opt.silent:
+            sys.stderr.write("OS ERROR : %s : %s\n" % (str(errno), strerror))
+            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)
+            if os.path.exists(filename):
+                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)
+            sys.stderr.flush()
+        returnValue = errno
+
+    except KeyboardInterrupt:
+        file_list.close()
+        if not Opt.silent:
+            sys.stderr.write("ERROR : Command terminated by user : %s\n" % CmdLine)
+            if os.path.exists(filename):
+                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)
+            sys.stderr.flush()
+        returnValue = 1
+
+    finally:
+        if not file_list.closed:
+            file_list.flush()
+            os.fsync(file_list.fileno())
+            file_list.close()
+
+    if os.path.exists(filename):
+        fd_ = open(filename, 'r')
+        Results = fd_.readlines()
+        fd_.close()
+        os.unlink(filename)
+
+    if returnValue > 0:
+        return returnValue
+
+    return Results
+
+
+def UpdateBuildVersionPython(Rev, UserModified, opts):
+    """ This routine will update the BuildVersion.h files in the C source tree """
+    for SubDir in ["Common", "UPT"]:
+        PyPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "Python", SubDir)
+        BuildVersionPy = os.path.join(PyPath, "BuildVersion.py")
+        fd_ = open(os.path.normpath(BuildVersionPy), 'r')
+        contents = fd_.readlines()
+        fd_.close()
+        if opts.HAVE_SVN is False:
+            BuildVersionOrig = os.path.join(PyPath, "orig_BuildVersion.py")
+            fd_ = open (BuildVersionOrig, 'w')
+            for line in contents:
+                fd_.write(line)
+            fd_.flush()
+            fd_.close()
+        new_content = []
+        for line in contents:
+            if line.strip().startswith("gBUILD_VERSION"):
+                new_line = "gBUILD_VERSION = \"Developer Build based on Revision: %s\"" % Rev
+                if UserModified:
+                    new_line = "gBUILD_VERSION = \"Developer Build based on Revision: %s with Modified Sources\"" % Rev
+                new_content.append(new_line)
+                continue
+            new_content.append(line)
+
+        fd_ = open(os.path.normpath(BuildVersionPy), 'w')
+        for line in new_content:
+            fd_.write(line)
+        fd_.close()
+
+
+def UpdateBuildVersionH(Rev, UserModified, opts):
+    """ This routine will update the BuildVersion.h files in the C source tree """
+    CPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "C", "Include", "Common")
+    BuildVersionH = os.path.join(CPath, "BuildVersion.h")
+    fd_ = open(os.path.normpath(BuildVersionH), 'r')
+    contents = fd_.readlines()
+    fd_.close()
+    if opts.HAVE_SVN is False:
+        BuildVersionOrig = os.path.join(CPath, "orig_BuildVersion.h")
+        fd_ = open(BuildVersionOrig, 'w')
+        for line in contents:
+            fd_.write(line)
+        fd_.flush()
+        fd_.close()
+
+    new_content = []
+    for line in contents:
+        if line.strip().startswith("#define"):
+            new_line = "#define __BUILD_VERSION \"Developer Build based on Revision: %s\"" % Rev
+            if UserModified:
+                new_line = "#define __BUILD_VERSION \"Developer Build based on Revision: %s with Modified Sources\"" % \
+                            Rev
+            new_content.append(new_line)
+            continue
+        new_content.append(line)
+
+    fd_ = open(os.path.normpath(BuildVersionH), 'w')
+    for line in new_content:
+        fd_.write(line)
+    fd_.close()
+
+
+def RevertCmd(Filename, Opt):
+    """ This is the shell command that does the SVN revert """
+    CmdLine = "svn revert %s" % Filename.replace("\\", "/").strip()
+    try:
+        subprocess.check_output(args=shlex.split(CmdLine))
+    except subprocess.CalledProcessError as err_val:
+        if not Opt.silent:
+            sys.stderr.write("Subprocess ERROR : %s\n" % err_val)
+            sys.stderr.flush()
+
+    except IOError as err_val:
+        (errno, strerror) = err_val.args
+        if not Opt.silent:
+            sys.stderr.write("I/O ERROR : %d : %s\n" % (str(errno), strerror))
+            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)
+            sys.stderr.flush()
+
+    except OSError as err_val:
+        (errno, strerror) = err_val.args
+        if not Opt.silent:
+            sys.stderr.write("OS ERROR : %d : %s\n" % (str(errno), strerror))
+            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)
+            sys.stderr.flush()
+
+    except KeyboardInterrupt:
+        if not Opt.silent:
+            sys.stderr.write("ERROR : Command terminated by user : %s\n" % CmdLine)
+            sys.stderr.flush()
+
+    if Opt.verbose:
+        sys.stdout.write("Reverted this file: %s\n" % Filename)
+        sys.stdout.flush()
+
+
+def GetSvnRevision(opts):
+    """ Get the current revision of the BaseTools/Source tree, and check if any of the files have been modified """
+    Revision = "Unknown"
+    Modified = False
+
+    if opts.HAVE_SVN is False:
+        sys.stderr.write("WARNING: the svn command-line tool is not available.\n")
+        return (Revision, Modified)
+
+    SrcPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source")
+    # Check if there are modified files.
+    Cwd = os.getcwd()
+    os.chdir(SrcPath)
+
+    StatusCmd = "svn st -v --depth infinity --non-interactive"
+    contents = ShellCommandResults(StatusCmd, opts)
+    os.chdir(Cwd)
+    if isinstance(contents, ListType):
+        for line in contents:
+            if line.startswith("M "):
+                Modified = True
+                break
+
+    # Get the repository revision of BaseTools/Source
+    InfoCmd = "svn info %s" % SrcPath.replace("\\", "/").strip()
+    Revision = 0
+    contents = ShellCommandResults(InfoCmd, opts)
+    if isinstance(contents, IntType):
+        return 0, Modified
+    for line in contents:
+        line = line.strip()
+        if line.startswith("Revision:"):
+            Revision = line.replace("Revision:", "").strip()
+            break
+
+    return (Revision, Modified)
+
+
+def CheckSvn(opts):
+    """
+    This routine will return True if an svn --version command succeeds, or False if it fails.
+    If it failed, SVN is not available.
+    """
+    OriginalSilent = opts.silent
+    opts.silent = True
+    VerCmd = "svn --version"
+    contents = ShellCommandResults(VerCmd, opts)
+    opts.silent = OriginalSilent
+    if isinstance(contents, IntType):
+        if opts.verbose:
+            sys.stdout.write("SVN does not appear to be available.\n")
+            sys.stdout.flush()
+        return False
+
+    if opts.verbose:
+        sys.stdout.write("Found %s" % contents[0])
+        sys.stdout.flush()
+    return True
+
+
+def CopyOrig(Src, Dest, Opt):
+    """ Overwrite the Dest File with the Src File content """
+    try:
+        fd_ = open(Src, 'r')
+        contents = fd_.readlines()
+        fd_.close()
+        fd_ = open(Dest, 'w')
+        for line in contents:
+            fd_.write(line)
+        fd_.flush()
+        fd_.close()
+    except IOError:
+        if not Opt.silent:
+            sys.stderr.write("Unable to restore this file: %s\n" % Dest)
+            sys.stderr.flush()
+        return 1
+
+    os.remove(Src)
+    if Opt.verbose:
+        sys.stdout.write("Restored this file: %s\n" % Src)
+        sys.stdout.flush()
+
+    return 0
+
+
+def CheckOriginals(Opts):
+    """
+    If SVN was not available, then the tools may have made copies of the original BuildVersion.* files using
+    orig_BuildVersion.* for the name. If they exist, replace the existing BuildVersion.* file with the corresponding
+    orig_BuildVersion.* file.
+    Returns 0 if this succeeds, or 1 if the copy function fails. It will also return 0 if the orig_BuildVersion.* file
+    does not exist.
+    """
+    CPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "C", "Include", "Common")
+    BuildVersionH = os.path.join(CPath, "BuildVersion.h")
+    OrigBuildVersionH = os.path.join(CPath, "orig_BuildVersion.h")
+    if not os.path.exists(OrigBuildVersionH):
+        return 0
+    if CopyOrig(OrigBuildVersionH, BuildVersionH, Opts):
+        return 1
+    for SubDir in ["Common", "UPT"]:
+        PyPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "Python", SubDir)
+        BuildVersionPy = os.path.join(PyPath, "BuildVersion.h")
+        OrigBuildVersionPy = os.path.join(PyPath, "orig_BuildVersion.h")
+        if not os.path.exists(OrigBuildVersionPy):
+            return 0
+        if CopyOrig(OrigBuildVersionPy, BuildVersionPy, Opts):
+            return 1
+
+    return 0
+
+
+def RevertBuildVersionFiles(opts):
+    """
+    This routine will attempt to perform an SVN --revert on each of the BuildVersion.* files
+    """
+    if not opts.HAVE_SVN:
+        if CheckOriginals(opts):
+            return 1
+        return 0
+    # SVN is available
+    BuildVersionH = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "C", "Include", "Common", "BuildVersion.h")
+    RevertCmd(BuildVersionH, opts)
+    for SubDir in ["Common", "UPT"]:
+        BuildVersionPy = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "Python", SubDir, "BuildVersion.py")
+        RevertCmd(BuildVersionPy, opts)
+
+def UpdateRevisionFiles():
+    """ Main routine that will update the BuildVersion.py and BuildVersion.h files."""
+    options = ParseOptions()
+    # Check the working environment
+    if "WORKSPACE" not in os.environ.keys():
+        sys.stderr.write(SYS_ENV_ERR % 'WORKSPACE')
+        return 1
+    if 'BASE_TOOLS_PATH' not in os.environ.keys():
+        sys.stderr.write(SYS_ENV_ERR % 'BASE_TOOLS_PATH')
+        return 1
+    if not os.path.exists(os.environ['BASE_TOOLS_PATH']):
+        sys.stderr.write("Unable to locate the %s directory." % os.environ['BASE_TOOLS_PATH'])
+        return 1
+
+
+    options.HAVE_SVN = CheckSvn(options)
+    if options.TEST_SVN:
+        return (not options.HAVE_SVN)
+    # done processing the option, now use the option.HAVE_SVN as a flag. True = Have it, False = Don't have it.
+    if options.REVERT:
+        # Just revert the tools an exit
+        RevertBuildVersionFiles(options)
+    else:
+        # Revert any changes in the BuildVersion.* files before setting them again.
+        RevertBuildVersionFiles(options)
+        Revision, Modified = GetSvnRevision(options)
+        if options.verbose:
+            sys.stdout.write("Revision: %s is Modified: %s\n" % (Revision, Modified))
+            sys.stdout.flush()
+        UpdateBuildVersionH(Revision, Modified, options)
+        UpdateBuildVersionPython(Revision, Modified, options)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(UpdateRevisionFiles())
+
+