path: root/Platform/Intel/build_bios.py

#!/usr/bin/env python3
#
# @ build_bios.py
# Builds BIOS using configuration files and dynamically
# imported functions from board directory
#
# Copyright (c) 2019 - 2025, Intel Corporation. All rights reserved.<BR>
# Copyright (c) 2021, American Megatrends International LLC.<BR>
# SPDX-License-Identifier: BSD-2-Clause-Patent
#

"""
This module builds BIOS using configuration files and dynamically
imported functions from board directory
"""


import os
import re
import sys
import glob
import signal
import shutil
import argparse
import traceback
import subprocess
from importlib import import_module

try:
    # python 2.7
    import ConfigParser as configparser
except ImportError:
    # python 3
    import configparser


def pre_build(build_config, build_type="DEBUG", silent=False, toolchain=None, skip_tools=False):
    """Sets the environment variables that shall be used for the build

        :param build_config: The build configuration as defined in the JSON
            configuration files
        :type build_config: Dictionary
        :param build_type: The build target, DEBUG, RELEASE, RELEASE_PDB,
            TEST_RELEASE
        :type build_type: String
        :param silent: Enables build in silent mode
        :type silent: Boolean
        :param toolchain: Specifies the tool chain tag to use for the build
        :type toolchain: String
        :returns: The updated environment variables
        :rtype: Dictionary
    """

    # get current environment variables
    config = os.environ.copy()

    # patch the build config
    build_config = patch_config(build_config)

    # update the current config with the build config
    config.update(build_config)

    # make the config and build python 2.7 compatible
    config = py_27_fix(config)

    # Set WORKSPACE environment.
    config["WORKSPACE"] = os.path.abspath(os.path.join("..", "..", "..", ""))
    print("Set WORKSPACE as: {}".format(config["WORKSPACE"]))

    # Check whether Git has been installed and been added to system path.
    try:
        subprocess.Popen(["git", "--help"], stdout=subprocess.PIPE)
    except OSError:
        print("The 'git' command is not recognized.")
        print("Please make sure that Git is installed\
                and has been added to system path.")
        sys.exit(1)

    # Create the Conf directory under WORKSPACE
    if not os.path.isdir(os.path.join(config["WORKSPACE"], "Conf")):
        try:
            # create directory
            os.makedirs(os.path.join(config["WORKSPACE"], "Conf"))
            # copy files to it
            config_template_path = os.path.join(config["WORKSPACE"],
                                                config["BASE_TOOLS_PATH"],
                                                "Conf")
            config_path = os.path.join(config["WORKSPACE"], "Conf")
            shutil.copyfile(config_template_path +
                            os.sep + "target.template",
                            config_path + os.sep + "target.txt")
            shutil.copyfile(config_template_path +
                            os.sep + "tools_def.template",
                            config_path + os.sep + "tools_def.txt")
            shutil.copyfile(config_template_path +
                            os.sep + "build_rule.template",
                            config_path + os.sep + "build_rule.txt")
        except OSError:
            print("Error while creating Conf")
            sys.exit(1)

    # Set other environments.
    # Basic Rule:
    # Platform override Silicon override Core
    # Source override Binary
    config["WORKSPACE_PLATFORM"] = os.path.join(config["WORKSPACE"],
                                                config["WORKSPACE_PLATFORM"])
    config["WORKSPACE_SILICON"] = os.path.join(config["WORKSPACE"],
                                               config["WORKSPACE_SILICON"])
    config["WORKSPACE_FEATURES"] = os.path.join(config["WORKSPACE"],
                                               config["WORKSPACE_FEATURES"])
    config["WORKSPACE_FEATURES_INTEL"] = os.path.join(config["WORKSPACE"],
                                            config["WORKSPACE_FEATURES_INTEL"])
    config["WORKSPACE_DRIVERS"] = os.path.join(config["WORKSPACE"],
                                               config["WORKSPACE_DRIVERS"])
    config["WORKSPACE_PLATFORM_BIN"] = \
        os.path.join(config["WORKSPACE"], config["WORKSPACE_PLATFORM_BIN"])
    config["WORKSPACE_SILICON_BIN"] = \
        os.path.join(config["WORKSPACE"], config["WORKSPACE_SILICON_BIN"])
    config["WORKSPACE_FSP_BIN"] = os.path.join(config["WORKSPACE"],
                                               config["WORKSPACE_FSP_BIN"])

    # add to package path
    config["PACKAGES_PATH"] = config["WORKSPACE_PLATFORM"]
    config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_SILICON"]
    config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_SILICON_BIN"]
    config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_FEATURES"]
    config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_FEATURES_INTEL"]
    # add all feature domains in WORKSPACE_FEATURES_INTEL to package path
    for filename in os.listdir(config["WORKSPACE_FEATURES_INTEL"]):
        filepath = os.path.join(config["WORKSPACE_FEATURES_INTEL"], filename)
        # feature domains folder does not contain dec file
        if os.path.isdir(filepath) and \
          not glob.glob(os.path.join(filepath, "*.dec")):
            config["PACKAGES_PATH"] += os.pathsep + filepath
    config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_DRIVERS"]
    config["PACKAGES_PATH"] += os.pathsep + \
        os.path.join(config["WORKSPACE"], config["WORKSPACE_FSP_BIN"])
    config["PACKAGES_PATH"] += os.pathsep + \
        os.path.join(config["WORKSPACE"], config["WORKSPACE_CORE"])
    config["PACKAGES_PATH"] += os.pathsep + os.path.join(config["WORKSPACE"])
    config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_PLATFORM_BIN"]
    config["EDK_TOOLS_PATH"] = os.path.join(config["WORKSPACE"],
                                            config["EDK_TOOLS_PATH"])
    config["BASE_TOOLS_PATH"] = config["EDK_TOOLS_PATH"]
    config["EDK_TOOLS_BIN"] = os.path.join(config["WORKSPACE"],
                                           config["EDK_TOOLS_BIN"])

    #
    # Board may have different FSP binary between API and Dispatch modes.
    # In API mode if FSP_BIN_PKG_FOR_API_MODE is assigned, it should
    # override FSP_BIN_PKG.
    #
    if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE":
        if config.get("FSP_BIN_PKG_FOR_API_MODE") is not None:
            config['FSP_BIN_PKG'] = config['FSP_BIN_PKG_FOR_API_MODE']

    config["PLATFORM_FSP_BIN_PACKAGE"] = \
        os.path.join(config['WORKSPACE_FSP_BIN'], config['FSP_BIN_PKG'])
    config['PROJECT_DSC'] = os.path.join(config["WORKSPACE_PLATFORM"],
                                         config['PROJECT_DSC'])
    config['BOARD_PKG_PCD_DSC'] = os.path.join(config["WORKSPACE_PLATFORM"],
                                               config['BOARD_PKG_PCD_DSC'])
    config["CONF_PATH"] = os.path.join(config["WORKSPACE"], "Conf")

    # get the python path
    if os.environ.get("PYTHON_HOME") is None:
        if os.environ.get("PYTHONPATH") is not None:
            config["PYTHON_HOME"] = os.environ.get("PYTHONPATH")
        else:
            config["PYTHON_HOME"] = os.path.dirname(sys.executable)
            config["PYTHONPATH"] = config["PYTHON_HOME"]

    if config.get("PYTHON_HOME") is None or \
       not os.path.exists(config.get("PYTHON_HOME")):
        print("PYTHON_HOME environment variable is not found")
        sys.exit(1)

    # if python is installed, disable the binary base tools.
    # python is installed if this code is running :)
    if config.get("PYTHON_HOME") is not None:
        if config.get("EDK_TOOLS_BIN") is not None:
            del config["EDK_TOOLS_BIN"]

    if os.name == 'nt' and toolchain is not None and \
        toolchain.startswith ('CLANG') and 'BASETOOLS_MINGW_PATH' in config:
        config['BASETOOLS_MINGW_BUILD'] = 'TRUE'
        if config.get("EDK_SETUP_OPTION"):
            config["EDK_SETUP_OPTION"] = config["EDK_SETUP_OPTION"].strip() + " " + "Mingw-w64"
        else:
            config["EDK_SETUP_OPTION"] = "Mingw-w64"
        config["PATH"] = os.path.join(config["BASETOOLS_MINGW_PATH"],
                                    "bin") + os.pathsep + config["PATH"]
        del config["CLANG_BIN"]
        del config["CLANG_HOST_BIN"]

    # Run edk setup and  update config
    if os.name == 'nt':
        edk2_setup_cmd = [os.path.join(config["EFI_SOURCE"], "edksetup"),
                          "Rebuild"]

        if config.get("EDK_SETUP_OPTION") and \
           config["EDK_SETUP_OPTION"] != " ":
            edk2_setup_cmd.append(config["EDK_SETUP_OPTION"])

        _, _, result, return_code = execute_script(edk2_setup_cmd,
                                                   config,
                                                   collect_env=True,
                                                   shell=True)
        if return_code == 0 and result is not None and isinstance(result,
                                                                  dict):
            config.update(result)
    else:
        # UNIX environment variable setup
        if os.environ.get("PYTHON_COMMAND") is not None:
            config["PYTHON_COMMAND"] = os.environ.get("PYTHON_COMMAND")
        else:
            config["PYTHON_COMMAND"] = sys.executable

        # Add BaseTools shell wrappers to the PATH
        config["PATH"] = os.path.join(config["BASE_TOOLS_PATH"],
                                    "BinPipWrappers", "PosixLike") + \
                                        os.pathsep + config["PATH"]

    # Make BaseTools source
    # and enable BaseTools source build
    shell = True
    command = ["nmake", "-f", os.path.join(config["BASE_TOOLS_PATH"],
                                           "Makefile")]
    if os.name == 'nt' and toolchain is not None and \
        toolchain.startswith ('CLANG') and 'BASETOOLS_MINGW_PATH' in config:
        command = ["mingw32-make", "-C", os.path.join(config["BASE_TOOLS_PATH"])]
    if os.name == "posix":  # linux
        shell = False
        command = ["make", "-C", os.path.join(config["BASE_TOOLS_PATH"])]

    if not skip_tools:
        _, _, result, return_code = execute_script(command, config, shell=shell)
        if return_code != 0:
            #
            # If the BaseTools build fails, then run a clean build and retry
            #
            clean_command = ["nmake", "-f",
                            os.path.join(config["BASE_TOOLS_PATH"], "Makefile"),
                            "clean"]
            if os.name == 'nt' and toolchain is not None and \
                toolchain.startswith ('CLANG') and 'BASETOOLS_MINGW_PATH' in config:
                clean_command = ["mingw32-make", "-C",
                                os.path.join(config["BASE_TOOLS_PATH"], "clean")]
            if os.name == "posix":
                clean_command = ["make", "-C",
                                os.path.join(config["BASE_TOOLS_PATH"]), "clean"]
            _, _, result, return_code = execute_script(clean_command, config,
                                                    shell=shell)
            if return_code != 0:
                build_failed(config)
            _, _, result, return_code = execute_script(command, config, shell=shell)
            if return_code != 0:
                build_failed(config)

    #
    # build platform silicon tools
    #
    # save the current workspace
    saved_work_directory = config["WORKSPACE"]
    # change the workspace to silicon tools directory
    config["WORKSPACE"] = os.path.join(config["WORKSPACE_SILICON"], "Tools")

    command = ["nmake"]
    if os.name == 'nt' and toolchain is not None and \
        toolchain.startswith ('CLANG') and 'BASETOOLS_MINGW_PATH' in config:
        command = ["mingw32-make"]
    if os.name == "posix":  # linux
        command = ["make"]
        # add path to generated FitGen binary to
        # environment path variable
        config["PATH"] += os.pathsep + \
                          os.path.join(config["BASE_TOOLS_PATH"],
                                       "Source", "C", "bin")

    # build the silicon tools
    _, _, result, return_code = execute_script(command, config, shell=shell)
    if return_code != 0:
        #
        # If the BaseTools build fails, then run a clean build and retry
        #
        clean_command = ["nmake", "clean"]
        if os.name == 'nt' and toolchain is not None and \
            toolchain.startswith ('CLANG') and 'BASETOOLS_MINGW_PATH' in config:
            clean_command = ["mingw32-make", "clean"]
        if os.name == "posix":
            clean_command = ["make", "clean"]
        _, _, result, return_code = execute_script(clean_command, config,
                                                shell=shell)
        if return_code != 0:
            build_failed(config)
        _, _, result, return_code = execute_script(command, config, shell=shell)
        if return_code != 0:
            build_failed(config)

    # restore WORKSPACE environment variable
    config["WORKSPACE"] = saved_work_directory

    config["SILENT_MODE"] = 'TRUE' if silent else 'FALSE'

    print("==============================================")

    if os.path.isfile(os.path.join(config['WORKSPACE'], "Prep.log")):
        os.remove(os.path.join(config['WORKSPACE'], "Prep.log"))

    config["PROJECT"] = os.path.join(config["PLATFORM_BOARD_PACKAGE"],
                                     config["BOARD"])

    # Setup Build
    # @todo: Need better TOOL_CHAIN_TAG detection
    if toolchain is not None:
        config["TOOL_CHAIN_TAG"] = toolchain
    elif config.get("TOOL_CHAIN_TAG") is None:
        if os.name == 'nt':
            config["TOOL_CHAIN_TAG"] = "VS2015"
        else:
            config["TOOL_CHAIN_TAG"] = "GCC5"

    # echo Show CL revision
    config["PrepRELEASE"] = build_type

    if build_type == "DEBUG":
        config["TARGET"] = 'DEBUG'
        config["TARGET_SHORT"] = 'D'
    else:
        config["TARGET"] = 'RELEASE'
        config["TARGET_SHORT"] = 'R'

    # set BUILD_DIR_PATH path
    config["BUILD_DIR_PATH"] = os.path.join(config["WORKSPACE"],
                                            'Build',
                                            config["PROJECT"],
                                            "{}_{}".format(
                                                config["TARGET"],
                                                config["TOOL_CHAIN_TAG"]))
    # set BUILD_DIR path
    config["BUILD_DIR"] = os.path.join('Build',
                                       config["PROJECT"],
                                       "{}_{}".format(
                                           config["TARGET"],
                                           config["TOOL_CHAIN_TAG"]))

    config["BUILD_X64"] = os.path.join(config["BUILD_DIR_PATH"], 'X64')
    config["BUILD_IA32"] = os.path.join(config["BUILD_DIR_PATH"], 'IA32')

    if not os.path.isdir(config["BUILD_DIR_PATH"]):
        try:
            os.makedirs(config["BUILD_DIR_PATH"])
        except OSError:
            print("Error while creating Build folder")
            sys.exit(1)

    # Set FSP_WRAPPER_BUILD
    if config['FSP_WRAPPER_BUILD'] == "TRUE":
        # Create dummy Fsp_Rebased_S_padded.fd to build the BiosInfo.inf
        # if it is wrapper build, due to the SECTION inclusion
        open(os.path.join(config["WORKSPACE_FSP_BIN"],
                          config["FSP_BIN_PKG"],
                          "Fsp_Rebased_S_padded.fd"), 'w').close()

    if not os.path.isdir(config["BUILD_X64"]):
        try:
            os.mkdir(config["BUILD_X64"])
        except OSError:
            print("Error while creating {}".format(config["BUILD_X64"]))
            sys.exit(1)

    # update config file with changes
    update_target_file(config)

    # Additional pre build scripts for this platform
    result = pre_build_ex(config)
    if result is not None and isinstance(result, dict):
        config.update(result)

    # print user settings
    print("BIOS_SIZE_OPTION     = {}".format(config["BIOS_SIZE_OPTION"]))
    print("EFI_SOURCE           = {}".format(config["EFI_SOURCE"]))
    print("TARGET               = {}".format(config["TARGET"]))
    print("TARGET_ARCH          = {}".format("IA32 X64"))
    print("TOOL_CHAIN_TAG       = {}".format(config["TOOL_CHAIN_TAG"]))
    print("WORKSPACE            = {}".format(config["WORKSPACE"]))
    print("WORKSPACE_CORE       = {}".format(config["WORKSPACE_CORE"]))
    print("EXT_BUILD_FLAGS      = {}".format(config["EXT_BUILD_FLAGS"]))

    return config


