[mirror_edk2.git] / BaseTools / Source / Python / UPT / Library / Misc.py

## @file\r
# Common routines used by all tools\r
#\r
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available\r
# under the terms and conditions of the BSD License which accompanies this\r
# distribution. The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
'''\r
Misc\r
'''\r
\r
##\r
# Import Modules\r
#\r
import os.path\r
from os import access\r
from os import F_OK\r
from os import makedirs\r
from os import getcwd\r
from os import chdir\r
from os import listdir\r
from os import remove\r
from os import rmdir\r
from os import linesep\r
from os import walk\r
from os import environ\r
import re\r
from collections import UserDict as IterableUserDict\r
\r
import Logger.Log as Logger\r
from Logger import StringTable as ST\r
from Logger import ToolError\r
from Library import GlobalData\r
from Library.DataType import SUP_MODULE_LIST\r
from Library.DataType import END_OF_LINE\r
from Library.DataType import TAB_SPLIT\r
from Library.DataType import TAB_LANGUAGE_EN_US\r
from Library.DataType import TAB_LANGUAGE_EN\r
from Library.DataType import TAB_LANGUAGE_EN_X\r
from Library.DataType import TAB_UNI_FILE_SUFFIXS\r
from Library.StringUtils import GetSplitValueList\r
from Library.ParserValidate import IsValidHexVersion\r
from Library.ParserValidate import IsValidPath\r
from Object.POM.CommonObject import TextObject\r
from Core.FileHook import __FileHookOpen__\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
\r
## Convert GUID string in xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx style to C\r
# structure style\r
#\r
# @param      Guid:    The GUID string\r
#\r
def GuidStringToGuidStructureString(Guid):\r
    GuidList = Guid.split('-')\r
    Result = '{'\r
    for Index in range(0, 3, 1):\r
        Result = Result + '0x' + GuidList[Index] + ', '\r
    Result = Result + '{0x' + GuidList[3][0:2] + ', 0x' + GuidList[3][2:4]\r
    for Index in range(0, 12, 2):\r
        Result = Result + ', 0x' + GuidList[4][Index:Index + 2]\r
    Result += '}}'\r
    return Result\r
\r
## Check whether GUID string is of format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\r
#\r
# @param      GuidValue:   The GUID value\r
#\r
def CheckGuidRegFormat(GuidValue):\r
    ## Regular expression used to find out register format of GUID\r
    #\r
    RegFormatGuidPattern = re.compile("^\s*([0-9a-fA-F]){8}-"\r
                                       "([0-9a-fA-F]){4}-"\r
                                       "([0-9a-fA-F]){4}-"\r
                                       "([0-9a-fA-F]){4}-"\r
                                       "([0-9a-fA-F]){12}\s*$")\r
\r
    if RegFormatGuidPattern.match(GuidValue):\r
        return True\r
    else:\r
        return False\r
\r
\r
## Convert GUID string in C structure style to\r
# xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\r
#\r
# @param      GuidValue:   The GUID value in C structure format\r
#\r
def GuidStructureStringToGuidString(GuidValue):\r
    GuidValueString = GuidValue.lower().replace("{", "").replace("}", "").\\r
    replace(" ", "").replace(";", "")\r
    GuidValueList = GuidValueString.split(",")\r
    if len(GuidValueList) != 11:\r
        return ''\r
    try:\r
        return "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (\r
                int(GuidValueList[0], 16),\r
                int(GuidValueList[1], 16),\r
                int(GuidValueList[2], 16),\r
                int(GuidValueList[3], 16),\r
                int(GuidValueList[4], 16),\r
                int(GuidValueList[5], 16),\r
                int(GuidValueList[6], 16),\r
                int(GuidValueList[7], 16),\r
                int(GuidValueList[8], 16),\r
                int(GuidValueList[9], 16),\r
                int(GuidValueList[10], 16)\r
                )\r
    except BaseException:\r
        return ''\r
\r
## Create directories\r
#\r
# @param      Directory:   The directory name\r
#\r
def CreateDirectory(Directory):\r
    if Directory is None or Directory.strip() == "":\r
        return True\r
    try:\r
        if not access(Directory, F_OK):\r
            makedirs(Directory)\r
    except BaseException:\r
        return False\r
    return True\r
\r
## Remove directories, including files and sub-directories in it\r
#\r
# @param      Directory:   The directory name\r
#\r
def RemoveDirectory(Directory, Recursively=False):\r
    if Directory is None or Directory.strip() == "" or not \\r
    os.path.exists(Directory):\r
        return\r
    if Recursively:\r
        CurrentDirectory = getcwd()\r
        chdir(Directory)\r
        for File in listdir("."):\r
            if os.path.isdir(File):\r
                RemoveDirectory(File, Recursively)\r
            else:\r
                remove(File)\r
        chdir(CurrentDirectory)\r
    rmdir(Directory)\r
