Sync BaseTools Branch (version r2271) to EDKII main trunk.

  BaseTool Branch:
  https://edk2-buildtools.svn.sourceforge.net/svnroot/edk2-buildtools/branches/Releases/BaseTools_r2100

Signed-off-by: lgao4
Reviewed-by: hchen30

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@12214 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 921 insertions, 0 deletions

diff --git a/BaseTools/Source/Python/UPT/Library/Misc.py b/BaseTools/Source/Python/UPT/Library/Misc.py
new file mode 100644
index 0000000000..658c4e0cfb
--- /dev/null
+++ b/BaseTools/Source/Python/UPT/Library/Misc.py
@@ -0,0 +1,921 @@
+## @file
+# Common routines used by all tools
+#
+# Copyright (c) 2011, 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.
+#
+
+'''
+Misc
+'''
+
+##
+# Import Modules
+#
+import os.path
+from os import access
+from os import F_OK
+from os import makedirs
+from os import getcwd
+from os import chdir
+from os import listdir
+from os import remove
+from os import rmdir
+from os import linesep
+from os import walk
+from os import environ
+import re
+from UserDict import IterableUserDict
+
+import Logger.Log as Logger
+from Logger import StringTable as ST
+from Logger import ToolError
+from Library import GlobalData
+from Library.DataType import SUP_MODULE_LIST
+from Library.DataType import END_OF_LINE
+from Library.DataType import TAB_SPLIT
+from Library.DataType import LANGUAGE_EN_US
+from Library.String import GetSplitValueList
+from Library.ParserValidate import IsValidHexVersion
+from Library.ParserValidate import IsValidPath
+from Object.POM.CommonObject import TextObject
+
+## Convert GUID string in xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx style to C 
+# structure style
+#
+# @param      Guid:    The GUID string
+#
+def GuidStringToGuidStructureString(Guid):
+    GuidList = Guid.split('-')
+    Result = '{'
+    for Index in range(0, 3, 1):
+        Result = Result + '0x' + GuidList[Index] + ', '
+    Result = Result + '{0x' + GuidList[3][0:2] + ', 0x' + GuidList[3][2:4]
+    for Index in range(0, 12, 2):
+        Result = Result + ', 0x' + GuidList[4][Index:Index + 2]
+    Result += '}}'
+    return Result
+
+## Check whether GUID string is of format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+#
+# @param      GuidValue:   The GUID value
+#
+def CheckGuidRegFormat(GuidValue):
+    ## Regular expression used to find out register format of GUID
+    #
+    RegFormatGuidPattern = re.compile("^\s*([0-9a-fA-F]){8}-"
+                                       "([0-9a-fA-F]){4}-"
+                                       "([0-9a-fA-F]){4}-"
+                                       "([0-9a-fA-F]){4}-"
+                                       "([0-9a-fA-F]){12}\s*$")
+
+    if RegFormatGuidPattern.match(GuidValue):
+        return True
+    else:
+        return False
+
+
+## Convert GUID string in C structure style to 
+# xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+#
+# @param      GuidValue:   The GUID value in C structure format
+#
+def GuidStructureStringToGuidString(GuidValue):
+    GuidValueString = GuidValue.lower().replace("{", "").replace("}", "").\
+    replace(" ", "").replace(";", "")
+    GuidValueList = GuidValueString.split(",")
+    if len(GuidValueList) != 11:
+        return ''
+    try:
+        return "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (
+                int(GuidValueList[0], 16),
+                int(GuidValueList[1], 16),
+                int(GuidValueList[2], 16),
+                int(GuidValueList[3], 16),
+                int(GuidValueList[4], 16),
+                int(GuidValueList[5], 16),
+                int(GuidValueList[6], 16),
+                int(GuidValueList[7], 16),
+                int(GuidValueList[8], 16),
+                int(GuidValueList[9], 16),
+                int(GuidValueList[10], 16)
+                )
+    except BaseException:
+        return ''
+
+## Create directories
+#
+# @param      Directory:   The directory name
+#
+def CreateDirectory(Directory):
+    if Directory == None or Directory.strip() == "":
+        return True
+    try:
+        if not access(Directory, F_OK):
+            makedirs(Directory)
+    except BaseException:
+        return False
+    return True
+
+## Remove directories, including files and sub-directories in it
+#
+# @param      Directory:   The directory name
+#
+def RemoveDirectory(Directory, Recursively=False):
+    if Directory == None or Directory.strip() == "" or not \
+    os.path.exists(Directory):
+        return
+    if Recursively:
+        CurrentDirectory = getcwd()
+        chdir(Directory)
+        for File in listdir("."):
+            if os.path.isdir(File):
+                RemoveDirectory(File, Recursively)
+            else:
+                remove(File)
+        chdir(CurrentDirectory)
+    rmdir(Directory)
+
+## Store content in file
+#
+# This method is used to save file only when its content is changed. This is
+# quite useful for "make" system to decide what will be re-built and what 
+# won't.
+#
+# @param      File:            The path of file
+# @param      Content:         The new content of the file
+# @param      IsBinaryFile:    The flag indicating if the file is binary file 
+#                              or not
+#
+def SaveFileOnChange(File, Content, IsBinaryFile=True):
+    if not IsBinaryFile:
+        Content = Content.replace("\n", linesep)
+
+    if os.path.exists(File):
+        try:
+            if Content == open(File, "rb").read():
+                return False
+        except BaseException:
+            Logger.Error(None, ToolError.FILE_OPEN_FAILURE, ExtraData=File)
+
+    CreateDirectory(os.path.dirname(File))
+    try:
+        FileFd = open(File, "wb")
+        FileFd.write(Content)
+        FileFd.close()
+    except BaseException:
+        Logger.Error(None, ToolError.FILE_CREATE_FAILURE, ExtraData=File)
+
+    return True
+
+## Get all files of a directory
+#
+# @param Root:       Root dir
+# @param SkipList :  The files need be skipped
+#
+def GetFiles(Root, SkipList=None, FullPath=True):
+    OriPath = os.path.normpath(Root)
+    FileList = []
+    for Root, Dirs, Files in walk(Root):
+        if SkipList:
+            for Item in SkipList:
+                if Item in Dirs:
+                    Dirs.remove(Item)
+        for Dir in Dirs:
+            if Dir.startswith('.'):
+                Dirs.remove(Dir)
+
+        for File in Files:
+            if File.startswith('.'):
+                continue
+            File = os.path.normpath(os.path.join(Root, File))
+            if not FullPath:
+                File = File[len(OriPath) + 1:]
+            FileList.append(File)
+
+    return FileList
+
+## Get all non-metadata files of a directory
+#
+# @param Root:       Root Dir
+# @param SkipList :  List of path need be skipped
+# @param FullPath:  True if the returned file should be full path
+# @param PrefixPath: the path that need to be added to the files found
+# @return: the list of files found
+#  
+def GetNonMetaDataFiles(Root, SkipList, FullPath, PrefixPath):
+    FileList = GetFiles(Root, SkipList, FullPath)
+    NewFileList = []
+    for File in FileList:
+        ExtName = os.path.splitext(File)[1]
+        #
+        # skip '.dec', '.inf', '.dsc', '.fdf' files
+        #
+        if ExtName.lower() not in ['.dec', '.inf', '.dsc', '.fdf']:
+            NewFileList.append(os.path.normpath(os.path.join(PrefixPath, File)))
+
+    return NewFileList
+
+## Check if given file exists or not
+#
+# @param      File:    File name or path to be checked
+# @param      Dir:     The directory the file is relative to
+#
+def ValidFile(File, Ext=None):
+    File = File.replace('\\', '/')
+    if Ext != None:
+        FileExt = os.path.splitext(File)[1]
+        if FileExt.lower() != Ext.lower():
+            return False
+    if not os.path.exists(File):
+        return False
+    return True
+
+## RealPath
+#
+# @param      File:    File name or path to be checked
+# @param      Dir:     The directory the file is relative to
+# @param      OverrideDir:     The override directory
+#
+def RealPath(File, Dir='', OverrideDir=''):
+    NewFile = os.path.normpath(os.path.join(Dir, File))
+    NewFile = GlobalData.gALL_FILES[NewFile]
+    if not NewFile and OverrideDir:
+        NewFile = os.path.normpath(os.path.join(OverrideDir, File))
+        NewFile = GlobalData.gALL_FILES[NewFile]
+    return NewFile
+
+## RealPath2
+#
+# @param      File:    File name or path to be checked
+# @param      Dir:     The directory the file is relative to
+# @param      OverrideDir:     The override directory
+#
+def RealPath2(File, Dir='', OverrideDir=''):
+    if OverrideDir:
+        NewFile = GlobalData.gALL_FILES[os.path.normpath(os.path.join\
+                                                        (OverrideDir, File))]
+        if NewFile:
+            if OverrideDir[-1] == os.path.sep:
+                return NewFile[len(OverrideDir):], NewFile[0:len(OverrideDir)]
+            else:
+                return NewFile[len(OverrideDir) + 1:], \
+            NewFile[0:len(OverrideDir)]
+
+    NewFile = GlobalData.gALL_FILES[os.path.normpath(os.path.join(Dir, File))]
+    if NewFile:
+        if Dir:
+            if Dir[-1] == os.path.sep:
+                return NewFile[len(Dir):], NewFile[0:len(Dir)]
+            else:
+                return NewFile[len(Dir) + 1:], NewFile[0:len(Dir)]
+        else:
+            return NewFile, ''
+
+    return None, None
+
+## A dict which can access its keys and/or values orderly
+#
+#  The class implements a new kind of dict which its keys or values can be
+#  accessed in the order they are added into the dict. It guarantees the order
+#  by making use of an internal list to keep a copy of keys.
+#
+class Sdict(IterableUserDict):
+    ## Constructor
+    #
+    def __init__(self):
+        IterableUserDict.__init__(self)
+        self._key_list = []
+
+    ## [] operator
+    #
+    def __setitem__(self, Key, Value):
+        if Key not in self._key_list:
+            self._key_list.append(Key)
+        IterableUserDict.__setitem__(self, Key, Value)
+
+    ## del operator
+    #
+    def __delitem__(self, Key):
+        self._key_list.remove(Key)
+        IterableUserDict.__delitem__(self, Key)
+
+    ## used in "for k in dict" loop to ensure the correct order
+    #
+    def __iter__(self):
+        return self.iterkeys()
+
+    ## len() support
+    #
+    def __len__(self):
+        return len(self._key_list)
+
+    ## "in" test support
+    #
+    def __contains__(self, Key):
+        return Key in self._key_list
+
+    ## indexof support
+    #
+    def index(self, Key):
+        return self._key_list.index(Key)
+
+    ## insert support
+    #
+    def insert(self, Key, Newkey, Newvalue, Order):
+        Index = self._key_list.index(Key)
+        if Order == 'BEFORE':
+            self._key_list.insert(Index, Newkey)
+            IterableUserDict.__setitem__(self, Newkey, Newvalue)
+        elif Order == 'AFTER':
+            self._key_list.insert(Index + 1, Newkey)
+            IterableUserDict.__setitem__(self, Newkey, Newvalue)
+
+    ## append support
+    #
+    def append(self, Sdict2):
+        for Key in Sdict2:
+            if Key not in self._key_list:
+                self._key_list.append(Key)
+            IterableUserDict.__setitem__(self, Key, Sdict2[Key])
+    ## hash key
+    #
+    def has_key(self, Key):
+        return Key in self._key_list
+
+    ## Empty the dict
+    #
+    def clear(self):
+        self._key_list = []
+        IterableUserDict.clear(self)
+
+    ## Return a copy of keys
+    #
+    def keys(self):
+        Keys = []
+        for Key in self._key_list:
+            Keys.append(Key)
+        return Keys
+
+    ## Return a copy of values
+    #
+    def values(self):
+        Values = []
+        for Key in self._key_list:
+            Values.append(self[Key])
+        return Values
+
+    ## Return a copy of (key, value) list
+    #
+    def items(self):
+        Items = []
+        for Key in self._key_list:
+            Items.append((Key, self[Key]))
+        return Items
+
+    ## Iteration support
+    #
+    def iteritems(self):
+        return iter(self.items())
+
+    ## Keys interation support
+    #
+    def iterkeys(self):
+        return iter(self.keys())
+
+    ## Values interation support
+    #
+    def itervalues(self):
+        return iter(self.values())
+
+    ## Return value related to a key, and remove the (key, value) from the dict
+    #
+    def pop(self, Key, *Dv):
+        Value = None
+        if Key in self._key_list:
+            Value = self[Key]
+            self.__delitem__(Key)
+        elif len(Dv) != 0 :
+            Value = Dv[0]
+        return Value
+
+    ## Return (key, value) pair, and remove the (key, value) from the dict
+    #
+    def popitem(self):
+        Key = self._key_list[-1]
+        Value = self[Key]
+        self.__delitem__(Key)
+        return Key, Value
+    ## update method
+    #
+    def update(self, Dict=None, **Kwargs):
+        if Dict != None:
+            for Key1, Val1 in Dict.items():
+                self[Key1] = Val1
+        if len(Kwargs):
+            for Key1, Val1 in Kwargs.items():
+                self[Key1] = Val1
+
+## CommonPath
+#
+# @param PathList: PathList
+#
+def CommonPath(PathList):
+    Path1 = min(PathList).split(os.path.sep)
+    Path2 = max(PathList).split(os.path.sep)
+    for Index in xrange(min(len(Path1), len(Path2))):
+        if Path1[Index] != Path2[Index]:
+            return os.path.sep.join(Path1[:Index])
+    return os.path.sep.join(Path1)
+
+## PathClass
+#
+class PathClass(object):
+    def __init__(self, File='', Root='', AlterRoot='', Type='', IsBinary=False,
+                 Arch='COMMON', ToolChainFamily='', Target='', TagName='', \
+                 ToolCode=''):
+        self.Arch = Arch
+        self.File = str(File)
+        if os.path.isabs(self.File):
+            self.Root = ''
+            self.AlterRoot = ''
+        else:
+            self.Root = str(Root)
+            self.AlterRoot = str(AlterRoot)
+
+        #
+        # Remove any '.' and '..' in path
+        #
+        if self.Root:
+            self.Path = os.path.normpath(os.path.join(self.Root, self.File))
+            self.Root = os.path.normpath(CommonPath([self.Root, self.Path]))
+            #
+            # eliminate the side-effect of 'C:'
+            #
+            if self.Root[-1] == ':':
+                self.Root += os.path.sep
+            #
+            # file path should not start with path separator
+            #
+            if self.Root[-1] == os.path.sep:
+                self.File = self.Path[len(self.Root):]
+            else:
+                self.File = self.Path[len(self.Root) + 1:]
+        else:
+            self.Path = os.path.normpath(self.File)
+
+        self.SubDir, self.Name = os.path.split(self.File)
+        self.BaseName, self.Ext = os.path.splitext(self.Name)
+
+        if self.Root:
+            if self.SubDir:
+                self.Dir = os.path.join(self.Root, self.SubDir)
+            else:
+                self.Dir = self.Root
+        else:
+            self.Dir = self.SubDir
+
+        if IsBinary:
+            self.Type = Type
+        else:
+            self.Type = self.Ext.lower()
+
+        self.IsBinary = IsBinary
+        self.Target = Target
+        self.TagName = TagName
+        self.ToolCode = ToolCode
+        self.ToolChainFamily = ToolChainFamily
+
+        self._Key = None
+
+    ## Convert the object of this class to a string
+    #
+    #  Convert member Path of the class to a string
+    #
+    def __str__(self):
+        return self.Path
+
+    ## Override __eq__ function
+    #
+    # Check whether PathClass are the same
+    #
+    def __eq__(self, Other):
+        if type(Other) == type(self):
+            return self.Path == Other.Path
+        else:
+            return self.Path == str(Other)
+
+    ## Override __hash__ function
+    #
+    # Use Path as key in hash table
+    #
+    def __hash__(self):
+        return hash(self.Path)
+
+    ## _GetFileKey
+    #
+    def _GetFileKey(self):
+        if self._Key == None:
+            self._Key = self.Path.upper()
+        return self._Key
+    ## Validate
+    #
+    def Validate(self, Type='', CaseSensitive=True):
+        if GlobalData.gCASE_INSENSITIVE:
+            CaseSensitive = False
+        if Type and Type.lower() != self.Type:
+            return ToolError.FILE_TYPE_MISMATCH, '%s (expect %s but got %s)' % \
+        (self.File, Type, self.Type)
+
+        RealFile, RealRoot = RealPath2(self.File, self.Root, self.AlterRoot)
+        if not RealRoot and not RealFile:
+            RealFile = self.File
+            if self.AlterRoot:
+                RealFile = os.path.join(self.AlterRoot, self.File)
+            elif self.Root:
+                RealFile = os.path.join(self.Root, self.File)
+            return ToolError.FILE_NOT_FOUND, os.path.join(self.AlterRoot, RealFile)
+
+        ErrorCode = 0
+        ErrorInfo = ''
+        if RealRoot != self.Root or RealFile != self.File:
+            if CaseSensitive and (RealFile != self.File or \
+                                  (RealRoot != self.Root and RealRoot != \
+                                   self.AlterRoot)):
+                ErrorCode = ToolError.FILE_CASE_MISMATCH
+                ErrorInfo = self.File + '\n\t' + RealFile + \
+                 " [in file system]"
+
+            self.SubDir, self.Name = os.path.split(RealFile)
+            self.BaseName, self.Ext = os.path.splitext(self.Name)
+            if self.SubDir:
+                self.Dir = os.path.join(RealRoot, self.SubDir)
+            else:
+                self.Dir = RealRoot
+            self.File = RealFile
+            self.Root = RealRoot
+            self.Path = os.path.join(RealRoot, RealFile)
+        return ErrorCode, ErrorInfo
+
+    Key = property(_GetFileKey)
+
+## Check environment variables
+#
+#  Check environment variables that must be set for build. Currently they are
+#
+#   WORKSPACE           The directory all packages/platforms start from
+#   EDK_TOOLS_PATH      The directory contains all tools needed by the build
+#   PATH                $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH
+#
+#   If any of above environment variable is not set or has error, the build
+#   will be broken.
+#
+def CheckEnvVariable():
+    #
+    # check WORKSPACE
+    #
+    if "WORKSPACE" not in environ:
+        Logger.Error("UPT",
+                     ToolError.UPT_ENVIRON_MISSING_ERROR,
+                     ST.ERR_NOT_FOUND_ENVIRONMENT,
+                     ExtraData="WORKSPACE")
+
+    WorkspaceDir = os.path.normpath(environ["WORKSPACE"])
+    if not os.path.exists(WorkspaceDir):
+        Logger.Error("UPT",
+                     ToolError.UPT_ENVIRON_MISSING_ERROR,
+                     ST.ERR_WORKSPACE_NOTEXIST,
+                     ExtraData="%s" % WorkspaceDir)
+    elif ' ' in WorkspaceDir:
+        Logger.Error("UPT",
+                     ToolError.FORMAT_NOT_SUPPORTED,
+                     ST.ERR_SPACE_NOTALLOWED,
+                     ExtraData=WorkspaceDir)
+
+## Check whether all module types are in list
+#
+# check whether all module types (SUP_MODULE_LIST) are in list
+#  
+# @param ModuleList:  a list of ModuleType
+#
+def IsAllModuleList(ModuleList):
+    NewModuleList = [Module.upper() for Module in ModuleList]
+    for Module in SUP_MODULE_LIST:
+        if Module not in NewModuleList:
+            return False
+    else:
+        return True
+
+## Dictionary that use comment(GenericComment, TailComment) as value,
+# if a new comment which key already in the dic is inserted, then the 
+# comment will be merged.
+# Key is (Statement, SupArch), when TailComment is added, it will ident 
+# according to Statement
+#
+class MergeCommentDict(dict):
+    ## []= operator
+    #
+    def __setitem__(self, Key, CommentVal):
+        GenericComment, TailComment = CommentVal
+        if Key in self:
+            OrigVal1, OrigVal2 = dict.__getitem__(self, Key)
+            Statement = Key[0]
+            dict.__setitem__(self, Key, (OrigVal1 + GenericComment, OrigVal2 \
+                                         + len(Statement) * ' ' + TailComment))
+        else:
+            dict.__setitem__(self, Key, (GenericComment, TailComment))
+
+    ## =[] operator
+    #
+    def __getitem__(self, Key):
+        return dict.__getitem__(self, Key)
+
+
+## GenDummyHelpTextObj
+#
+# @retval HelpTxt:   Generated dummy help text object
+#
+def GenDummyHelpTextObj():
+    HelpTxt = TextObject()
+    HelpTxt.SetLang(LANGUAGE_EN_US)
+    HelpTxt.SetString(' ')
+    return HelpTxt
+
+## ConvertVersionToDecimal, the minor version should be within 0 - 99
+# <HexVersion>          ::=  "0x" <Major> <Minor>
+# <Major>               ::=  (a-fA-F0-9){4}
+# <Minor>               ::=  (a-fA-F0-9){4}
+# <DecVersion>          ::=  (0-65535) ["." (0-99)]
+# 
+# @param StringIn:  The string contains version defined in INF file.
+#                   It can be Decimal or Hex
+#
+def ConvertVersionToDecimal(StringIn):
+    if IsValidHexVersion(StringIn):
+        Value = int(StringIn, 16)
+        Major = Value >> 16
+        Minor = Value & 0xFFFF
+        MinorStr = str(Minor)
+        if len(MinorStr) == 1:
+            MinorStr = '0' + MinorStr
+        return str(Major) + '.' + MinorStr
+    else:
+        if StringIn.find(TAB_SPLIT) != -1:
+            return StringIn
+        elif StringIn:
+            return StringIn + '.0'
+        else:
+            #
+            # when StringIn is '', return it directly
+            #
+            return StringIn
+
+## GetHelpStringByRemoveHashKey
+#
+# Remove hash key at the header of string and return the remain.
+#
+# @param String:  The string need to be processed.
+#
+def GetHelpStringByRemoveHashKey(String):
+    ReturnString = ''
+    PattenRemoveHashKey = re.compile(r"^[#+\s]+", re.DOTALL)
+    String = String.strip()
+    if String == '':
+        return String
+
+    LineList = GetSplitValueList(String, END_OF_LINE)
+    for Line in LineList:
+        ValueList = PattenRemoveHashKey.split(Line)
+        if len(ValueList) == 1:
+            ReturnString += ValueList[0] + END_OF_LINE
+        else:
+            ReturnString += ValueList[1] + END_OF_LINE
+
+    if ReturnString.endswith('\n') and not ReturnString.endswith('\n\n') and ReturnString != '\n':
+        ReturnString = ReturnString[:-1]
+
+    return ReturnString
+
+## ConvPathFromAbsToRel
+#
+# Get relative file path from absolute path.
+#
+# @param Path:  The string contain file absolute path.
+# @param Root:  The string contain the parent path of Path in.
+#
+#
+def ConvPathFromAbsToRel(Path, Root):
+    Path = os.path.normpath(Path)
+    Root = os.path.normpath(Root)
+    FullPath = os.path.normpath(os.path.join(Root, Path))
+
+    #
+    # If Path is absolute path.
+    # It should be in Root.
+    #
+    if os.path.isabs(Path):
+        return FullPath[FullPath.find(Root) + len(Root) + 1:]
+
+    else:
+        return Path
+
+## ConvertPath
+#
+# Convert special characters to '_', '\' to '/'
+# return converted path: Test!1.inf -> Test_1.inf
+#
+# @param Path: Path to be converted
+#
+def ConvertPath(Path):
+    RetPath = ''
+    for Char in Path.strip():
+        if Char.isalnum() or Char in '.-_/':
+            RetPath = RetPath + Char
+        elif Char == '\\':
+            RetPath = RetPath + '/'
+        else:
+            RetPath = RetPath + '_'
+    return RetPath
+
+## ConvertSpec
+#
+# during install, convert the Spec string extract from UPD into INF allowable definition, 
+# the difference is period is allowed in the former (not the first letter) but not in the latter.
+# return converted Spec string
+#
+# @param SpecStr: SpecStr to be converted
+#
+def ConvertSpec(SpecStr):
+    RetStr = ''
+    for Char in SpecStr:
+        if Char.isalnum() or Char == '_':
+            RetStr = RetStr + Char
+        else:
+            RetStr = RetStr + '_'
+
+    return RetStr
+
+
+## IsEqualList
+#
+# Judge two lists are identical(contain same item).
+# The rule is elements in List A are in List B and elements in List B are in List A.
+#
+# @param ListA, ListB  Lists need to be judged.
+# 
+# @return True  ListA and ListB are identical
+# @return False ListA and ListB are different with each other
+#
+def IsEqualList(ListA, ListB):
+    if ListA == ListB:
+        return True
+
+    for ItemA in ListA:
+        if not ItemA in ListB:
+            return False
+
+    for ItemB in ListB:
+        if not ItemB in ListA:
+            return False
+
+    return True
+
+## ConvertArchList
+#
+# Convert item in ArchList if the start character is lower case.
+# In UDP spec, Arch is only allowed as: [A-Z]([a-zA-Z0-9])* 
+#
+# @param ArchList The ArchList need to be converted.
+# 
+# @return NewList  The ArchList been converted.
+#
+def ConvertArchList(ArchList):
+    NewArchList = []
+    if not ArchList:
+        return NewArchList
+
+    if type(ArchList) == list:
+        for Arch in ArchList:
+            Arch = Arch.upper()
+            NewArchList.append(Arch)
+    elif type(ArchList) == str:
+        ArchList = ArchList.upper()
+        NewArchList.append(ArchList)
+
+    return NewArchList
+
+## ProcessLineExtender
+#
+# Process the LineExtender of Line in LineList.
+# If one line ends with a line extender, then it will be combined together with next line.
+#
+# @param LineList The LineList need to be processed.
+# 
+# @return NewList  The ArchList been processed.
+#
+def ProcessLineExtender(LineList):
+    NewList = []
+    Count = 0
+    while Count < len(LineList):
+        if LineList[Count].strip().endswith("\\") and Count + 1 < len(LineList):
+            NewList.append(LineList[Count].strip()[:-2] + LineList[Count + 1])
+            Count = Count + 1
+        else:
+            NewList.append(LineList[Count])
+
+        Count = Count + 1
+
+    return NewList
+
+## GetLibInstanceInfo
+#
+# Get the information from Library Instance INF file.
+#
+# @param string.  A string start with # and followed by INF file path
+# @param WorkSpace. The WorkSpace directory used to combined with INF file path.
+#
+# @return GUID, Version
+def GetLibInstanceInfo(String, WorkSpace, LineNo):
+
+    FileGuidString = ""
+    VerString = ""
+
+    OrignalString = String
+    String = String.strip()
+    if not String:
+        return None, None
+    #
+    # Remove "#" characters at the beginning
+    #
+    String = GetHelpStringByRemoveHashKey(String)
+    String = String.strip()
+
+    #
+    # Validate file name exist.
+    #
+    FullFileName = os.path.normpath(os.path.realpath(os.path.join(WorkSpace, String)))
+    if not (ValidFile(FullFileName)):
+        Logger.Error("InfParser",
+                     ToolError.FORMAT_INVALID,
+                     ST.ERR_FILELIST_EXIST % (String),
+                     File=GlobalData.gINF_MODULE_NAME,
+                     Line=LineNo,
+                     ExtraData=OrignalString)
+
+    #
+    # Validate file exist/format.
+    #
+    if IsValidPath(String, WorkSpace):
+        IsValidFileFlag = True
+    else:
+        Logger.Error("InfParser",
+                     ToolError.FORMAT_INVALID,
+                     ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (String),
+                     File=GlobalData.gINF_MODULE_NAME,
+                     Line=LineNo,
+                     ExtraData=OrignalString)
+        return False
+    if IsValidFileFlag:
+        FileLinesList = []
+
+        try:
+            FInputfile = open(FullFileName, "rb", 0)
+            try:
+                FileLinesList = FInputfile.readlines()
+            except BaseException:
+                Logger.Error("InfParser",
+                             ToolError.FILE_READ_FAILURE,
+                             ST.ERR_FILE_OPEN_FAILURE,
+                             File=FullFileName)
+            finally:
+                FInputfile.close()
+        except BaseException:
+            Logger.Error("InfParser",
+                         ToolError.FILE_READ_FAILURE,
+                         ST.ERR_FILE_OPEN_FAILURE,
+                         File=FullFileName)
+
+        ReFileGuidPattern = re.compile("^\s*FILE_GUID\s*=.*$")
+        ReVerStringPattern = re.compile("^\s*VERSION_STRING\s*=.*$")
+
+        FileLinesList = ProcessLineExtender(FileLinesList)
+
+        for Line in FileLinesList:
+            if ReFileGuidPattern.match(Line):
+                FileGuidString = Line
+            if ReVerStringPattern.match(Line):
+                VerString = Line
+
+        if FileGuidString:
+            FileGuidString = GetSplitValueList(FileGuidString, '=', 1)[1]
+        if VerString:
+            VerString = GetSplitValueList(VerString, '=', 1)[1]
+
+        return FileGuidString, VerString