def build(config):
    """Builds the BIOS image

        :param config: The environment variables to be used
            in the build process
        :type config: Dictionary
        :returns: nothing
    """

    if config["FSP_WRAPPER_BUILD"] == "TRUE":
        pattern = "Fsp_Rebased.*\\.fd$"
        file_dir = os.path.join(config['WORKSPACE_FSP_BIN'],
                                config['FSP_BIN_PKG'])
        for item in os.listdir(file_dir):
            if re.search(pattern, item):
                os.remove(os.path.join(file_dir, item))

        command = [sys.executable, os.path.join(config['WORKSPACE_PLATFORM'],
                                config['PLATFORM_PACKAGE'],
                                'Tools', 'Fsp',
                                'RebaseFspBinBaseAddress.py'),
                   os.path.join(config['WORKSPACE_PLATFORM'],
                                config['FLASH_MAP_FDF']),
                   os.path.join(config['WORKSPACE_FSP_BIN'],
                                config['FSP_BIN_PKG']),
                   "Fsp.fd",
                   "0x0"]

        _, _, _, return_code = execute_script(command, config, shell=False)

        if return_code != 0:
            print("ERROR:RebaseFspBinBaseAddress failed")
            sys.exit(return_code)

        # create Fsp_Rebased.fd which is Fsp_Rebased_S.fd +
        # Fsp_Rebased_M + Fsp_Rebased_T
        with open(os.path.join(file_dir, "Fsp_Rebased_S.fd"), 'rb') as fsp_s, \
                open(os.path.join(file_dir,
                                  "Fsp_Rebased_M.fd"), 'rb') as fsp_m, \
                open(os.path.join(file_dir,
                                  "Fsp_Rebased_T.fd"), 'rb') as fsp_t:

            fsp_rebased = fsp_s.read() + fsp_m.read() + fsp_t.read()
            with open(os.path.join(file_dir,
                                   "Fsp_Rebased.fd"), 'wb') as new_fsp:
                new_fsp.write(fsp_rebased)

        if not os.path.isfile(os.path.join(file_dir, "Fsp_Rebased.fd")):
            print("!!! ERROR:failed to create fsp!!!")
            sys.exit(1)

    # Output the build variables the user has selected.
    print("==========================================")
    print(" User Selected build options:")
    print(" SILENT_MODE    = ", config.get("SILENT_MODE"))
    print(" REBUILD_MODE   = ", config.get("REBUILD_MODE"))
    print(" BUILD_ROM_ONLY = ", config.get("BUILD_ROM_ONLY"))
    print(" BINARY_CACHE_CMD_LINE = ", config.get("HASH"), config.get("BINARY_CACHE_CMD_LINE"))
    print("==========================================")

    command = ["build", "-n", config["NUMBER_OF_PROCESSORS"]]

    if config["REBUILD_MODE"] and config["REBUILD_MODE"] != "":
        command.append(config["REBUILD_MODE"])

    if config["EXT_BUILD_FLAGS"] and config["EXT_BUILD_FLAGS"] != "":
        ext_build_flags = config["EXT_BUILD_FLAGS"].split(" ")
        ext_build_flags = [x.strip() for x in ext_build_flags]
        ext_build_flags = [x for x in ext_build_flags if x != ""]
        command.extend(ext_build_flags)

    if config.get('BINARY_CACHE_CMD_LINE'):
        command.append(config['HASH'])
        command.append(config['BINARY_CACHE_CMD_LINE'])

    if config.get("SILENT_MODE", "FALSE") == "TRUE":
        command.append("--silent")
        command.append("--quiet")

    else:
        command.append("--log=" + config.get("BUILD_LOG", "Build.log"))
        command.append("--report-file=" +
                       config.get("BUILD_REPORT", "BuildReport.log"))

    if config.get("VERBOSE", "FALSE") == "TRUE":
        command.append("--verbose")

    if config.get("VERY_VERBOSE", "FALSE") == "TRUE":
        command.append("--debug=1")

    if config.get("MAX_SOCKET") is not None:
        command.append("-D")
        command.append("MAX_SOCKET=" + config["MAX_SOCKET"])

    if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE":
        #Override PCD to enable API mode FSP wrapper.
        command.append("--pcd")
        command.append("gIntelFsp2WrapperTokenSpaceGuid.PcdFspModeSelection=1")

    if config.get("PERFORMANCE_BUILD", "FALSE") == "TRUE":
        command.append("--pcd")
        command.append("gMinPlatformPkgTokenSpaceGuid.PcdPerformanceEnable=True")

    shell = True
    if os.name == "posix":
        shell = False

    _, _, _, exit_code = execute_script(command, config, shell=shell)
    if exit_code != 0:
        build_failed(config)

    # Additional build scripts for this platform
    result = build_ex(config)
    if result is not None and isinstance(result, dict):
        config.update(result)

    return config