\r
## Store content in file\r
#\r
# This method is used to save file only when its content is changed. This is\r
# quite useful for "make" system to decide what will be re-built and what\r
# won't.\r
#\r
# @param      File:            The path of file\r
# @param      Content:         The new content of the file\r
# @param      IsBinaryFile:    The flag indicating if the file is binary file\r
#                              or not\r
#\r
def SaveFileOnChange(File, Content, IsBinaryFile=True):\r
    if os.path.exists(File):\r
        try:\r
            if isinstance(Content, bytes):\r
                if Content == __FileHookOpen__(File, "rb").read():\r
                    return False\r
            else:\r
                if Content == __FileHookOpen__(File, "r").read():\r
                    return False\r
        except BaseException:\r
            Logger.Error(None, ToolError.FILE_OPEN_FAILURE, ExtraData=File)\r
\r
    CreateDirectory(os.path.dirname(File))\r
    try:\r
        if isinstance(Content, bytes):\r
            FileFd = __FileHookOpen__(File, "wb")\r
        else:\r
            FileFd = __FileHookOpen__(File, "w")\r
        FileFd.write(Content)\r
        FileFd.close()\r
    except BaseException:\r
        Logger.Error(None, ToolError.FILE_CREATE_FAILURE, ExtraData=File)\r
\r
    return True\r
\r
## Get all files of a directory\r
#\r
# @param Root:       Root dir\r
# @param SkipList :  The files need be skipped\r
#\r
def GetFiles(Root, SkipList=None, FullPath=True):\r
    OriPath = os.path.normpath(Root)\r
    FileList = []\r
    for Root, Dirs, Files in walk(Root):\r
        if SkipList:\r
            for Item in SkipList:\r
                if Item in Dirs:\r
                    Dirs.remove(Item)\r
                if Item in Files:\r
                    Files.remove(Item)\r
        for Dir in Dirs:\r
            if Dir.startswith('.'):\r
                Dirs.remove(Dir)\r
\r
        for File in Files:\r
            if File.startswith('.'):\r
                continue\r
            File = os.path.normpath(os.path.join(Root, File))\r
            if not FullPath:\r
                File = File[len(OriPath) + 1:]\r
            FileList.append(File)\r
\r
    return FileList\r
\r
## Get all non-metadata files of a directory\r
#\r
# @param Root:       Root Dir\r
# @param SkipList :  List of path need be skipped\r
# @param FullPath:  True if the returned file should be full path\r
# @param PrefixPath: the path that need to be added to the files found\r
# @return: the list of files found\r
#\r
def GetNonMetaDataFiles(Root, SkipList, FullPath, PrefixPath):\r
    FileList = GetFiles(Root, SkipList, FullPath)\r
    NewFileList = []\r
    for File in FileList:\r
        ExtName = os.path.splitext(File)[1]\r
        #\r
        # skip '.dec', '.inf', '.dsc', '.fdf' files\r
        #\r
        if ExtName.lower() not in ['.dec', '.inf', '.dsc', '.fdf']:\r
            NewFileList.append(os.path.normpath(os.path.join(PrefixPath, File)))\r
\r
    return NewFileList\r
\r
## Check if given file exists or not\r
#\r
# @param      File:    File name or path to be checked\r
# @param      Dir:     The directory the file is relative to\r
#\r
def ValidFile(File, Ext=None):\r
    File = File.replace('\\', '/')\r
    if Ext is not None:\r
        FileExt = os.path.splitext(File)[1]\r
        if FileExt.lower() != Ext.lower():\r
            return False\r
    if not os.path.exists(File):\r
        return False\r
    return True\r
\r
## RealPath\r
#\r
# @param      File:    File name or path to be checked\r
# @param      Dir:     The directory the file is relative to\r
# @param      OverrideDir:     The override directory\r
#\r
def RealPath(File, Dir='', OverrideDir=''):\r
    NewFile = os.path.normpath(os.path.join(Dir, File))\r
    NewFile = GlobalData.gALL_FILES[NewFile]\r
    if not NewFile and OverrideDir:\r
        NewFile = os.path.normpath(os.path.join(OverrideDir, File))\r
        NewFile = GlobalData.gALL_FILES[NewFile]\r
    return NewFile\r
\r
## RealPath2\r
#\r
# @param      File:    File name or path to be checked\r
# @param      Dir:     The directory the file is relative to\r
# @param      OverrideDir:     The override directory\r
#\r
def RealPath2(File, Dir='', OverrideDir=''):\r
    if OverrideDir:\r
        NewFile = GlobalData.gALL_FILES[os.path.normpath(os.path.join\\r
                                                        (OverrideDir, File))]\r
        if NewFile:\r
            if OverrideDir[-1] == os.path.sep:\r
                return NewFile[len(OverrideDir):], NewFile[0:len(OverrideDir)]\r
            else:\r
                return NewFile[len(OverrideDir) + 1:], \\r
            NewFile[0:len(OverrideDir)]\r
