/edk2/BaseTools/Source/Python/Common/TargetTxtClassObject.py

## @file

# This file is used to define each component of Target.txt file

#

# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>

# This program and the accompanying materials

# are licensed and made available under the terms and conditions of the BSD License

# which accompanies this distribution.  The full text of the license may be found at

# http://opensource.org/licenses/bsd-license.php

#

# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

#



##

# Import Modules

#

import Common.LongFilePathOs as os

import EdkLogger

import DataType

from BuildToolError import *

import GlobalData

from Common.LongFilePathSupport import OpenLongFilePath as open



gDefaultTargetTxtFile = "target.txt"



## TargetTxtClassObject

#

# This class defined content used in file target.txt

#

# @param object:             Inherited from object class

# @param Filename:           Input value for full path of target.txt

#

# @var TargetTxtDictionary:  To store keys and values defined in target.txt

#

class TargetTxtClassObject(object):

    def __init__(self, Filename = None):

        self.TargetTxtDictionary = {

            DataType.TAB_TAT_DEFINES_ACTIVE_PLATFORM                            : '',

            DataType.TAB_TAT_DEFINES_ACTIVE_MODULE                              : '',

            DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF                            : '',

            DataType.TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER               : '',

            DataType.TAB_TAT_DEFINES_TARGET                                     : [],

            DataType.TAB_TAT_DEFINES_TOOL_CHAIN_TAG                             : [],

            DataType.TAB_TAT_DEFINES_TARGET_ARCH                                : [],

            DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF                            : '',

        }

        self.ConfDirectoryPath = ""

        if Filename != None:

            self.LoadTargetTxtFile(Filename)



    ## LoadTargetTxtFile

    #

    # Load target.txt file and parse it, return a set structure to store keys and values

    #

    # @param Filename:  Input value for full path of target.txt

    #

    # @retval set() A set structure to store keys and values

    # @retval 1     Error happenes in parsing

    #

    def LoadTargetTxtFile(self, Filename):

        if os.path.exists(Filename) and os.path.isfile(Filename):

             return self.ConvertTextFileToDict(Filename, '#', '=')

        else:

            EdkLogger.error("Target.txt Parser", FILE_NOT_FOUND, ExtraData=Filename)

            return 1



    ## ConvertTextFileToDict

    #

    # Convert a text file to a dictionary of (name:value) pairs.

    # The data is saved to self.TargetTxtDictionary

    #

    # @param FileName:             Text filename

    # @param CommentCharacter:     Comment char, be used to ignore comment content

    # @param KeySplitCharacter:    Key split char, between key name and key value. Key1 = Value1, '=' is the key split char

    #

    # @retval 0 Convert successfully

    # @retval 1 Open file failed

    #

    def ConvertTextFileToDict(self, FileName, CommentCharacter, KeySplitCharacter):

        F = None

        try:

            F = open(FileName, 'r')

            self.ConfDirectoryPath = os.path.dirname(FileName)

        except:

            EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=FileName)

            if F != None:

                F.close()



        for Line in F:

            Line = Line.strip()

            if Line.startswith(CommentCharacter) or Line == '':

                continue



            LineList = Line.split(KeySplitCharacter, 1)

            Key = LineList[0].strip()

            if len(LineList) == 2:

                Value = LineList[1].strip()

            else:

                Value = ""



            if Key in [DataType.TAB_TAT_DEFINES_ACTIVE_PLATFORM, DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF, \

                       DataType.TAB_TAT_DEFINES_ACTIVE_MODULE, DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF]:

                self.TargetTxtDictionary[Key] = Value.replace('\\', '/')

                if Key == DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF and self.TargetTxtDictionary[Key]:

                    if self.TargetTxtDictionary[Key].startswith("Conf/"):

                        Tools_Def = os.path.join(self.ConfDirectoryPath, self.TargetTxtDictionary[Key].strip())

                        if not os.path.exists(Tools_Def) or not os.path.isfile(Tools_Def):

                            # If Conf/Conf does not exist, try just the Conf/ directory

                            Tools_Def = os.path.join(self.ConfDirectoryPath, self.TargetTxtDictionary[Key].replace("Conf/", "", 1).strip())

                    else:

                        # The File pointed to by TOOL_CHAIN_CONF is not in a Conf/ directory

                        Tools_Def = os.path.join(self.ConfDirectoryPath, self.TargetTxtDictionary[Key].strip())

                    self.TargetTxtDictionary[Key] = Tools_Def

                if Key == DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF and self.TargetTxtDictionary[Key]:

                    if self.TargetTxtDictionary[Key].startswith("Conf/"):

                        Build_Rule = os.path.join(self.ConfDirectoryPath, self.TargetTxtDictionary[Key].strip())

                        if not os.path.exists(Build_Rule) or not os.path.isfile(Build_Rule):

                            # If Conf/Conf does not exist, try just the Conf/ directory

                            Build_Rule = os.path.join(self.ConfDirectoryPath, self.TargetTxtDictionary[Key].replace("Conf/", "", 1).strip())

                    else:

                        # The File pointed to by BUILD_RULE_CONF is not in a Conf/ directory

                        Build_Rule = os.path.join(self.ConfDirectoryPath, self.TargetTxtDictionary[Key].strip())

                    self.TargetTxtDictionary[Key] = Build_Rule

            elif Key in [DataType.TAB_TAT_DEFINES_TARGET, DataType.TAB_TAT_DEFINES_TARGET_ARCH, \

                         DataType.TAB_TAT_DEFINES_TOOL_CHAIN_TAG]:

                self.TargetTxtDictionary[Key] = Value.split()

            elif Key == DataType.TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER:

                try:

                    V = int(Value, 0)

                except:

                    EdkLogger.error("build", FORMAT_INVALID, "Invalid number of [%s]: %s." % (Key, Value),

                                    File=FileName)

                self.TargetTxtDictionary[Key] = Value

            #elif Key not in GlobalData.gGlobalDefines:

            #    GlobalData.gGlobalDefines[Key] = Value



        F.close()

        return 0



    ## Print the dictionary

    #

    # Print all items of dictionary one by one

    #

    # @param Dict:  The dictionary to be printed

    #

    def printDict(Dict):

        if Dict != None:

            KeyList = Dict.keys()

            for Key in KeyList:

                if Dict[Key] != '':

                    print Key + ' = ' + str(Dict[Key])



    ## Print the dictionary

    #

    # Print the items of dictionary which matched with input key

    #

    # @param list:  The dictionary to be printed

    # @param key:   The key of the item to be printed

    #

    def printList(Key, List):

        if type(List) == type([]):

            if len(List) > 0:

                if Key.find(TAB_SPLIT) != -1:

                    print "\n" + Key

                    for Item in List:

                        print Item

## TargetTxtDict

#

# Load target.txt in input Conf dir

#

# @param ConfDir:  Conf dir

#

# @retval Target An instance of TargetTxtClassObject() with loaded target.txt

#

def TargetTxtDict(ConfDir):

    Target = TargetTxtClassObject()

    Target.LoadTargetTxtFile(os.path.normpath(os.path.join(ConfDir, gDefaultTargetTxtFile)))

    return Target



##

#

# This acts like the main() function for the script, unless it is 'import'ed into another

# script.

#

if __name__ == '__main__':

    pass

    Target = TargetTxtDict(os.getenv("WORKSPACE"))

    print Target.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER]

    print Target.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TARGET]

    print Target.TargetTxtDictionary