def post_build(config):
    """Post build process of BIOS image

    :param config: The environment variables to be used in the build process
    :type config: Dictionary
    :returns: nothing
    """
    print("Running post_build to complete the build process.")
    board_fd = config["BOARD"].upper()
    final_fd = os.path.join(config["BUILD_DIR_PATH"], "FV",
                            "{}.fd".format(board_fd))

    if config["BIOS_INFO_GUID"]:
        # Generate the fit table
        print("Generating FIT ...")
        if os.path.isfile(final_fd):
            temp_fd = os.path.join(config["BUILD_DIR_PATH"], "FV",
                                   "{}_.fd".format(board_fd))
            shell = True
            command = ["FitGen", "-D",
                       final_fd, temp_fd, "-NA",
                       "-I", config["BIOS_INFO_GUID"]]   #@todo: Need mechanism to add additional options to the FitGen command line

            if os.name == "posix": # linux
                shell = False

            _, _, result, return_code = execute_script(command, config, shell=shell)
            if return_code != 0:
                print("Error while generating fit")
            else:
                # copy output to final binary
                shutil.copyfile(temp_fd, final_fd)
                # remove temp file
                os.remove(temp_fd)
        else:
            print("{} does not exist".format(final_fd))
            # remove temp file

    # Additional build scripts for this platform
    result = post_build_ex(config)
    if result is not None and isinstance(result, dict):
        config.update(result)

    # cleanup
    pattern = "Fsp_Rebased.*\\.fd$"
    file_dir = os.path.join(config['WORKSPACE_FSP_BIN'],
                            config['FSP_BIN_PKG'])
    for item in os.listdir(file_dir):
        if re.search(pattern, item):
            os.remove(os.path.join(file_dir, item))

    if config.get("DYNAMIC_BUILD_INIT_FILES") is not None:
        for item in config["DYNAMIC_BUILD_INIT_FILES"].split(","):
            try:
                os.remove(item)  # remove __init__.py
                os.remove(item + "c")  # remove __init__.pyc as well
            except OSError:
                pass

    print("Done")
    if os.path.isfile(final_fd):
        print("Fd file can be found at {}".format(final_fd))