\r
    NewFile = GlobalData.gALL_FILES[os.path.normpath(os.path.join(Dir, File))]\r
    if NewFile:\r
        if Dir:\r
            if Dir[-1] == os.path.sep:\r
                return NewFile[len(Dir):], NewFile[0:len(Dir)]\r
            else:\r
                return NewFile[len(Dir) + 1:], NewFile[0:len(Dir)]\r
        else:\r
            return NewFile, ''\r
\r
    return None, None\r
\r
## A dict which can access its keys and/or values orderly\r
#\r
#  The class implements a new kind of dict which its keys or values can be\r
#  accessed in the order they are added into the dict. It guarantees the order\r
#  by making use of an internal list to keep a copy of keys.\r
#\r
class Sdict(IterableUserDict):\r
    ## Constructor\r
    #\r
    def __init__(self):\r
        IterableUserDict.__init__(self)\r
        self._key_list = []\r
\r
    ## [] operator\r
    #\r
    def __setitem__(self, Key, Value):\r
        if Key not in self._key_list:\r
            self._key_list.append(Key)\r
        IterableUserDict.__setitem__(self, Key, Value)\r
\r
    ## del operator\r
    #\r
    def __delitem__(self, Key):\r
        self._key_list.remove(Key)\r
        IterableUserDict.__delitem__(self, Key)\r
\r
    ## used in "for k in dict" loop to ensure the correct order\r
    #\r
    def __iter__(self):\r
        return self.iterkeys()\r
\r
    ## len() support\r
    #\r
    def __len__(self):\r
        return len(self._key_list)\r
\r
    ## "in" test support\r
    #\r
    def __contains__(self, Key):\r
        return Key in self._key_list\r
\r
    ## indexof support\r
    #\r
    def index(self, Key):\r
        return self._key_list.index(Key)\r
\r
    ## insert support\r
    #\r
    def insert(self, Key, Newkey, Newvalue, Order):\r
        Index = self._key_list.index(Key)\r
        if Order == 'BEFORE':\r
            self._key_list.insert(Index, Newkey)\r
            IterableUserDict.__setitem__(self, Newkey, Newvalue)\r
        elif Order == 'AFTER':\r
            self._key_list.insert(Index + 1, Newkey)\r
            IterableUserDict.__setitem__(self, Newkey, Newvalue)\r
\r
    ## append support\r
    #\r
    def append(self, Sdict2):\r
        for Key in Sdict2:\r
            if Key not in self._key_list:\r
                self._key_list.append(Key)\r
            IterableUserDict.__setitem__(self, Key, Sdict2[Key])\r
    ## hash key\r
    #\r
    def has_key(self, Key):\r
        return Key in self._key_list\r
\r
    ## Empty the dict\r
    #\r
    def clear(self):\r
        self._key_list = []\r
        IterableUserDict.clear(self)\r
\r
    ## Return a copy of keys\r
    #\r
    def keys(self):\r
        Keys = []\r
        for Key in self._key_list:\r
            Keys.append(Key)\r
        return Keys\r
\r
    ## Return a copy of values\r
    #\r
    def values(self):\r
        Values = []\r
        for Key in self._key_list:\r
            Values.append(self[Key])\r
        return Values\r
\r
    ## Return a copy of (key, value) list\r
    #\r
    def items(self):\r
        Items = []\r
        for Key in self._key_list:\r
            Items.append((Key, self[Key]))\r
        return Items\r
\r
    ## Iteration support\r
    #\r
    def iteritems(self):\r
        return iter(self.items())\r
\r
    ## Keys interation support\r
    #\r
    def iterkeys(self):\r
        return iter(self.keys())\r
\r
    ## Values interation support\r
    #\r
    def itervalues(self):\r
        return iter(self.values())\r
\r
    ## Return value related to a key, and remove the (key, value) from the dict\r
    #\r
    def pop(self, Key, *Dv):\r
        Value = None\r
        if Key in self._key_list:\r
            Value = self[Key]\r
            self.__delitem__(Key)\r
        elif len(Dv) != 0 :\r
            Value = Dv[0]\r
        return Value\r
\r
    ## Return (key, value) pair, and remove the (key, value) from the dict\r
    #\r
    def popitem(self):\r
        Key = self._key_list[-1]\r
        Value = self[Key]\r
        self.__delitem__(Key)\r
        return Key, Value\r
    ## update method\r
    #\r
    def update(self, Dict=None, **Kwargs):\r
        if Dict is not None:\r
            for Key1, Val1 in Dict.items():\r
                self[Key1] = Val1\r
        if len(Kwargs):\r
            for Key1, Val1 in Kwargs.items():\r
                self[Key1] = Val1\r