def build_failed(config):
    """Displays results when build fails

        :param config: The environment variables used in the build process
        :type config: Dictionary
        :returns: nothing
    """
    print(" The EDKII BIOS Build has failed!")
    # clean up
    if config.get("DYNAMIC_BUILD_INIT_FILES") is not None:
        for item in config["DYNAMIC_BUILD_INIT_FILES"].split(","):
            if os.path.isfile(item):
                try:
                    os.remove(item)  # remove __init__.py
                    os.remove(item + "c")  # remove __init__.pyc as well
                except OSError:
                    pass
    sys.exit(1)


def import_platform_lib(path, function):
    """Imports custom functions for the platforms being built

        :param path: the location of the custom build script to be executed
        :type path: String
        :param path: the function to be executed
        :type path: String
        :returns: nothing
    """
    if path.endswith(".py"):
        path = path[:-3]
    path = path.replace(os.sep, ".")
    module = import_module(path)
    lib = getattr(module, function)
    return lib


def pre_build_ex(config):
    """ An extension of the pre_build process as defined platform
        specific pre_build setup script

        :param config: The environment variables used in the pre build process
        :type config: Dictionary
        :returns: config dictionary
        :rtype: Dictionary
    """
    if config.get("ADDITIONAL_SCRIPTS"):
        try:
            platform_function =\
                import_platform_lib(config["ADDITIONAL_SCRIPTS"],
                                    "pre_build_ex")
            functions = {"execute_script": execute_script}
            return platform_function(config, functions)
        except ImportError as error:
            print(config["ADDITIONAL_SCRIPTS"], str(error))
            build_failed(config)
    return None