\r
## CommonPath\r
#\r
# @param PathList: PathList\r
#\r
def CommonPath(PathList):\r
    Path1 = min(PathList).split(os.path.sep)\r
    Path2 = max(PathList).split(os.path.sep)\r
    for Index in range(min(len(Path1), len(Path2))):\r
        if Path1[Index] != Path2[Index]:\r
            return os.path.sep.join(Path1[:Index])\r
    return os.path.sep.join(Path1)\r
\r
## PathClass\r
#\r
class PathClass(object):\r
    def __init__(self, File='', Root='', AlterRoot='', Type='', IsBinary=False,\r
                 Arch='COMMON', ToolChainFamily='', Target='', TagName='', \\r
                 ToolCode=''):\r
        self.Arch = Arch\r
        self.File = str(File)\r
        if os.path.isabs(self.File):\r
            self.Root = ''\r
            self.AlterRoot = ''\r
        else:\r
            self.Root = str(Root)\r
            self.AlterRoot = str(AlterRoot)\r
\r
        #\r
        # Remove any '.' and '..' in path\r
        #\r
        if self.Root:\r
            self.Path = os.path.normpath(os.path.join(self.Root, self.File))\r
            self.Root = os.path.normpath(CommonPath([self.Root, self.Path]))\r
            #\r
            # eliminate the side-effect of 'C:'\r
            #\r
            if self.Root[-1] == ':':\r
                self.Root += os.path.sep\r
            #\r
            # file path should not start with path separator\r
            #\r
            if self.Root[-1] == os.path.sep:\r
                self.File = self.Path[len(self.Root):]\r
            else:\r
                self.File = self.Path[len(self.Root) + 1:]\r
        else:\r
            self.Path = os.path.normpath(self.File)\r
\r
        self.SubDir, self.Name = os.path.split(self.File)\r
        self.BaseName, self.Ext = os.path.splitext(self.Name)\r
\r
        if self.Root:\r
            if self.SubDir:\r
                self.Dir = os.path.join(self.Root, self.SubDir)\r
            else:\r
                self.Dir = self.Root\r
        else:\r
            self.Dir = self.SubDir\r
\r
        if IsBinary:\r
            self.Type = Type\r
        else:\r
            self.Type = self.Ext.lower()\r
\r
        self.IsBinary = IsBinary\r
        self.Target = Target\r
        self.TagName = TagName\r
        self.ToolCode = ToolCode\r
        self.ToolChainFamily = ToolChainFamily\r
\r
        self._Key = None\r
\r
    ## Convert the object of this class to a string\r
    #\r
    #  Convert member Path of the class to a string\r
    #\r
    def __str__(self):\r
        return self.Path\r
\r
    ## Override __eq__ function\r
    #\r
    # Check whether PathClass are the same\r
    #\r
    def __eq__(self, Other):\r
        if isinstance(Other, type(self)):\r
            return self.Path == Other.Path\r
        else:\r
            return self.Path == str(Other)\r
\r
    ## Override __hash__ function\r
    #\r
    # Use Path as key in hash table\r
    #\r
    def __hash__(self):\r
        return hash(self.Path)\r
\r
    ## _GetFileKey\r
    #\r
    def _GetFileKey(self):\r
        if self._Key is None:\r
            self._Key = self.Path.upper()\r
        return self._Key\r
    ## Validate\r
    #\r
    def Validate(self, Type='', CaseSensitive=True):\r
        if GlobalData.gCASE_INSENSITIVE:\r
            CaseSensitive = False\r
        if Type and Type.lower() != self.Type:\r
            return ToolError.FILE_TYPE_MISMATCH, '%s (expect %s but got %s)' % \\r
        (self.File, Type, self.Type)\r
\r
        RealFile, RealRoot = RealPath2(self.File, self.Root, self.AlterRoot)\r
        if not RealRoot and not RealFile:\r
            RealFile = self.File\r
            if self.AlterRoot:\r
                RealFile = os.path.join(self.AlterRoot, self.File)\r
            elif self.Root:\r
                RealFile = os.path.join(self.Root, self.File)\r
            return ToolError.FILE_NOT_FOUND, os.path.join(self.AlterRoot, RealFile)\r
\r
        ErrorCode = 0\r
        ErrorInfo = ''\r
        if RealRoot != self.Root or RealFile != self.File:\r
            if CaseSensitive and (RealFile != self.File or \\r
                                  (RealRoot != self.Root and RealRoot != \\r
                                   self.AlterRoot)):\r
                ErrorCode = ToolError.FILE_CASE_MISMATCH\r
                ErrorInfo = self.File + '\n\t' + RealFile + \\r
                 " [in file system]"\r
\r
            self.SubDir, self.Name = os.path.split(RealFile)\r
            self.BaseName, self.Ext = os.path.splitext(self.Name)\r
            if self.SubDir:\r
                self.Dir = os.path.join(RealRoot, self.SubDir)\r
            else:\r
                self.Dir = RealRoot\r
            self.File = RealFile\r
            self.Root = RealRoot\r
            self.Path = os.path.join(RealRoot, RealFile)\r
        return ErrorCode, ErrorInfo\r