def build_ex(config):
    """ An extension of the build process as defined platform
        specific build setup script

        :param config: The environment variables used in the build process
        :type config: Dictionary
        :returns: config dictionary
        :rtype: Dictionary
    """
    if config.get("ADDITIONAL_SCRIPTS"):
        try:
            platform_function =\
                import_platform_lib(config["ADDITIONAL_SCRIPTS"],
                                    "build_ex")
            functions = {"execute_script": execute_script}
            return platform_function(config, functions)
        except ImportError as error:
            print("error", config["ADDITIONAL_SCRIPTS"], str(error))
            build_failed(config)
    return None


def post_build_ex(config):
    """ An extension of the post build process as defined platform
        specific build setup script

        :param config: The environment variables used in the post build
            process
        :type config: Dictionary
        :returns: config dictionary
        :rtype: Dictionary
    """
    if config.get("ADDITIONAL_SCRIPTS"):
        try:
            platform_function =\
                import_platform_lib(config["ADDITIONAL_SCRIPTS"],
                                    "post_build_ex")
            functions = {"execute_script": execute_script}
            return platform_function(config, functions)
        except ImportError as error:
            print(config["ADDITIONAL_SCRIPTS"], str(error))
            build_failed(config)
    return None


def clean_ex(config):
    """ An extension of the platform cleaning

        :param config: The environment variables used in the clean process
        :type config: Dictionary
        :returns: config dictionary
        :rtype: Dictionary
    """
    if config.get("ADDITIONAL_SCRIPTS"):
        try:
            platform_function =\
                import_platform_lib(config["ADDITIONAL_SCRIPTS"],
                                    "clean_ex")
            functions = {"execute_script": execute_script}
            return platform_function(config, functions)
        except ImportError as error:
            print(config["ADDITIONAL_SCRIPTS"], str(error))
            build_failed(config)
    return None


def get_environment_variables(std_out_str, marker):
    """Gets the environment variables from a process

        :param std_out_str: The std_out pipe
        :type std_out_str: String
        :param marker: A begining and end mark of environment
            variables printed to std_out
        :type marker: String
        :returns: The environment variables read from the process' std_out pipe
        :rtype: Tuple
    """
    start_env_update = False
    environment_vars = {}
    out_put = ""
    for line in std_out_str.split("\n"):
        if start_env_update and len(line.split("=")) == 2:
            key, value = line.split("=")
            environment_vars[key] = value
        else:
            out_put += "\n" + line.replace(marker, "")

        if marker in line:
            if start_env_update:
                start_env_update = False
            else:
                start_env_update = True
    return (out_put, environment_vars)


def execute_script(command, env_variables, collect_env=False,
                   enable_std_pipe=False, shell=True):
    """launches a process that executes a script/shell command passed to it

        :param command: The command/script with its commandline
            arguments to be executed
        :type command:  List:String
        :param env_variables: Environment variables passed to the process
        :type env_variables: String
        :param collect_env: Enables the collection of environment variables
            when process execution is done
        :type collect_env: Boolean
        :param enable_std_pipe: Enables process out to be piped to
        :type enable_std_pipe: String
        :returns: a tuple of std_out, stderr , environment variables,
            return code
        :rtype: Tuple: (std_out, stderr , enVar, return_code)
    """

    print("Calling " + " ".join(command))

    env_marker = '-----env-----'
    env = {}
    kwarg = {"env": env_variables,
             "universal_newlines": True,
             "shell": shell,
             "cwd": env_variables["WORKSPACE"]}

    if enable_std_pipe or collect_env:
        kwarg["stdout"] = subprocess.PIPE
        kwarg["stderr"] = subprocess.PIPE

    # collect environment variables
    if collect_env:
        # get the binary that prints environment variables based on os
        if os.name == 'nt':
            get_var_command = "set"
        else:
            get_var_command = "env"
        # modify the command to print the environment variables
        if isinstance(command, list):
            command += ["&&", "echo", env_marker, "&&",
                        get_var_command, "&&", "echo", env_marker]
        else:
            command += " " + " ".join(["&&", "echo", env_marker,
                                       "&&", get_var_command,
                                       "&&", "echo", env_marker])

    # execute the command
    execute = subprocess.Popen(command, **kwarg)
    std_out, stderr = execute.communicate()
    code = execute.returncode

    # wait for process to be done
    execute.wait()

    # if collect environment variables
    if collect_env:
        # get the new environment variables
        std_out, env = get_environment_variables(std_out, env_marker)
    return (std_out, stderr, env, code)


def patch_config(config):
    """ An extension of the platform cleaning

        :param config: The environment variables used in the build process
        :type config: Dictionary
        :returns: config dictionary
        :rtype: Dictionary
    """
    new_config = {}
    for key in config:
        new_config[str(key)] = str(config[key].replace("/", os.sep))
    return new_config


def py_27_fix(config):
    """  Prepares build for python 2.7 => build
        :param config: The environment variables used in the build process
        :type config: Dictionary
        :returns: config dictionary
        :rtype: Dictionary
    """
    if not sys.version_info > (3, 0):
        path_list = []
        # create __init__.py in directories in this path
        if config.get("ADDITIONAL_SCRIPTS"):
            # get the directory
            path_to_directory =\
                os.path.dirname(config.get("ADDITIONAL_SCRIPTS"))
            path = ""
            for directories in path_to_directory.split(os.sep):
                path += directories + os.sep
                init_file = path + os.sep + "__init__.py"
                if not os.path.isfile(init_file):
                    open(init_file, 'w').close()
                    path_list.append(init_file)
            config["DYNAMIC_BUILD_INIT_FILES"] = ",".join(path_list)

    return config


def clean(build_config, board=False):
    """Cleans the build workspace

        :param config: The environment variables used in the build process
        :type config: Dictionary
        :param board: This flag specifies specific board clean
        :type board: Bool
        :returns: nothing
    """

    # patch the config
    build_config = patch_config(build_config)

    # get current environment variables
    config = os.environ.copy()

    # update it with the build variables
    config.update(build_config)

    if config.get('WORKSPACE') is None or not config.get('WORKSPACE'):
        config["WORKSPACE"] =\
                os.path.abspath(os.path.join("..", "..", "..", ""))

    # build cleanall
    print("Cleaning directories...")

    if board:
        platform_pkg = config.get("PLATFORM_BOARD_PACKAGE", None)
        if platform_pkg is None or\
            not os.path.isdir(os.path.join(config['WORKSPACE'],
                                           "Build", platform_pkg)):
            print("Platform package not found")
            sys.exit(1)
        else:
            print("Removing " + os.path.join(config['WORKSPACE'],
                                             "Build", platform_pkg))
            shutil.rmtree(os.path.join(config['WORKSPACE'],
                                       "Build", platform_pkg))

    else:
        if os.path.isdir(os.path.join(config['WORKSPACE'], "Build")):
            print("Removing " + os.path.join(config['WORKSPACE'], "Build"))
            shutil.rmtree(os.path.join(config['WORKSPACE'], "Build"))

    if os.path.isdir(os.path.join(config['WORKSPACE'], "Conf")):
        print("Removing " + os.path.join(config['WORKSPACE'], "Conf"))
        shutil.rmtree(os.path.join(config['WORKSPACE'], "Conf"))

    print("Cleaning files...")

    if os.path.isfile(os.path.join(config['WORKSPACE'],
                                   config.get("BUILD_REPORT",
                                              "BuildReport.log"))):
        print("Removing ", os.path.join(config['WORKSPACE'],
                                        config.get("BUILD_REPORT",
                                                   "BuildReport.log")))
        os.remove(os.path.join(config['WORKSPACE'],
                               config.get("BUILD_REPORT", "BuildReport.log")))

    print("  All done...")

    sys.exit(0)