\r
    Key = property(_GetFileKey)\r
\r
## Get current workspace\r
#\r
#  get WORKSPACE from environment variable if present,if not use current working directory as WORKSPACE\r
#\r
def GetWorkspace():\r
    #\r
    # check WORKSPACE\r
    #\r
    if "WORKSPACE" in environ:\r
        WorkspaceDir = os.path.normpath(environ["WORKSPACE"])\r
        if not os.path.exists(WorkspaceDir):\r
            Logger.Error("UPT",\r
                         ToolError.UPT_ENVIRON_MISSING_ERROR,\r
                         ST.ERR_WORKSPACE_NOTEXIST,\r
                         ExtraData="%s" % WorkspaceDir)\r
    else:\r
        WorkspaceDir = os.getcwd()\r
\r
    if WorkspaceDir[-1] == ':':\r
        WorkspaceDir += os.sep\r
\r
    PackagesPath = os.environ.get("PACKAGES_PATH")\r
    mws.setWs(WorkspaceDir, PackagesPath)\r
\r
    return WorkspaceDir, mws.PACKAGES_PATH\r
\r
## Get relative path\r
#\r
#  use full path and workspace to get relative path\r
#  the destination of this function is mainly to resolve the root path issue(like c: or c:\)\r
#\r
#  @param Fullpath: a string of fullpath\r
#  @param Workspace: a string of workspace\r
#\r
def GetRelativePath(Fullpath, Workspace):\r
\r
    RelativePath = ''\r
    if Workspace.endswith(os.sep):\r
        RelativePath = Fullpath[Fullpath.upper().find(Workspace.upper())+len(Workspace):]\r
    else:\r
        RelativePath = Fullpath[Fullpath.upper().find(Workspace.upper())+len(Workspace)+1:]\r
\r
    return RelativePath\r
\r
## Check whether all module types are in list\r
#\r
# check whether all module types (SUP_MODULE_LIST) are in list\r
#\r
# @param ModuleList:  a list of ModuleType\r
#\r
def IsAllModuleList(ModuleList):\r
    NewModuleList = [Module.upper() for Module in ModuleList]\r
    for Module in SUP_MODULE_LIST:\r
        if Module not in NewModuleList:\r
            return False\r
    else:\r
        return True\r
\r
## Dictionary that use comment(GenericComment, TailComment) as value,\r
# if a new comment which key already in the dic is inserted, then the\r
# comment will be merged.\r
# Key is (Statement, SupArch), when TailComment is added, it will ident\r
# according to Statement\r
#\r
class MergeCommentDict(dict):\r
    ## []= operator\r
    #\r
    def __setitem__(self, Key, CommentVal):\r
        GenericComment, TailComment = CommentVal\r
        if Key in self:\r
            OrigVal1, OrigVal2 = dict.__getitem__(self, Key)\r
            Statement = Key[0]\r
            dict.__setitem__(self, Key, (OrigVal1 + GenericComment, OrigVal2 \\r
                                         + len(Statement) * ' ' + TailComment))\r
        else:\r
            dict.__setitem__(self, Key, (GenericComment, TailComment))\r
\r
    ## =[] operator\r
    #\r
    def __getitem__(self, Key):\r
        return dict.__getitem__(self, Key)\r
\r
\r
## GenDummyHelpTextObj\r
#\r
# @retval HelpTxt:   Generated dummy help text object\r
#\r
def GenDummyHelpTextObj():\r
    HelpTxt = TextObject()\r
    HelpTxt.SetLang(TAB_LANGUAGE_EN_US)\r
    HelpTxt.SetString(' ')\r
    return HelpTxt\r
\r
## ConvertVersionToDecimal, the minor version should be within 0 - 99\r
# <HexVersion>          ::=  "0x" <Major> <Minor>\r
# <Major>               ::=  (a-fA-F0-9){4}\r
# <Minor>               ::=  (a-fA-F0-9){4}\r
# <DecVersion>          ::=  (0-65535) ["." (0-99)]\r
#\r
# @param StringIn:  The string contains version defined in INF file.\r
#                   It can be Decimal or Hex\r
#\r
def ConvertVersionToDecimal(StringIn):\r
    if IsValidHexVersion(StringIn):\r
        Value = int(StringIn, 16)\r
        Major = Value >> 16\r
        Minor = Value & 0xFFFF\r
        MinorStr = str(Minor)\r
        if len(MinorStr) == 1:\r
            MinorStr = '0' + MinorStr\r
        return str(Major) + '.' + MinorStr\r
    else:\r
        if StringIn.find(TAB_SPLIT) != -1:\r
            return StringIn\r
        elif StringIn:\r
            return StringIn + '.0'\r
        else:\r
            #\r
            # when StringIn is '', return it directly\r
            #\r
            return StringIn\r
\r
## GetHelpStringByRemoveHashKey\r
#\r
# Remove hash key at the header of string and return the remain.\r
#\r
# @param String:  The string need to be processed.\r
#\r
def GetHelpStringByRemoveHashKey(String):\r
    ReturnString = ''\r
    PattenRemoveHashKey = re.compile(r"^[#+\s]+", re.DOTALL)\r
    String = String.strip()\r
    if String == '':\r
        return String\r
\r
    LineList = GetSplitValueList(String, END_OF_LINE)\r
    for Line in LineList:\r
        ValueList = PattenRemoveHashKey.split(Line)\r
        if len(ValueList) == 1:\r
            ReturnString += ValueList[0] + END_OF_LINE\r
        else:\r
            ReturnString += ValueList[1] + END_OF_LINE\r
\r
    if ReturnString.endswith('\n') and not ReturnString.endswith('\n\n') and ReturnString != '\n':\r
        ReturnString = ReturnString[:-1]\r
\r
    return ReturnString\r
\r
## ConvPathFromAbsToRel\r
#\r
# Get relative file path from absolute path.\r
#\r
# @param Path:  The string contain file absolute path.\r
# @param Root:  The string contain the parent path of Path in.\r
#\r
#\r
def ConvPathFromAbsToRel(Path, Root):\r
    Path = os.path.normpath(Path)\r
    Root = os.path.normpath(Root)\r
    FullPath = os.path.normpath(os.path.join(Root, Path))\r
\r
    #\r
    # If Path is absolute path.\r
    # It should be in Root.\r
    #\r
    if os.path.isabs(Path):\r
        return FullPath[FullPath.find(Root) + len(Root) + 1:]\r
\r
    else:\r
        return Path\r
\r
## ConvertPath\r
#\r
# Convert special characters to '_', '\' to '/'\r
# return converted path: Test!1.inf -> Test_1.inf\r
#\r
# @param Path: Path to be converted\r
#\r
def ConvertPath(Path):\r
    RetPath = ''\r
    for Char in Path.strip():\r
        if Char.isalnum() or Char in '.-_/':\r
            RetPath = RetPath + Char\r
        elif Char == '\\':\r
            RetPath = RetPath + '/'\r
        else:\r
            RetPath = RetPath + '_'\r
    return RetPath\r
\r
## ConvertSpec\r
#\r
# during install, convert the Spec string extract from UPD into INF allowable definition,\r
# the difference is period is allowed in the former (not the first letter) but not in the latter.\r
# return converted Spec string\r
#\r
# @param SpecStr: SpecStr to be converted\r
#\r
def ConvertSpec(SpecStr):\r
    RetStr = ''\r
    for Char in SpecStr:\r
        if Char.isalnum() or Char == '_':\r
            RetStr = RetStr + Char\r
        else:\r
            RetStr = RetStr + '_'\r
\r
    return RetStr\r
\r
\r
## IsEqualList\r
#\r
# Judge two lists are identical(contain same item).\r
# The rule is elements in List A are in List B and elements in List B are in List A.\r
#\r
# @param ListA, ListB  Lists need to be judged.\r
#\r
# @return True  ListA and ListB are identical\r
# @return False ListA and ListB are different with each other\r
#\r
def IsEqualList(ListA, ListB):\r
    if ListA == ListB:\r
        return True\r
\r
    for ItemA in ListA:\r
        if not ItemA in ListB:\r
            return False\r
\r
    for ItemB in ListB:\r
        if not ItemB in ListA:\r
            return False\r
\r
    return True\r
\r
## ConvertArchList\r
#\r
# Convert item in ArchList if the start character is lower case.\r
# In UDP spec, Arch is only allowed as: [A-Z]([a-zA-Z0-9])*\r
#\r
# @param ArchList The ArchList need to be converted.\r
#\r
# @return NewList  The ArchList been converted.\r
#\r
def ConvertArchList(ArchList):\r
    NewArchList = []\r
    if not ArchList:\r
        return NewArchList\r
\r
    if isinstance(ArchList, list):\r
        for Arch in ArchList:\r
            Arch = Arch.upper()\r
            NewArchList.append(Arch)\r
    elif isinstance(ArchList, str):\r
        ArchList = ArchList.upper()\r
        NewArchList.append(ArchList)\r
\r
    return NewArchList\r
\r
## ProcessLineExtender\r
#\r
# Process the LineExtender of Line in LineList.\r
# If one line ends with a line extender, then it will be combined together with next line.\r
#\r
# @param LineList The LineList need to be processed.\r
#\r
# @return NewList  The ArchList been processed.\r
#\r
def ProcessLineExtender(LineList):\r
    NewList = []\r
    Count = 0\r
    while Count < len(LineList):\r
        if LineList[Count].strip().endswith("\\") and Count + 1 < len(LineList):\r
            NewList.append(LineList[Count].strip()[:-2] + LineList[Count + 1])\r
            Count = Count + 1\r
        else:\r
            NewList.append(LineList[Count])\r