def update_target_file(config):
    """Updates Conf's target file that will be used in the build

        :param config: The environment variables used in the build process
        :type config: Dictionary
        :returns: True if update was successful and False if update fails
        :rtype: Boolean
    """
    contents = None
    result = False
    with open(os.path.join(config["CONF_PATH"], "target.txt"), 'r') as target:
        contents = target.readlines()
        options_list = ['ACTIVE_PLATFORM', 'TARGET',
                        'TARGET_ARCH', 'TOOL_CHAIN_TAG', 'BUILD_RULE_CONF']
        modified = []

        # remove these options from the config file
        for line in contents:
            if line.replace(" ", "")[0] != '#' and\
             any(opt in line for opt in options_list):
                continue
            modified.append(line)

        # replace with config options provided
        string = "{} = {}\n".format("ACTIVE_PLATFORM",
                                    os.path.join(
                                        config['WORKSPACE_PLATFORM'],
                                        config['PLATFORM_BOARD_PACKAGE'],
                                        config['BOARD'],
                                        config['PROJECT_DSC']))
        modified.append(string)

        string = "{} = {}\n".format("TARGET", config['TARGET'])
        modified.append(string)

        string = "TARGET_ARCH = IA32 X64\n"
        modified.append(string)

        string = "{} = {}\n".format("TOOL_CHAIN_TAG", config['TOOL_CHAIN_TAG'])
        modified.append(string)

        string = "{} = {}\n".format("BUILD_RULE_CONF",
                                    os.path.join("Conf", "build_rule.txt"))
        modified.append(string)

    if modified is not None:
        with open(os.path.join(config["WORKSPACE"],
                               "Conf", "target.txt"), 'w') as target:
            for line in modified:
                target.write(line)
            result = True

    return result


def get_config():
    """Reads the default projects config file

        :returns: The config defined in the the Build.cfg file
        :rtype: Dictionary
    """
    path = 'build.cfg'
    if not os.path.isfile(path):
        path = os.path.dirname(__file__)
        path = os.path.join(path, 'build.cfg')
        if not os.path.isfile(path):
            raise IOError("Config file {} not found".format())
    config_file = configparser.RawConfigParser()
    config_file.optionxform = str
    config_file.read(path)
    config_dictionary = {}
    for section in config_file.sections():
        dictionary = dict(config_file.items(section))
        config_dictionary[section] = dictionary
    return config_dictionary


def get_platform_config(platform_name, config_data):
    """ Reads the platform specific config file

        param platform_name: The name of the platform to be built
        :type platform_name: String
        param configData: The environment variables to be
            used in the build process
        :type configData: Dictionary
        :returns: The config defined in the the Build.cfg file
        :rtype: Dictionary
    """
    config = {}

    platform_data = config_data.get("PLATFORMS")
    path = platform_data.get(platform_name)
    if not os.path.isfile(path):
        path = os.path.dirname(__file__)
        path = os.path.join(path, platform_data.get(platform_name))
        if not os.path.isfile(path):
            raise IOError("Config file {} not found".format())
    config_file = configparser.RawConfigParser()
    config_file.optionxform = str
    config_file.read(path)
    for section in config_file.sections():
        config[section] = dict(config_file.items(section))

    return config


def get_cmd_config_arguments(arguments):
    """Get commandline config arguments

    param arguments: The environment variables to be used in the build process
    :type arguments: argparse
    :returns: The config dictionary built from the commandline arguments
    :rtype: Dictionary
    """
    result = {}
    if arguments.capsule is True:
        result["CAPSULE_BUILD"] = "1"

    if arguments.performance is True:
        result["PERFORMANCE_BUILD"] = "TRUE"

    if arguments.verbose is not None and arguments.verbose > 0:
        result["VERBOSE"] = "TRUE"

    if arguments.verbose is not None and arguments.verbose > 1:
        result["VERY_VERBOSE"] = "TRUE"

    if arguments.fsp is True:
        result["FSP_WRAPPER_BUILD"] = "TRUE"

    if arguments.fspapi is True:
        result["API_MODE_FSP_WRAPPER_BUILD"] = "TRUE"

    if not arguments.UseHashCache:
        result['BINARY_CACHE_CMD_LINE'] = ''
    elif arguments.BinCacheDest:
        result['HASH'] = '--hash'
        result['BINARY_CACHE_CMD_LINE'] = '--binary-destination=%s' % arguments.BinCacheDest
    elif arguments.BinCacheSource:
        result['HASH'] = '--hash'
        result['BINARY_CACHE_CMD_LINE'] = '--binary-source=%s' % arguments.BinCacheSource
    else:
        result['BINARY_CACHE_CMD_LINE'] = ''

    return result