\r
        Count = Count + 1\r
\r
    return NewList\r
\r
## ProcessEdkComment\r
#\r
# Process EDK style comment in LineList: c style /* */ comment or cpp style // comment\r
#\r
#\r
# @param LineList The LineList need to be processed.\r
#\r
# @return LineList  The LineList been processed.\r
# @return FirstPos  Where Edk comment is first found, -1 if not found\r
#\r
def ProcessEdkComment(LineList):\r
    FindEdkBlockComment = False\r
    Count = 0\r
    StartPos = -1\r
    EndPos = -1\r
    FirstPos = -1\r
\r
    while(Count < len(LineList)):\r
        Line = LineList[Count].strip()\r
        if Line.startswith("/*"):\r
            #\r
            # handling c style comment\r
            #\r
            StartPos = Count\r
            while Count < len(LineList):\r
                Line = LineList[Count].strip()\r
                if Line.endswith("*/"):\r
                    if (Count == StartPos) and Line.strip() == '/*/':\r
                        Count = Count + 1\r
                        continue\r
                    EndPos = Count\r
                    FindEdkBlockComment = True\r
                    break\r
                Count = Count + 1\r
\r
            if FindEdkBlockComment:\r
                if FirstPos == -1:\r
                    FirstPos = StartPos\r
                for Index in range(StartPos, EndPos+1):\r
                    LineList[Index] = ''\r
                FindEdkBlockComment = False\r
        elif Line.find("//") != -1 and not Line.startswith("#"):\r
            #\r
            # handling cpp style comment\r
            #\r
            LineList[Count] = Line.replace("//", '#')\r
            if FirstPos == -1:\r
                FirstPos = Count\r
\r
        Count = Count + 1\r
\r
    return LineList, FirstPos\r
\r
## GetLibInstanceInfo\r
#\r
# Get the information from Library Instance INF file.\r
#\r
# @param string.  A string start with # and followed by INF file path\r
# @param WorkSpace. The WorkSpace directory used to combined with INF file path.\r
#\r
# @return GUID, Version\r
def GetLibInstanceInfo(String, WorkSpace, LineNo):\r
\r
    FileGuidString = ""\r
    VerString = ""\r
\r
    OrignalString = String\r
    String = String.strip()\r
    if not String:\r
        return None, None\r
    #\r
    # Remove "#" characters at the beginning\r
    #\r
    String = GetHelpStringByRemoveHashKey(String)\r
    String = String.strip()\r
\r
    #\r
    # Validate file name exist.\r
    #\r
    FullFileName = os.path.normpath(os.path.realpath(os.path.join(WorkSpace, String)))\r
    if not (ValidFile(FullFileName)):\r
        Logger.Error("InfParser",\r
                     ToolError.FORMAT_INVALID,\r
                     ST.ERR_FILELIST_EXIST % (String),\r
                     File=GlobalData.gINF_MODULE_NAME,\r
                     Line=LineNo,\r
                     ExtraData=OrignalString)\r
\r
    #\r
    # Validate file exist/format.\r
    #\r
    if IsValidPath(String, WorkSpace):\r
        IsValidFileFlag = True\r
    else:\r
        Logger.Error("InfParser",\r
                     ToolError.FORMAT_INVALID,\r
                     ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (String),\r
                     File=GlobalData.gINF_MODULE_NAME,\r
                     Line=LineNo,\r
                     ExtraData=OrignalString)\r
        return False\r
    if IsValidFileFlag:\r
        FileLinesList = []\r
\r
        try:\r
            FInputfile = open(FullFileName, "r")\r
            try:\r
                FileLinesList = FInputfile.readlines()\r
            except BaseException:\r
                Logger.Error("InfParser",\r
                             ToolError.FILE_READ_FAILURE,\r
                             ST.ERR_FILE_OPEN_FAILURE,\r
                             File=FullFileName)\r
            finally:\r
                FInputfile.close()\r
        except BaseException:\r
            Logger.Error("InfParser",\r
                         ToolError.FILE_READ_FAILURE,\r
                         ST.ERR_FILE_OPEN_FAILURE,\r
                         File=FullFileName)\r
\r
        ReFileGuidPattern = re.compile("^\s*FILE_GUID\s*=.*$")\r
        ReVerStringPattern = re.compile("^\s*VERSION_STRING\s*=.*$")\r
\r
        FileLinesList = ProcessLineExtender(FileLinesList)\r
\r
        for Line in FileLinesList:\r
            if ReFileGuidPattern.match(Line):\r
                FileGuidString = Line\r
            if ReVerStringPattern.match(Line):\r
                VerString = Line\r
\r
        if FileGuidString:\r
            FileGuidString = GetSplitValueList(FileGuidString, '=', 1)[1]\r
        if VerString:\r
            VerString = GetSplitValueList(VerString, '=', 1)[1]\r
\r
        return FileGuidString, VerString\r
\r
## GetLocalValue\r
#\r
# Generate the local value for INF and DEC file. If Lang attribute not present, then use this value.\r
# If present, and there is no element without the Lang attribute, and one of the elements has the rfc1766 code is\r
# "en-x-tianocore", or "en-US" if "en-x-tianocore" was not found, or "en" if "en-US" was not found, or startswith 'en'\r
# if 'en' was not found, then use this value.\r
# If multiple entries of a tag exist which have the same language code, use the last entry.\r
#\r
# @param ValueList  A list need to be processed.\r
# @param UseFirstValue: True to use the first value, False to use the last value\r
#\r
# @return LocalValue\r
def GetLocalValue(ValueList, UseFirstValue=False):\r
    Value1 = ''\r
    Value2 = ''\r
    Value3 = ''\r
    Value4 = ''\r
    Value5 = ''\r
    for (Key, Value) in ValueList:\r
        if Key == TAB_LANGUAGE_EN_X:\r
            if UseFirstValue:\r
                if not Value1:\r
                    Value1 = Value\r
            else:\r
                Value1 = Value\r
        if Key == TAB_LANGUAGE_EN_US:\r
            if UseFirstValue:\r
                if not Value2:\r
                    Value2 = Value\r
            else:\r
                Value2 = Value\r
        if Key == TAB_LANGUAGE_EN:\r
            if UseFirstValue:\r
                if not Value3:\r
                    Value3 = Value\r
            else:\r
                Value3 = Value\r
        if Key.startswith(TAB_LANGUAGE_EN):\r
            if UseFirstValue:\r
                if not Value4:\r
                    Value4 = Value\r
            else:\r
                Value4 = Value\r
        if Key == '':\r
            if UseFirstValue:\r
                if not Value5:\r
                    Value5 = Value\r
            else:\r
                Value5 = Value\r
\r
    if Value1:\r
        return Value1\r
    if Value2:\r
        return Value2\r
    if Value3:\r
        return Value3\r
    if Value4:\r
        return Value4\r
    if Value5:\r
        return Value5\r
\r
    return ''\r
\r
\r
## GetCharIndexOutStr\r
#\r
# Get comment character index outside a string\r
#\r
# @param Line:              The string to be checked\r
# @param CommentCharacter:  Comment char, used to ignore comment content\r
#\r
# @retval Index\r
#\r
def GetCharIndexOutStr(CommentCharacter, Line):\r
    #\r
    # remove whitespace\r
    #\r
    Line = Line.strip()\r
\r
    #\r
    # Check whether comment character is in a string\r
    #\r
    InString = False\r
    for Index in range(0, len(Line)):\r
        if Line[Index] == '"':\r
            InString = not InString\r
        elif Line[Index] == CommentCharacter and InString :\r
            pass\r
        elif Line[Index] == CommentCharacter and (Index +1) < len(Line) and Line[Index+1] == CommentCharacter \\r
            and not InString :\r
            return Index\r
    return -1\r
\r
## ValidateUNIFilePath\r
#\r
# Check the UNI file path\r
#\r
# @param FilePath: The UNI file path\r
#\r
def ValidateUNIFilePath(Path):\r
    Suffix = Path[Path.rfind(TAB_SPLIT):]\r
\r
    #\r
    # Check if the suffix is one of the '.uni', '.UNI', '.Uni'\r
    #\r
    if Suffix not in TAB_UNI_FILE_SUFFIXS:\r
        Logger.Error("Unicode File Parser",\r
                        ToolError.FORMAT_INVALID,\r
                        Message=ST.ERR_UNI_FILE_SUFFIX_WRONG,\r
                        ExtraData=Path)\r
\r
    #\r
    # Check if '..' in the file name(without suffixe)\r
    #\r
    if (TAB_SPLIT + TAB_SPLIT) in Path:\r
        Logger.Error("Unicode File Parser",\r
                        ToolError.FORMAT_INVALID,\r
                        Message=ST.ERR_UNI_FILE_NAME_INVALID,\r
                        ExtraData=Path)\r
\r
    #\r
    # Check if the file name is valid according to the DEC and INF specification\r
    #\r
    Pattern = '[a-zA-Z0-9_][a-zA-Z0-9_\-\.]*'\r
    FileName = Path.replace(Suffix, '')\r
    InvalidCh = re.sub(Pattern, '', FileName)\r
    if InvalidCh:\r
        Logger.Error("Unicode File Parser",\r
                        ToolError.FORMAT_INVALID,\r
                        Message=ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID,\r
                        ExtraData=Path)\r
\r