def get_cmd_arguments(build_config):
    """ Get commandline inputs from user

        param config_data: The environment variables to be
            used in the build process
        :type config_data: Dictionary
        :returns: The commandline arguments input by the user
        :rtype: argparse object
    """

    class PrintPlatforms(argparse.Action):
        """ this is an argparse action that lists the available platforms
        """
        def __call__(self, parser, namespace, values, option_string=None):
            print("Platforms:")
            for key in build_config.get("PLATFORMS"):
                print("    " + key)
            setattr(namespace, self.dest, values)
            sys.exit(0)

    # get the build commands
    parser = argparse.ArgumentParser(description="Build Help")
    parser.add_argument('--platform', '-p', dest="platform",
                        help='the platform to build',
                        choices=build_config.get("PLATFORMS"),
                        required=('-l' not in sys.argv and
                                  '--cleanall' not in sys.argv))

    parser.add_argument('--toolchain', '-t', dest="toolchain",
                        help="using the Tool Chain Tagname to build \
                            the platform,overriding \
                            target.txt's TOOL_CHAIN_TAG definition")

    parser.add_argument("--DEBUG", '-d', help="debug flag",
                        action='store_const', dest="target",
                        const="DEBUG", default="DEBUG")

    parser.add_argument("--RELEASE", '-r', help="release flag",
                        action='store_const',
                        dest="target", const="RELEASE")

    parser.add_argument("--TEST_RELEASE", '-tr', help="test Release flag",
                        action='store_const',
                        dest="target", const="TEST_RELEASE")

    parser.add_argument("--RELEASE_PDB", '-rp', help="release flag",
                        action='store_const', dest="target",
                        const="RELEASE_PDB")

    parser.add_argument('--list', '-l', action=PrintPlatforms,
                        help='lists available platforms', nargs=0)

    parser.add_argument('--skiptools', '-s', dest='skip_tools',
                        help='skips rebuilding base tools', action='store_true')

    parser.add_argument('--cleanall', dest='clean_all',
                        help='cleans all', action='store_true')

    parser.add_argument('--clean', dest='clean',
                        help='cleans specific platform', action='store_true')

    parser.add_argument('--verbose', '-v', dest='verbose',
                        help='Verbose build log output, specify -vv for very verbose.', action='count')

    parser.add_argument("--capsule", help="capsule build enabled",
                        action='store_true', dest="capsule")

    parser.add_argument("--silent", help="silent build enabled",
                        action='store_true', dest="silent")

    parser.add_argument("--performance", help="performance build enabled",
                        action='store_true', dest="performance")

    parser.add_argument("--fsp", help="fsp wrapper build enabled",
                        action='store_true', dest="fsp")

    parser.add_argument("--fspapi", help="API mode fsp wrapper build enabled",
                        action='store_true', dest="fspapi")

    parser.add_argument("--hash", action="store_true", dest="UseHashCache", default=False,
                        help="Enable hash-based caching during build process.")

    parser.add_argument("--binary-destination", help="Generate a cache of binary \
                            files in the specified directory.",
                        action='store', dest="BinCacheDest")

    parser.add_argument("--binary-source", help="Consume a cache of binary files \
                                from the specified directory.",
                        action='store', dest="BinCacheSource")

    return parser.parse_args()


def keyboard_interruption(int_signal, int_frame):
    """ Catches a keyboard interruption handler

        param int_signal: The signal this handler is called with
        :type int_signal: Signal
        param int_frame: The signal this handler is called with
        :type int_frame: frame
        :rtype: nothing
    """
    print("Signal #: {} Frame: {}".format(int_signal, int_frame))
    print("Quiting...")
    sys.exit(0)


def main():
    """ The main function of this module
        :rtype: nothing
    """
    # to quit the build
    signal.signal(signal.SIGINT, keyboard_interruption)

    # get general build configurations
    build_config = get_config()

    # get commandline parameters
    arguments = get_cmd_arguments(build_config)

    if arguments.clean_all:
        clean(build_config.get("DEFAULT_CONFIG"))

    # get platform specific config
    platform_config = get_platform_config(arguments.platform, build_config)

    # update general build config with platform specific config
    config = build_config.get("DEFAULT_CONFIG")
    config.update(platform_config.get("CONFIG"))

    # if user selected clean
    if arguments.clean:
        clean(config, board=True)

    # Override config with cmd arguments
    cmd_config_args = get_cmd_config_arguments(arguments)
    config.update(cmd_config_args)

    # get pre_build configurations
    config = pre_build(config,
                       build_type=arguments.target,
                       toolchain=arguments.toolchain,
                       silent=arguments.silent,
                       skip_tools=arguments.skip_tools)

    # build selected platform
    config = build(config)

    # post build
    post_build(config)


if __name__ == "__main__":
    try:
        EXIT_CODE = 0
        main()
    except Exception as error:
        EXIT_CODE = 1
        traceback.print_exc()
    sys.exit(EXIT_CODE)