BaseTools/Source/Python/Common/Misc.py

   1 ## @file
   2 # Common routines used by all tools
   3 #
   4 # Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>
   5 # This program and the accompanying materials
   6 # are licensed and made available under the terms and conditions of the BSD License
   7 # which accompanies this distribution.  The full text of the license may be found at
   8 # http://opensource.org/licenses/bsd-license.php
   9 #
  10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 #
  13
  14 ##
  15 # Import Modules
  16 #
  17 from __future__ import absolute_import
  18
  19 import sys
  20 import string
  21 import threading
  22 import time
  23 import re
  24 import pickle
  25 import array
  26 import shutil
  27 from random import sample
  28 from struct import pack
  29 import uuid
  30 import subprocess
  31 from collections import OrderedDict
  32
  33 import Common.LongFilePathOs as os
  34 from Common import EdkLogger as EdkLogger
  35 from Common import GlobalData as GlobalData
  36 from Common.DataType import *
  37 from Common.BuildToolError import *
  38 from CommonDataClass.DataClass import *
  39 from Common.Parsing import GetSplitValueList
  40 from Common.LongFilePathSupport import OpenLongFilePath as open
  41 from Common.MultipleWorkspace import MultipleWorkspace as mws
  42 from CommonDataClass.Exceptions import BadExpression
  43 from Common.caching import cached_property
  44
  45 ## Regular expression used to find out place holders in string template
  46 gPlaceholderPattern = re.compile("\$\{([^$()\s]+)\}", re.MULTILINE | re.UNICODE)
  47
  48 ## regular expressions for map file processing
  49 startPatternGeneral = re.compile("^Start[' ']+Length[' ']+Name[' ']+Class")
  50 addressPatternGeneral = re.compile("^Address[' ']+Publics by Value[' ']+Rva\+Base")
  51 valuePatternGcc = re.compile('^([\w_\.]+) +([\da-fA-Fx]+) +([\da-fA-Fx]+)$')
  52 pcdPatternGcc = re.compile('^([\da-fA-Fx]+) +([\da-fA-Fx]+)')
  53 secReGeneral = re.compile('^([\da-fA-F]+):([\da-fA-F]+) +([\da-fA-F]+)[Hh]? +([.\w\$]+) +(\w+)', re.UNICODE)
  54
  55 StructPattern = re.compile(r'[_a-zA-Z][0-9A-Za-z_]*$')
  56
  57 ## Dictionary used to store dependencies of files
  58 gDependencyDatabase = {}    # arch : {file path : [dependent files list]}
  59
  60 #
  61 # If a module is built more than once with different PCDs or library classes
  62 # a temporary INF file with same content is created, the temporary file is removed
  63 # when build exits.
  64 #
  65 _TempInfs = []
  66
  67 def GetVariableOffset(mapfilepath, efifilepath, varnames):
  68     """ Parse map file to get variable offset in current EFI file
  69     @param mapfilepath    Map file absolution path
  70     @param efifilepath:   EFI binary file full path
  71     @param varnames       iteratable container whose elements are variable names to be searched
  72
  73     @return List whos elements are tuple with variable name and raw offset
  74     """
  75     lines = []
  76     try:
  77         f = open(mapfilepath, 'r')
  78         lines = f.readlines()
  79         f.close()
  80     except:
  81         return None
  82
  83     if len(lines) == 0: return None
  84     firstline = lines[0].strip()
  85     if (firstline.startswith("Archive member included ") and
  86         firstline.endswith(" file (symbol)")):
  87         return _parseForGCC(lines, efifilepath, varnames)
  88     if firstline.startswith("# Path:"):
  89         return _parseForXcode(lines, efifilepath, varnames)
  90     return _parseGeneral(lines, efifilepath, varnames)
  91
  92 def _parseForXcode(lines, efifilepath, varnames):
  93     status = 0
  94     ret = []
  95     for line in lines:
  96         line = line.strip()
  97         if status == 0 and line == "# Symbols:":
  98             status = 1
  99             continue
 100         if status == 1 and len(line) != 0:
 101             for varname in varnames:
 102                 if varname in line:
 103                     # cannot pregenerate this RegEx since it uses varname from varnames.
 104                     m = re.match('^([\da-fA-FxX]+)([\s\S]*)([_]*%s)$' % varname, line)
 105                     if m is not None:
 106                         ret.append((varname, m.group(1)))
 107     return ret
 108
 109 def _parseForGCC(lines, efifilepath, varnames):
 110     """ Parse map file generated by GCC linker """
 111     status = 0
 112     sections = []
 113     varoffset = []
 114     for index, line in enumerate(lines):
 115         line = line.strip()
 116         # status machine transection
 117         if status == 0 and line == "Memory Configuration":
 118             status = 1
 119             continue
 120         elif status == 1 and line == 'Linker script and memory map':
 121             status = 2
 122             continue
 123         elif status ==2 and line == 'START GROUP':
 124             status = 3
 125             continue
 126
 127         # status handler
 128         if status == 3:
 129             m = valuePatternGcc.match(line)
 130             if m is not None:
 131                 sections.append(m.groups(0))
 132             for varname in varnames:
 133                 Str = ''
 134                 m = re.match("^.data.(%s)" % varname, line)
 135                 if m is not None:
 136                     m = re.match(".data.(%s)$" % varname, line)
 137                     if m is not None:
 138                         Str = lines[index + 1]
 139                     else:
 140                         Str = line[len(".data.%s" % varname):]
 141                     if Str:
 142                         m = pcdPatternGcc.match(Str.strip())
 143                         if m is not None:
 144                             varoffset.append((varname, int(m.groups(0)[0], 16), int(sections[-1][1], 16), sections[-1][0]))
 145
 146     if not varoffset:
 147         return []
 148     # get section information from efi file
 149     efisecs = PeImageClass(efifilepath).SectionHeaderList
 150     if efisecs is None or len(efisecs) == 0:
 151         return []
 152     #redirection
 153     redirection = 0
 154     for efisec in efisecs:
 155         for section in sections:
 156             if section[0].strip() == efisec[0].strip() and section[0].strip() == '.text':
 157                 redirection = int(section[1], 16) - efisec[1]
 158
 159     ret = []
 160     for var in varoffset:
 161         for efisec in efisecs:
 162             if var[1] >= efisec[1] and var[1] < efisec[1]+efisec[3]:
 163                 ret.append((var[0], hex(efisec[2] + var[1] - efisec[1] - redirection)))
 164     return ret
 165
 166 def _parseGeneral(lines, efifilepath, varnames):
 167     status = 0    #0 - beginning of file; 1 - PE section definition; 2 - symbol table
 168     secs  = []    # key = section name
 169     varoffset = []
 170     symRe = re.compile('^([\da-fA-F]+):([\da-fA-F]+) +([\.:\\\\\w\?@\$]+) +([\da-fA-F]+)', re.UNICODE)
 171
 172     for line in lines:
 173         line = line.strip()
 174         if startPatternGeneral.match(line):
 175             status = 1
 176             continue
 177         if addressPatternGeneral.match(line):
 178             status = 2
 179             continue
 180         if line.startswith("entry point at"):
 181             status = 3
 182             continue
 183         if status == 1 and len(line) != 0:
 184             m =  secReGeneral.match(line)
 185             assert m is not None, "Fail to parse the section in map file , line is %s" % line
 186             sec_no, sec_start, sec_length, sec_name, sec_class = m.groups(0)
 187             secs.append([int(sec_no, 16), int(sec_start, 16), int(sec_length, 16), sec_name, sec_class])
 188         if status == 2 and len(line) != 0:
 189             for varname in varnames:
 190                 m = symRe.match(line)
 191                 assert m is not None, "Fail to parse the symbol in map file, line is %s" % line
 192                 sec_no, sym_offset, sym_name, vir_addr = m.groups(0)
 193                 sec_no     = int(sec_no,     16)
 194                 sym_offset = int(sym_offset, 16)
 195                 vir_addr   = int(vir_addr,   16)
 196                 # cannot pregenerate this RegEx since it uses varname from varnames.
 197                 m2 = re.match('^[_]*(%s)' % varname, sym_name)
 198                 if m2 is not None:
 199                     # fond a binary pcd entry in map file
 200                     for sec in secs:
 201                         if sec[0] == sec_no and (sym_offset >= sec[1] and sym_offset < sec[1] + sec[2]):
 202                             varoffset.append([varname, sec[3], sym_offset, vir_addr, sec_no])
 203
 204     if not varoffset: return []
 205
 206     # get section information from efi file
 207     efisecs = PeImageClass(efifilepath).SectionHeaderList
 208     if efisecs is None or len(efisecs) == 0:
 209         return []
 210
 211     ret = []
 212     for var in varoffset:
 213         index = 0
 214         for efisec in efisecs:
 215             index = index + 1
 216             if var[1].strip() == efisec[0].strip():
 217                 ret.append((var[0], hex(efisec[2] + var[2])))
 218             elif var[4] == index:
 219                 ret.append((var[0], hex(efisec[2] + var[2])))
 220
 221     return ret
 222
 223 ## Routine to process duplicated INF
 224 #
 225 #  This function is called by following two cases:
 226 #  Case 1 in DSC:
 227 #    [components.arch]
 228 #    Pkg/module/module.inf
 229 #    Pkg/module/module.inf {
 230 #      <Defines>
 231 #        FILE_GUID = 0D1B936F-68F3-4589-AFCC-FB8B7AEBC836
 232 #    }
 233 #  Case 2 in FDF:
 234 #    INF Pkg/module/module.inf
 235 #    INF FILE_GUID = 0D1B936F-68F3-4589-AFCC-FB8B7AEBC836 Pkg/module/module.inf
 236 #
 237 #  This function copies Pkg/module/module.inf to
 238 #  Conf/.cache/0D1B936F-68F3-4589-AFCC-FB8B7AEBC836module.inf
 239 #
 240 #  @param Path     Original PathClass object
 241 #  @param BaseName New file base name
 242 #
 243 #  @retval         return the new PathClass object
 244 #
 245 def ProcessDuplicatedInf(Path, BaseName, Workspace):
 246     Filename = os.path.split(Path.File)[1]
 247     if '.' in Filename:
 248         Filename = BaseName + Path.BaseName + Filename[Filename.rfind('.'):]
 249     else:
 250         Filename = BaseName + Path.BaseName
 251
 252     #
 253     # If -N is specified on command line, cache is disabled
 254     # The directory has to be created
 255     #
 256     DbDir = os.path.split(GlobalData.gDatabasePath)[0]
 257     if not os.path.exists(DbDir):
 258         os.makedirs(DbDir)
 259     #
 260     # A temporary INF is copied to database path which must have write permission
 261     # The temporary will be removed at the end of build
 262     # In case of name conflict, the file name is
 263     # FILE_GUIDBaseName (0D1B936F-68F3-4589-AFCC-FB8B7AEBC836module.inf)
 264     #
 265     TempFullPath = os.path.join(DbDir,
 266                                 Filename)
 267     RtPath = PathClass(Path.File, Workspace)
 268     #
 269     # Modify the full path to temporary path, keep other unchanged
 270     #
 271     # To build same module more than once, the module path with FILE_GUID overridden has
 272     # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the real path
 273     # in DSC which is used as relative path by C files and other files in INF.
 274     # A trick was used: all module paths are PathClass instances, after the initialization
 275     # of PathClass, the PathClass.Path is overridden by the temporary INF path.
 276     #
 277     # The reason for creating a temporary INF is:
 278     # Platform.Modules which is the base to create ModuleAutoGen objects is a dictionary,
 279     # the key is the full path of INF, the value is an object to save overridden library instances, PCDs.
 280     # A different key for the same module is needed to create different output directory,
 281     # retrieve overridden PCDs, library instances.
 282     #
 283     # The BaseName is the FILE_GUID which is also the output directory name.
 284     #
 285     #
 286     RtPath.Path = TempFullPath
 287     RtPath.BaseName = BaseName
 288     #
 289     # If file exists, compare contents
 290     #
 291     if os.path.exists(TempFullPath):
 292         with open(str(Path), 'rb') as f1, open(TempFullPath, 'rb') as f2:
 293             if f1.read() == f2.read():
 294                 return RtPath
 295     _TempInfs.append(TempFullPath)
 296     shutil.copy2(str(Path), TempFullPath)
 297     return RtPath
 298
 299 ## Remove temporary created INFs whose paths were saved in _TempInfs
 300 #
 301 def ClearDuplicatedInf():
 302     while _TempInfs:
 303         File = _TempInfs.pop()
 304         if os.path.exists(File):
 305             os.remove(File)
 306
 307 ## Convert GUID string in xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx style to C structure style
 308 #
 309 #   @param      Guid    The GUID string
 310 #
 311 #   @retval     string  The GUID string in C structure style
 312 #
 313 def GuidStringToGuidStructureString(Guid):
 314     GuidList = Guid.split('-')
 315     Result = '{'
 316     for Index in range(0, 3, 1):
 317         Result = Result + '0x' + GuidList[Index] + ', '
 318     Result = Result + '{0x' + GuidList[3][0:2] + ', 0x' + GuidList[3][2:4]
 319     for Index in range(0, 12, 2):
 320         Result = Result + ', 0x' + GuidList[4][Index:Index + 2]
 321     Result += '}}'
 322     return Result
 323
 324 ## Convert GUID structure in byte array to xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 325 #
 326 #   @param      GuidValue   The GUID value in byte array
 327 #
 328 #   @retval     string      The GUID value in xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format
 329 #
 330 def GuidStructureByteArrayToGuidString(GuidValue):
 331     guidValueString = GuidValue.lower().replace("{", "").replace("}", "").replace(" ", "").replace(";", "")
 332     guidValueList = guidValueString.split(",")
 333     if len(guidValueList) != 16:
 334         return ''
 335         #EdkLogger.error(None, None, "Invalid GUID value string %s" % GuidValue)
 336     try:
 337         return "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (
 338                 int(guidValueList[3], 16),
 339                 int(guidValueList[2], 16),
 340                 int(guidValueList[1], 16),
 341                 int(guidValueList[0], 16),
 342                 int(guidValueList[5], 16),
 343                 int(guidValueList[4], 16),
 344                 int(guidValueList[7], 16),
 345                 int(guidValueList[6], 16),
 346                 int(guidValueList[8], 16),
 347                 int(guidValueList[9], 16),
 348                 int(guidValueList[10], 16),
 349                 int(guidValueList[11], 16),
 350                 int(guidValueList[12], 16),
 351                 int(guidValueList[13], 16),
 352                 int(guidValueList[14], 16),
 353                 int(guidValueList[15], 16)
 354                 )
 355     except:
 356         return ''
 357
 358 ## Convert GUID string in C structure style to xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 359 #
 360 #   @param      GuidValue   The GUID value in C structure format
 361 #
 362 #   @retval     string      The GUID value in xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format
 363 #
 364 def GuidStructureStringToGuidString(GuidValue):
 365     if not GlobalData.gGuidCFormatPattern.match(GuidValue):
 366         return ''
 367     guidValueString = GuidValue.lower().replace("{", "").replace("}", "").replace(" ", "").replace(";", "")
 368     guidValueList = guidValueString.split(",")
 369     if len(guidValueList) != 11:
 370         return ''
 371         #EdkLogger.error(None, None, "Invalid GUID value string %s" % GuidValue)
 372     try:
 373         return "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (
 374                 int(guidValueList[0], 16),
 375                 int(guidValueList[1], 16),
 376                 int(guidValueList[2], 16),
 377                 int(guidValueList[3], 16),
 378                 int(guidValueList[4], 16),
 379                 int(guidValueList[5], 16),
 380                 int(guidValueList[6], 16),
 381                 int(guidValueList[7], 16),
 382                 int(guidValueList[8], 16),
 383                 int(guidValueList[9], 16),
 384                 int(guidValueList[10], 16)
 385                 )
 386     except:
 387         return ''
 388
 389 ## Convert GUID string in C structure style to xxxxxxxx_xxxx_xxxx_xxxx_xxxxxxxxxxxx
 390 #
 391 #   @param      GuidValue   The GUID value in C structure format
 392 #
 393 #   @retval     string      The GUID value in xxxxxxxx_xxxx_xxxx_xxxx_xxxxxxxxxxxx format
 394 #
 395 def GuidStructureStringToGuidValueName(GuidValue):
 396     guidValueString = GuidValue.lower().replace("{", "").replace("}", "").replace(" ", "")
 397     guidValueList = guidValueString.split(",")
 398     if len(guidValueList) != 11:
 399         EdkLogger.error(None, FORMAT_INVALID, "Invalid GUID value string [%s]" % GuidValue)
 400     return "%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x" % (
 401             int(guidValueList[0], 16),
 402             int(guidValueList[1], 16),
 403             int(guidValueList[2], 16),
 404             int(guidValueList[3], 16),
 405             int(guidValueList[4], 16),
 406             int(guidValueList[5], 16),
 407             int(guidValueList[6], 16),
 408             int(guidValueList[7], 16),
 409             int(guidValueList[8], 16),
 410             int(guidValueList[9], 16),
 411             int(guidValueList[10], 16)
 412             )
 413
 414 ## Create directories
 415 #
 416 #   @param      Directory   The directory name
 417 #
 418 def CreateDirectory(Directory):
 419     if Directory is None or Directory.strip() == "":
 420         return True
 421     try:
 422         if not os.access(Directory, os.F_OK):
 423             os.makedirs(Directory)
 424     except:
 425         return False
 426     return True
 427
 428 ## Remove directories, including files and sub-directories in it
 429 #
 430 #   @param      Directory   The directory name
 431 #
 432 def RemoveDirectory(Directory, Recursively=False):
 433     if Directory is None or Directory.strip() == "" or not os.path.exists(Directory):
 434         return
 435     if Recursively:
 436         CurrentDirectory = os.getcwd()
 437         os.chdir(Directory)
 438         for File in os.listdir("."):
 439             if os.path.isdir(File):
 440                 RemoveDirectory(File, Recursively)
 441             else:
 442                 os.remove(File)
 443         os.chdir(CurrentDirectory)
 444     os.rmdir(Directory)
 445
 446 ## Store content in file
 447 #
 448 #  This method is used to save file only when its content is changed. This is
 449 #  quite useful for "make" system to decide what will be re-built and what won't.
 450 #
 451 #   @param      File            The path of file
 452 #   @param      Content         The new content of the file
 453 #   @param      IsBinaryFile    The flag indicating if the file is binary file or not
 454 #
 455 #   @retval     True            If the file content is changed and the file is renewed
 456 #   @retval     False           If the file content is the same
 457 #
 458 def SaveFileOnChange(File, Content, IsBinaryFile=True):
 459     if not IsBinaryFile:
 460         Content = Content.replace("\n", os.linesep)
 461
 462     if os.path.exists(File):
 463         try:
 464             if Content == open(File, "rb").read():
 465                 return False
 466         except:
 467             EdkLogger.error(None, FILE_OPEN_FAILURE, ExtraData=File)
 468
 469     DirName = os.path.dirname(File)
 470     if not CreateDirectory(DirName):
 471         EdkLogger.error(None, FILE_CREATE_FAILURE, "Could not create directory %s" % DirName)
 472     else:
 473         if DirName == '':
 474             DirName = os.getcwd()
 475         if not os.access(DirName, os.W_OK):
 476             EdkLogger.error(None, PERMISSION_FAILURE, "Do not have write permission on directory %s" % DirName)
 477
 478     try:
 479         Fd = open(File, "wb")
 480         Fd.write(Content)
 481         Fd.close()
 482     except IOError as X:
 483         EdkLogger.error(None, FILE_CREATE_FAILURE, ExtraData='IOError %s' % X)
 484
 485     return True
 486
 487 ## Retrieve and cache the real path name in file system
 488 #
 489 #   @param      Root    The root directory of path relative to
 490 #
 491 #   @retval     str     The path string if the path exists
 492 #   @retval     None    If path doesn't exist
 493 #
 494 class DirCache:
 495     _CACHE_ = set()
 496     _UPPER_CACHE_ = {}
 497
 498     def __init__(self, Root):
 499         self._Root = Root
 500         for F in os.listdir(Root):
 501             self._CACHE_.add(F)
 502             self._UPPER_CACHE_[F.upper()] = F
 503
 504     # =[] operator
 505     def __getitem__(self, Path):
 506         Path = Path[len(os.path.commonprefix([Path, self._Root])):]
 507         if not Path:
 508             return self._Root
 509         if Path and Path[0] == os.path.sep:
 510             Path = Path[1:]
 511         if Path in self._CACHE_:
 512             return os.path.join(self._Root, Path)
 513         UpperPath = Path.upper()
 514         if UpperPath in self._UPPER_CACHE_:
 515             return os.path.join(self._Root, self._UPPER_CACHE_[UpperPath])
 516
 517         IndexList = []
 518         LastSepIndex = -1
 519         SepIndex = Path.find(os.path.sep)
 520         while SepIndex > -1:
 521             Parent = UpperPath[:SepIndex]
 522             if Parent not in self._UPPER_CACHE_:
 523                 break
 524             LastSepIndex = SepIndex
 525             SepIndex = Path.find(os.path.sep, LastSepIndex + 1)
 526
 527         if LastSepIndex == -1:
 528             return None
 529
 530         Cwd = os.getcwd()
 531         os.chdir(self._Root)
 532         SepIndex = LastSepIndex
 533         while SepIndex > -1:
 534             Parent = Path[:SepIndex]
 535             ParentKey = UpperPath[:SepIndex]
 536             if ParentKey not in self._UPPER_CACHE_:
 537                 os.chdir(Cwd)
 538                 return None
 539
 540             if Parent in self._CACHE_:
 541                 ParentDir = Parent
 542             else:
 543                 ParentDir = self._UPPER_CACHE_[ParentKey]
 544             for F in os.listdir(ParentDir):
 545                 Dir = os.path.join(ParentDir, F)
 546                 self._CACHE_.add(Dir)
 547                 self._UPPER_CACHE_[Dir.upper()] = Dir
 548
 549             SepIndex = Path.find(os.path.sep, SepIndex + 1)
 550
 551         os.chdir(Cwd)
 552         if Path in self._CACHE_:
 553             return os.path.join(self._Root, Path)
 554         elif UpperPath in self._UPPER_CACHE_:
 555             return os.path.join(self._Root, self._UPPER_CACHE_[UpperPath])
 556         return None
 557
 558 def RealPath(File, Dir='', OverrideDir=''):
 559     NewFile = os.path.normpath(os.path.join(Dir, File))
 560     NewFile = GlobalData.gAllFiles[NewFile]
 561     if not NewFile and OverrideDir:
 562         NewFile = os.path.normpath(os.path.join(OverrideDir, File))
 563         NewFile = GlobalData.gAllFiles[NewFile]
 564     return NewFile
 565
 566 ## Get GUID value from given packages
 567 #
 568 #   @param      CName           The CName of the GUID
 569 #   @param      PackageList     List of packages looking-up in
 570 #   @param      Inffile         The driver file
 571 #
 572 #   @retval     GuidValue   if the CName is found in any given package
 573 #   @retval     None        if the CName is not found in all given packages
 574 #
 575 def GuidValue(CName, PackageList, Inffile = None):
 576     for P in PackageList:
 577         GuidKeys = P.Guids.keys()
 578         if Inffile and P._PrivateGuids:
 579             if not Inffile.startswith(P.MetaFile.Dir):
 580                 GuidKeys = [x for x in P.Guids if x not in P._PrivateGuids]
 581         if CName in GuidKeys:
 582             return P.Guids[CName]
 583     return None
 584
 585 ## A string template class
 586 #
 587 #  This class implements a template for string replacement. A string template
 588 #  looks like following
 589 #
 590 #       ${BEGIN} other_string ${placeholder_name} other_string ${END}
 591 #
 592 #  The string between ${BEGIN} and ${END} will be repeated as many times as the
 593 #  length of "placeholder_name", which is a list passed through a dict. The
 594 #  "placeholder_name" is the key name of the dict. The ${BEGIN} and ${END} can
 595 #  be not used and, in this case, the "placeholder_name" must not a list and it
 596 #  will just be replaced once.
 597 #
 598 class TemplateString(object):
 599     _REPEAT_START_FLAG = "BEGIN"
 600     _REPEAT_END_FLAG = "END"
 601
 602     class Section(object):
 603         _LIST_TYPES = [type([]), type(set()), type((0,))]
 604
 605         def __init__(self, TemplateSection, PlaceHolderList):
 606             self._Template = TemplateSection
 607             self._PlaceHolderList = []
 608
 609             # Split the section into sub-sections according to the position of placeholders
 610             if PlaceHolderList:
 611                 self._SubSectionList = []
 612                 SubSectionStart = 0
 613                 #
 614                 # The placeholders passed in must be in the format of
 615                 #
 616                 #   PlaceHolderName, PlaceHolderStartPoint, PlaceHolderEndPoint
 617                 #
 618                 for PlaceHolder, Start, End in PlaceHolderList:
 619                     self._SubSectionList.append(TemplateSection[SubSectionStart:Start])
 620                     self._SubSectionList.append(TemplateSection[Start:End])
 621                     self._PlaceHolderList.append(PlaceHolder)
 622                     SubSectionStart = End
 623                 if SubSectionStart < len(TemplateSection):
 624                     self._SubSectionList.append(TemplateSection[SubSectionStart:])
 625             else:
 626                 self._SubSectionList = [TemplateSection]
 627
 628         def __str__(self):
 629             return self._Template + " : " + str(self._PlaceHolderList)
 630
 631         def Instantiate(self, PlaceHolderValues):
 632             RepeatTime = -1
 633             RepeatPlaceHolders = {}
 634             NonRepeatPlaceHolders = {}
 635
 636             for PlaceHolder in self._PlaceHolderList:
 637                 if PlaceHolder not in PlaceHolderValues:
 638                     continue
 639                 Value = PlaceHolderValues[PlaceHolder]
 640                 if type(Value) in self._LIST_TYPES:
 641                     if RepeatTime < 0:
 642                         RepeatTime = len(Value)
 643                     elif RepeatTime != len(Value):
 644                         EdkLogger.error(
 645                                     "TemplateString",
 646                                     PARAMETER_INVALID,
 647                                     "${%s} has different repeat time from others!" % PlaceHolder,
 648                                     ExtraData=str(self._Template)
 649                                     )
 650                     RepeatPlaceHolders["${%s}" % PlaceHolder] = Value
 651                 else:
 652                     NonRepeatPlaceHolders["${%s}" % PlaceHolder] = Value
 653
 654             if NonRepeatPlaceHolders:
 655                 StringList = []
 656                 for S in self._SubSectionList:
 657                     if S not in NonRepeatPlaceHolders:
 658                         StringList.append(S)
 659                     else:
 660                         StringList.append(str(NonRepeatPlaceHolders[S]))
 661             else:
 662                 StringList = self._SubSectionList
 663
 664             if RepeatPlaceHolders:
 665                 TempStringList = []
 666                 for Index in range(RepeatTime):
 667                     for S in StringList:
 668                         if S not in RepeatPlaceHolders:
 669                             TempStringList.append(S)
 670                         else:
 671                             TempStringList.append(str(RepeatPlaceHolders[S][Index]))
 672                 StringList = TempStringList
 673
 674             return "".join(StringList)
 675
 676     ## Constructor
 677     def __init__(self, Template=None):
 678         self.String = []
 679         self.IsBinary = False
 680         self._Template = Template
 681         self._TemplateSectionList = self._Parse(Template)
 682
 683     ## str() operator
 684     #
 685     #   @retval     string  The string replaced
 686     #
 687     def __str__(self):
 688         return "".join(self.String)
 689
 690     ## Split the template string into fragments per the ${BEGIN} and ${END} flags
 691     #
 692     #   @retval     list    A list of TemplateString.Section objects
 693     #
 694     def _Parse(self, Template):
 695         SectionStart = 0
 696         SearchFrom = 0
 697         MatchEnd = 0
 698         PlaceHolderList = []
 699         TemplateSectionList = []
 700         while Template:
 701             MatchObj = gPlaceholderPattern.search(Template, SearchFrom)
 702             if not MatchObj:
 703                 if MatchEnd <= len(Template):
 704                     TemplateSection = TemplateString.Section(Template[SectionStart:], PlaceHolderList)
 705                     TemplateSectionList.append(TemplateSection)
 706                 break
 707
 708             MatchString = MatchObj.group(1)
 709             MatchStart = MatchObj.start()
 710             MatchEnd = MatchObj.end()
 711
 712             if MatchString == self._REPEAT_START_FLAG:
 713                 if MatchStart > SectionStart:
 714                     TemplateSection = TemplateString.Section(Template[SectionStart:MatchStart], PlaceHolderList)
 715                     TemplateSectionList.append(TemplateSection)
 716                 SectionStart = MatchEnd
 717                 PlaceHolderList = []
 718             elif MatchString == self._REPEAT_END_FLAG:
 719                 TemplateSection = TemplateString.Section(Template[SectionStart:MatchStart], PlaceHolderList)
 720                 TemplateSectionList.append(TemplateSection)
 721                 SectionStart = MatchEnd
 722                 PlaceHolderList = []
 723             else:
 724                 PlaceHolderList.append((MatchString, MatchStart - SectionStart, MatchEnd - SectionStart))
 725             SearchFrom = MatchEnd
 726         return TemplateSectionList
 727
 728     ## Replace the string template with dictionary of placeholders and append it to previous one
 729     #
 730     #   @param      AppendString    The string template to append
 731     #   @param      Dictionary      The placeholder dictionaries
 732     #
 733     def Append(self, AppendString, Dictionary=None):
 734         if Dictionary:
 735             SectionList = self._Parse(AppendString)
 736             self.String.append( "".join(S.Instantiate(Dictionary) for S in SectionList))
 737         else:
 738             if isinstance(AppendString,list):
 739                 self.String.extend(AppendString)
 740             else:
 741                 self.String.append(AppendString)
 742
 743     ## Replace the string template with dictionary of placeholders
 744     #
 745     #   @param      Dictionary      The placeholder dictionaries
 746     #
 747     #   @retval     str             The string replaced with placeholder values
 748     #
 749     def Replace(self, Dictionary=None):
 750         return "".join(S.Instantiate(Dictionary) for S in self._TemplateSectionList)
 751
 752 ## Progress indicator class
 753 #
 754 #  This class makes use of thread to print progress on console.
 755 #
 756 class Progressor:
 757     # for avoiding deadloop
 758     _StopFlag = None
 759     _ProgressThread = None
 760     _CheckInterval = 0.25
 761
 762     ## Constructor
 763     #
 764     #   @param      OpenMessage     The string printed before progress charaters
 765     #   @param      CloseMessage    The string printed after progress charaters
 766     #   @param      ProgressChar    The charater used to indicate the progress
 767     #   @param      Interval        The interval in seconds between two progress charaters
 768     #
 769     def __init__(self, OpenMessage="", CloseMessage="", ProgressChar='.', Interval=1.0):
 770         self.PromptMessage = OpenMessage
 771         self.CodaMessage = CloseMessage
 772         self.ProgressChar = ProgressChar
 773         self.Interval = Interval
 774         if Progressor._StopFlag is None:
 775             Progressor._StopFlag = threading.Event()
 776
 777     ## Start to print progress charater
 778     #
 779     #   @param      OpenMessage     The string printed before progress charaters
 780     #
 781     def Start(self, OpenMessage=None):
 782         if OpenMessage is not None:
 783             self.PromptMessage = OpenMessage
 784         Progressor._StopFlag.clear()
 785         if Progressor._ProgressThread is None:
 786             Progressor._ProgressThread = threading.Thread(target=self._ProgressThreadEntry)
 787             Progressor._ProgressThread.setDaemon(False)
 788             Progressor._ProgressThread.start()
 789
 790     ## Stop printing progress charater
 791     #
 792     #   @param      CloseMessage    The string printed after progress charaters
 793     #
 794     def Stop(self, CloseMessage=None):
 795         OriginalCodaMessage = self.CodaMessage
 796         if CloseMessage is not None:
 797             self.CodaMessage = CloseMessage
 798         self.Abort()
 799         self.CodaMessage = OriginalCodaMessage
 800
 801     ## Thread entry method
 802     def _ProgressThreadEntry(self):
 803         sys.stdout.write(self.PromptMessage + " ")
 804         sys.stdout.flush()
 805         TimeUp = 0.0
 806         while not Progressor._StopFlag.isSet():
 807             if TimeUp <= 0.0:
 808                 sys.stdout.write(self.ProgressChar)
 809                 sys.stdout.flush()
 810                 TimeUp = self.Interval
 811             time.sleep(self._CheckInterval)
 812             TimeUp -= self._CheckInterval
 813         sys.stdout.write(" " + self.CodaMessage + "\n")
 814         sys.stdout.flush()
 815
 816     ## Abort the progress display
 817     @staticmethod
 818     def Abort():
 819         if Progressor._StopFlag is not None:
 820             Progressor._StopFlag.set()
 821         if Progressor._ProgressThread is not None:
 822             Progressor._ProgressThread.join()
 823             Progressor._ProgressThread = None
 824
 825
 826 ## Dictionary using prioritized list as key
 827 #
 828 class tdict:
 829     _ListType = type([])
 830     _TupleType = type(())
 831     _Wildcard = 'COMMON'
 832     _ValidWildcardList = ['COMMON', 'DEFAULT', 'ALL', TAB_STAR, 'PLATFORM']
 833
 834     def __init__(self, _Single_=False, _Level_=2):
 835         self._Level_ = _Level_
 836         self.data = {}
 837         self._Single_ = _Single_
 838
 839     # =[] operator
 840     def __getitem__(self, key):
 841         KeyType = type(key)
 842         RestKeys = None
 843         if KeyType == self._ListType or KeyType == self._TupleType:
 844             FirstKey = key[0]
 845             if len(key) > 1:
 846                 RestKeys = key[1:]
 847             elif self._Level_ > 1:
 848                 RestKeys = [self._Wildcard for i in range(0, self._Level_ - 1)]
 849         else:
 850             FirstKey = key
 851             if self._Level_ > 1:
 852                 RestKeys = [self._Wildcard for i in range(0, self._Level_ - 1)]
 853
 854         if FirstKey is None or str(FirstKey).upper() in self._ValidWildcardList:
 855             FirstKey = self._Wildcard
 856
 857         if self._Single_:
 858             return self._GetSingleValue(FirstKey, RestKeys)
 859         else:
 860             return self._GetAllValues(FirstKey, RestKeys)
 861
 862     def _GetSingleValue(self, FirstKey, RestKeys):
 863         Value = None
 864         #print "%s-%s" % (FirstKey, self._Level_) ,
 865         if self._Level_ > 1:
 866             if FirstKey == self._Wildcard:
 867                 if FirstKey in self.data:
 868                     Value = self.data[FirstKey][RestKeys]
 869                 if Value is None:
 870                     for Key in self.data:
 871                         Value = self.data[Key][RestKeys]
 872                         if Value is not None: break
 873             else:
 874                 if FirstKey in self.data:
 875                     Value = self.data[FirstKey][RestKeys]
 876                 if Value is None and self._Wildcard in self.data:
 877                     #print "Value=None"
 878                     Value = self.data[self._Wildcard][RestKeys]
 879         else:
 880             if FirstKey == self._Wildcard:
 881                 if FirstKey in self.data:
 882                     Value = self.data[FirstKey]
 883                 if Value is None:
 884                     for Key in self.data:
 885                         Value = self.data[Key]
 886                         if Value is not None: break
 887             else:
 888                 if FirstKey in self.data:
 889                     Value = self.data[FirstKey]
 890                 elif self._Wildcard in self.data:
 891                     Value = self.data[self._Wildcard]
 892         return Value
 893
 894     def _GetAllValues(self, FirstKey, RestKeys):
 895         Value = []
 896         if self._Level_ > 1:
 897             if FirstKey == self._Wildcard:
 898                 for Key in self.data:
 899                     Value += self.data[Key][RestKeys]
 900             else:
 901                 if FirstKey in self.data:
 902                     Value += self.data[FirstKey][RestKeys]
 903                 if self._Wildcard in self.data:
 904                     Value += self.data[self._Wildcard][RestKeys]
 905         else:
 906             if FirstKey == self._Wildcard:
 907                 for Key in self.data:
 908                     Value.append(self.data[Key])
 909             else:
 910                 if FirstKey in self.data:
 911                     Value.append(self.data[FirstKey])
 912                 if self._Wildcard in self.data:
 913                     Value.append(self.data[self._Wildcard])
 914         return Value
 915
 916     ## []= operator
 917     def __setitem__(self, key, value):
 918         KeyType = type(key)
 919         RestKeys = None
 920         if KeyType == self._ListType or KeyType == self._TupleType:
 921             FirstKey = key[0]
 922             if len(key) > 1:
 923                 RestKeys = key[1:]
 924             else:
 925                 RestKeys = [self._Wildcard for i in range(0, self._Level_ - 1)]
 926         else:
 927             FirstKey = key
 928             if self._Level_ > 1:
 929                 RestKeys = [self._Wildcard for i in range(0, self._Level_ - 1)]
 930
 931         if FirstKey in self._ValidWildcardList:
 932             FirstKey = self._Wildcard
 933
 934         if FirstKey not in self.data and self._Level_ > 0:
 935             self.data[FirstKey] = tdict(self._Single_, self._Level_ - 1)
 936
 937         if self._Level_ > 1:
 938             self.data[FirstKey][RestKeys] = value
 939         else:
 940             self.data[FirstKey] = value
 941
 942     def SetGreedyMode(self):
 943         self._Single_ = False
 944         if self._Level_ > 1:
 945             for Key in self.data:
 946                 self.data[Key].SetGreedyMode()
 947
 948     def SetSingleMode(self):
 949         self._Single_ = True
 950         if self._Level_ > 1:
 951             for Key in self.data:
 952                 self.data[Key].SetSingleMode()
 953
 954     def GetKeys(self, KeyIndex=0):
 955         assert KeyIndex >= 0
 956         if KeyIndex == 0:
 957             return set(self.data.keys())
 958         else:
 959             keys = set()
 960             for Key in self.data:
 961                 keys |= self.data[Key].GetKeys(KeyIndex - 1)
 962             return keys
 963
 964 def AnalyzePcdExpression(Setting):
 965     RanStr = ''.join(sample(string.ascii_letters + string.digits, 8))
 966     Setting = Setting.replace('\\\\', RanStr).strip()
 967     # There might be escaped quote in a string: \", \\\" , \', \\\'
 968     Data = Setting
 969     # There might be '|' in string and in ( ... | ... ), replace it with '-'
 970     NewStr = ''
 971     InSingleQuoteStr = False
 972     InDoubleQuoteStr = False
 973     Pair = 0
 974     for Index, ch in enumerate(Data):
 975         if ch == '"' and not InSingleQuoteStr:
 976             if Data[Index - 1] != '\\':
 977                 InDoubleQuoteStr = not InDoubleQuoteStr
 978         elif ch == "'" and not InDoubleQuoteStr:
 979             if Data[Index - 1] != '\\':
 980                 InSingleQuoteStr = not InSingleQuoteStr
 981         elif ch == '(' and not (InSingleQuoteStr or InDoubleQuoteStr):
 982             Pair += 1
 983         elif ch == ')' and not (InSingleQuoteStr or InDoubleQuoteStr):
 984             Pair -= 1
 985
 986         if (Pair > 0 or InSingleQuoteStr or InDoubleQuoteStr) and ch == TAB_VALUE_SPLIT:
 987             NewStr += '-'
 988         else:
 989             NewStr += ch
 990     FieldList = []
 991     StartPos = 0
 992     while True:
 993         Pos = NewStr.find(TAB_VALUE_SPLIT, StartPos)
 994         if Pos < 0:
 995             FieldList.append(Setting[StartPos:].strip())
 996             break
 997         FieldList.append(Setting[StartPos:Pos].strip())
 998         StartPos = Pos + 1
 999     for i, ch in enumerate(FieldList):
1000         if RanStr in ch:
1001             FieldList[i] = ch.replace(RanStr,'\\\\')
1002     return FieldList
1003
1004 def ParseFieldValue (Value):
1005     def ParseDevPathValue (Value):
1006         if '\\' in Value:
1007             Value.replace('\\', '/').replace(' ', '')
1008
1009         Cmd = 'DevicePath ' + '"' + Value + '"'
1010         try:
1011             p = subprocess.Popen(Cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
1012             out, err = p.communicate()
1013         except Exception as X:
1014             raise BadExpression("DevicePath: %s" % (str(X)) )
1015         finally:
1016             subprocess._cleanup()
1017             p.stdout.close()
1018             p.stderr.close()
1019         if err:
1020             raise BadExpression("DevicePath: %s" % str(err))
1021         Size = len(out.split())
1022         out = ','.join(out.split())
1023         return '{' + out + '}', Size
1024
1025     if "{CODE(" in Value:
1026         return Value, len(Value.split(","))
1027     if isinstance(Value, type(0)):
1028         return Value, (Value.bit_length() + 7) / 8
1029     if not isinstance(Value, type('')):
1030         raise BadExpression('Type %s is %s' %(Value, type(Value)))
1031     Value = Value.strip()
1032     if Value.startswith(TAB_UINT8) and Value.endswith(')'):
1033         Value, Size = ParseFieldValue(Value.split('(', 1)[1][:-1])
1034         if Size > 1:
1035             raise BadExpression('Value (%s) Size larger than %d' %(Value, Size))
1036         return Value, 1
1037     if Value.startswith(TAB_UINT16) and Value.endswith(')'):
1038         Value, Size = ParseFieldValue(Value.split('(', 1)[1][:-1])
1039         if Size > 2:
1040             raise BadExpression('Value (%s) Size larger than %d' %(Value, Size))
1041         return Value, 2
1042     if Value.startswith(TAB_UINT32) and Value.endswith(')'):
1043         Value, Size = ParseFieldValue(Value.split('(', 1)[1][:-1])
1044         if Size > 4:
1045             raise BadExpression('Value (%s) Size larger than %d' %(Value, Size))
1046         return Value, 4
1047     if Value.startswith(TAB_UINT64) and Value.endswith(')'):
1048         Value, Size = ParseFieldValue(Value.split('(', 1)[1][:-1])
1049         if Size > 8:
1050             raise BadExpression('Value (%s) Size larger than %d' % (Value, Size))
1051         return Value, 8
1052     if Value.startswith(TAB_GUID) and Value.endswith(')'):
1053         Value = Value.split('(', 1)[1][:-1].strip()
1054         if Value[0] == '{' and Value[-1] == '}':
1055             TmpValue = GuidStructureStringToGuidString(Value)
1056             if not TmpValue:
1057                 raise BadExpression("Invalid GUID value string %s" % Value)
1058             Value = TmpValue
1059         if Value[0] == '"' and Value[-1] == '"':
1060             Value = Value[1:-1]
1061         try:
1062             Value = "'" + uuid.UUID(Value).bytes_le + "'"
1063         except ValueError as Message:
1064             raise BadExpression(Message)
1065         Value, Size = ParseFieldValue(Value)
1066         return Value, 16
1067     if Value.startswith('L"') and Value.endswith('"'):
1068         # Unicode String
1069         # translate escape character
1070         Value = Value[1:]
1071         try:
1072             Value = eval(Value)
1073         except:
1074             Value = Value[1:-1]
1075         List = list(Value)
1076         List.reverse()
1077         Value = 0
1078         for Char in List:
1079             Value = (Value << 16) | ord(Char)
1080         return Value, (len(List) + 1) * 2
1081     if Value.startswith('"') and Value.endswith('"'):
1082         # ASCII String
1083         # translate escape character
1084         try:
1085             Value = eval(Value)
1086         except:
1087             Value = Value[1:-1]
1088         List = list(Value)
1089         List.reverse()
1090         Value = 0
1091         for Char in List:
1092             Value = (Value << 8) | ord(Char)
1093         return Value, len(List) + 1
1094     if Value.startswith("L'") and Value.endswith("'"):
1095         # Unicode Character Constant
1096         # translate escape character
1097         Value = Value[1:]
1098         try:
1099             Value = eval(Value)
1100         except:
1101             Value = Value[1:-1]
1102         List = list(Value)
1103         if len(List) == 0:
1104             raise BadExpression('Length %s is %s' % (Value, len(List)))
1105         List.reverse()
1106         Value = 0
1107         for Char in List:
1108             Value = (Value << 16) | ord(Char)
1109         return Value, len(List) * 2
1110     if Value.startswith("'") and Value.endswith("'"):
1111         # Character constant
1112         # translate escape character
1113         try:
1114             Value = eval(Value)
1115         except:
1116             Value = Value[1:-1]
1117         List = list(Value)
1118         if len(List) == 0:
1119             raise BadExpression('Length %s is %s' % (Value, len(List)))
1120         List.reverse()
1121         Value = 0
1122         for Char in List:
1123             Value = (Value << 8) | ord(Char)
1124         return Value, len(List)
1125     if Value.startswith('{') and Value.endswith('}'):
1126         # Byte array
1127         Value = Value[1:-1]
1128         List = [Item.strip() for Item in Value.split(',')]
1129         List.reverse()
1130         Value = 0
1131         RetSize = 0
1132         for Item in List:
1133             ItemValue, Size = ParseFieldValue(Item)
1134             RetSize += Size
1135             for I in range(Size):
1136                 Value = (Value << 8) | ((ItemValue >> 8 * I) & 0xff)
1137         return Value, RetSize
1138     if Value.startswith('DEVICE_PATH(') and Value.endswith(')'):
1139         Value = Value.replace("DEVICE_PATH(", '').rstrip(')')
1140         Value = Value.strip().strip('"')
1141         return ParseDevPathValue(Value)
1142     if Value.lower().startswith('0x'):
1143         try:
1144             Value = int(Value, 16)
1145         except:
1146             raise BadExpression("invalid hex value: %s" % Value)
1147         if Value == 0:
1148             return 0, 1
1149         return Value, (Value.bit_length() + 7) / 8
1150     if Value[0].isdigit():
1151         Value = int(Value, 10)
1152         if Value == 0:
1153             return 0, 1
1154         return Value, (Value.bit_length() + 7) / 8
1155     if Value.lower() == 'true':
1156         return 1, 1
1157     if Value.lower() == 'false':
1158         return 0, 1
1159     return Value, 1
1160
1161 ## AnalyzeDscPcd
1162 #
1163 #  Analyze DSC PCD value, since there is no data type info in DSC
1164 #  This function is used to match functions (AnalyzePcdData) used for retrieving PCD value from database
1165 #  1. Feature flag: TokenSpace.PcdCName|PcdValue
1166 #  2. Fix and Patch:TokenSpace.PcdCName|PcdValue[|VOID*[|MaxSize]]
1167 #  3. Dynamic default:
1168 #     TokenSpace.PcdCName|PcdValue[|VOID*[|MaxSize]]
1169 #     TokenSpace.PcdCName|PcdValue
1170 #  4. Dynamic VPD:
1171 #     TokenSpace.PcdCName|VpdOffset[|VpdValue]
1172 #     TokenSpace.PcdCName|VpdOffset[|MaxSize[|VpdValue]]
1173 #  5. Dynamic HII:
1174 #     TokenSpace.PcdCName|HiiString|VariableGuid|VariableOffset[|HiiValue]
1175 #  PCD value needs to be located in such kind of string, and the PCD value might be an expression in which
1176 #    there might have "|" operator, also in string value.
1177 #
1178 #  @param Setting: String contain information described above with "TokenSpace.PcdCName|" stripped
1179 #  @param PcdType: PCD type: feature, fixed, dynamic default VPD HII
1180 #  @param DataType: The datum type of PCD: VOID*, UNIT, BOOL
1181 #  @retval:
1182 #    ValueList: A List contain fields described above
1183 #    IsValid:   True if conforming EBNF, otherwise False
1184 #    Index:     The index where PcdValue is in ValueList
1185 #
1186 def AnalyzeDscPcd(Setting, PcdType, DataType=''):
1187     FieldList = AnalyzePcdExpression(Setting)
1188
1189     IsValid = True
1190     if PcdType in (MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT):
1191         Value = FieldList[0]
1192         Size = ''
1193         if len(FieldList) > 1 and FieldList[1]:
1194             DataType = FieldList[1]
1195             if FieldList[1] != TAB_VOID and StructPattern.match(FieldList[1]) is None:
1196                 IsValid = False
1197         if len(FieldList) > 2:
1198             Size = FieldList[2]
1199         if IsValid:
1200             if DataType == "":
1201                 IsValid = (len(FieldList) <= 1)
1202             else:
1203                 IsValid = (len(FieldList) <= 3)
1204
1205         if Size:
1206             try:
1207                 int(Size, 16) if Size.upper().startswith("0X") else int(Size)
1208             except:
1209                 IsValid = False
1210                 Size = -1
1211         return [str(Value), DataType, str(Size)], IsValid, 0
1212     elif PcdType == MODEL_PCD_FEATURE_FLAG:
1213         Value = FieldList[0]
1214         Size = ''
1215         IsValid = (len(FieldList) <= 1)
1216         return [Value, DataType, str(Size)], IsValid, 0
1217     elif PcdType in (MODEL_PCD_DYNAMIC_VPD, MODEL_PCD_DYNAMIC_EX_VPD):
1218         VpdOffset = FieldList[0]
1219         Value = Size = ''
1220         if not DataType == TAB_VOID:
1221             if len(FieldList) > 1:
1222                 Value = FieldList[1]
1223         else:
1224             if len(FieldList) > 1:
1225                 Size = FieldList[1]
1226             if len(FieldList) > 2:
1227                 Value = FieldList[2]
1228         if DataType == "":
1229             IsValid = (len(FieldList) <= 1)
1230         else:
1231             IsValid = (len(FieldList) <= 3)
1232         if Size:
1233             try:
1234                 int(Size, 16) if Size.upper().startswith("0X") else int(Size)
1235             except:
1236                 IsValid = False
1237                 Size = -1
1238         return [VpdOffset, str(Size), Value], IsValid, 2
1239     elif PcdType in (MODEL_PCD_DYNAMIC_HII, MODEL_PCD_DYNAMIC_EX_HII):
1240         IsValid = (3 <= len(FieldList) <= 5)
1241         HiiString = FieldList[0]
1242         Guid = Offset = Value = Attribute = ''
1243         if len(FieldList) > 1:
1244             Guid = FieldList[1]
1245         if len(FieldList) > 2:
1246             Offset = FieldList[2]
1247         if len(FieldList) > 3:
1248             Value = FieldList[3]
1249         if len(FieldList) > 4:
1250             Attribute = FieldList[4]
1251         return [HiiString, Guid, Offset, Value, Attribute], IsValid, 3
1252     return [], False, 0
1253
1254 ## AnalyzePcdData
1255 #
1256 #  Analyze the pcd Value, Datum type and TokenNumber.
1257 #  Used to avoid split issue while the value string contain "|" character
1258 #
1259 #  @param[in] Setting:  A String contain value/datum type/token number information;
1260 #
1261 #  @retval   ValueList: A List contain value, datum type and toke number.
1262 #
1263 def AnalyzePcdData(Setting):
1264     ValueList = ['', '', '']
1265
1266     ValueRe = re.compile(r'^\s*L?\".*\|.*\"')
1267     PtrValue = ValueRe.findall(Setting)
1268
1269     ValueUpdateFlag = False
1270
1271     if len(PtrValue) >= 1:
1272         Setting = re.sub(ValueRe, '', Setting)
1273         ValueUpdateFlag = True
1274
1275     TokenList = Setting.split(TAB_VALUE_SPLIT)
1276     ValueList[0:len(TokenList)] = TokenList
1277
1278     if ValueUpdateFlag:
1279         ValueList[0] = PtrValue[0]
1280
1281     return ValueList
1282
1283 ## check format of PCD value against its the datum type
1284 #
1285 # For PCD value setting
1286 #
1287 def CheckPcdDatum(Type, Value):
1288     if Type == TAB_VOID:
1289         ValueRe = re.compile(r'\s*L?\".*\"\s*$')
1290         if not (((Value.startswith('L"') or Value.startswith('"')) and Value.endswith('"'))
1291                 or (Value.startswith('{') and Value.endswith('}')) or (Value.startswith("L'") or Value.startswith("'") and Value.endswith("'"))
1292                ):
1293             return False, "Invalid value [%s] of type [%s]; must be in the form of {...} for array"\
1294                           ", \"...\" or \'...\' for string, L\"...\" or L\'...\' for unicode string" % (Value, Type)
1295         elif ValueRe.match(Value):
1296             # Check the chars in UnicodeString or CString is printable
1297             if Value.startswith("L"):
1298                 Value = Value[2:-1]
1299             else:
1300                 Value = Value[1:-1]
1301             Printset = set(string.printable)
1302             Printset.remove(TAB_PRINTCHAR_VT)
1303             Printset.add(TAB_PRINTCHAR_BS)
1304             Printset.add(TAB_PRINTCHAR_NUL)
1305             if not set(Value).issubset(Printset):
1306                 PrintList = sorted(Printset)
1307                 return False, "Invalid PCD string value of type [%s]; must be printable chars %s." % (Type, PrintList)
1308     elif Type == 'BOOLEAN':
1309         if Value not in ['TRUE', 'True', 'true', '0x1', '0x01', '1', 'FALSE', 'False', 'false', '0x0', '0x00', '0']:
1310             return False, "Invalid value [%s] of type [%s]; must be one of TRUE, True, true, 0x1, 0x01, 1"\
1311                           ", FALSE, False, false, 0x0, 0x00, 0" % (Value, Type)
1312     elif Type in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64]:
1313         if Value and int(Value, 0) < 0:
1314             return False, "PCD can't be set to negative value[%s] for datum type [%s]" % (Value, Type)
1315         try:
1316             Value = long(Value, 0)
1317             if Value > MAX_VAL_TYPE[Type]:
1318                 return False, "Too large PCD value[%s] for datum type [%s]" % (Value, Type)
1319         except:
1320             return False, "Invalid value [%s] of type [%s];"\
1321                           " must be a hexadecimal, decimal or octal in C language format." % (Value, Type)
1322     else:
1323         return True, "StructurePcd"
1324
1325     return True, ""
1326
1327 def CommonPath(PathList):
1328     P1 = min(PathList).split(os.path.sep)
1329     P2 = max(PathList).split(os.path.sep)
1330     for Index in range(min(len(P1), len(P2))):
1331         if P1[Index] != P2[Index]:
1332             return os.path.sep.join(P1[:Index])
1333     return os.path.sep.join(P1)
1334
1335 class PathClass(object):
1336     def __init__(self, File='', Root='', AlterRoot='', Type='', IsBinary=False,
1337                  Arch='COMMON', ToolChainFamily='', Target='', TagName='', ToolCode=''):
1338         self.Arch = Arch
1339         self.File = str(File)
1340         if os.path.isabs(self.File):
1341             self.Root = ''
1342             self.AlterRoot = ''
1343         else:
1344             self.Root = str(Root)
1345             self.AlterRoot = str(AlterRoot)
1346
1347         # Remove any '.' and '..' in path
1348         if self.Root:
1349             self.Root = mws.getWs(self.Root, self.File)
1350             self.Path = os.path.normpath(os.path.join(self.Root, self.File))
1351             self.Root = os.path.normpath(CommonPath([self.Root, self.Path]))
1352             # eliminate the side-effect of 'C:'
1353             if self.Root[-1] == ':':
1354                 self.Root += os.path.sep
1355             # file path should not start with path separator
1356             if self.Root[-1] == os.path.sep:
1357                 self.File = self.Path[len(self.Root):]
1358             else:
1359                 self.File = self.Path[len(self.Root) + 1:]
1360         else:
1361             self.Path = os.path.normpath(self.File)
1362
1363         self.SubDir, self.Name = os.path.split(self.File)
1364         self.BaseName, self.Ext = os.path.splitext(self.Name)
1365
1366         if self.Root:
1367             if self.SubDir:
1368                 self.Dir = os.path.join(self.Root, self.SubDir)
1369             else:
1370                 self.Dir = self.Root
1371         else:
1372             self.Dir = self.SubDir
1373
1374         if IsBinary:
1375             self.Type = Type
1376         else:
1377             self.Type = self.Ext.lower()
1378
1379         self.IsBinary = IsBinary
1380         self.Target = Target
1381         self.TagName = TagName
1382         self.ToolCode = ToolCode
1383         self.ToolChainFamily = ToolChainFamily
1384
1385     ## Convert the object of this class to a string
1386     #
1387     #  Convert member Path of the class to a string
1388     #
1389     #  @retval string Formatted String
1390     #
1391     def __str__(self):
1392         return self.Path
1393
1394     ## Override __eq__ function
1395     #
1396     # Check whether PathClass are the same
1397     #
1398     # @retval False The two PathClass are different
1399     # @retval True  The two PathClass are the same
1400     #
1401     def __eq__(self, Other):
1402         return self.Path == str(Other)
1403
1404     ## Override __cmp__ function
1405     #
1406     # Customize the comparsion operation of two PathClass
1407     #
1408     # @retval 0     The two PathClass are different
1409     # @retval -1    The first PathClass is less than the second PathClass
1410     # @retval 1     The first PathClass is Bigger than the second PathClass
1411     def __cmp__(self, Other):
1412         OtherKey = str(Other)
1413
1414         SelfKey = self.Path
1415         if SelfKey == OtherKey:
1416             return 0
1417         elif SelfKey > OtherKey:
1418             return 1
1419         else:
1420             return -1
1421
1422     ## Override __hash__ function
1423     #
1424     # Use Path as key in hash table
1425     #
1426     # @retval string Key for hash table
1427     #
1428     def __hash__(self):
1429         return hash(self.Path)
1430
1431     @cached_property
1432     def Key(self):
1433         return self.Path.upper()
1434
1435     @property
1436     def TimeStamp(self):
1437         return os.stat(self.Path)[8]
1438
1439     def Validate(self, Type='', CaseSensitive=True):
1440         def RealPath2(File, Dir='', OverrideDir=''):
1441             NewFile = None
1442             if OverrideDir:
1443                 NewFile = GlobalData.gAllFiles[os.path.normpath(os.path.join(OverrideDir, File))]
1444                 if NewFile:
1445                     if OverrideDir[-1] == os.path.sep:
1446                         return NewFile[len(OverrideDir):], NewFile[0:len(OverrideDir)]
1447                     else:
1448                         return NewFile[len(OverrideDir) + 1:], NewFile[0:len(OverrideDir)]
1449             if GlobalData.gAllFiles:
1450                 NewFile = GlobalData.gAllFiles[os.path.normpath(os.path.join(Dir, File))]
1451             if not NewFile:
1452                 NewFile = os.path.normpath(os.path.join(Dir, File))
1453                 if not os.path.exists(NewFile):
1454                     return None, None
1455             if NewFile:
1456                 if Dir:
1457                     if Dir[-1] == os.path.sep:
1458                         return NewFile[len(Dir):], NewFile[0:len(Dir)]
1459                     else:
1460                         return NewFile[len(Dir) + 1:], NewFile[0:len(Dir)]
1461                 else:
1462                     return NewFile, ''
1463
1464             return None, None
1465
1466         if GlobalData.gCaseInsensitive:
1467             CaseSensitive = False
1468         if Type and Type.lower() != self.Type:
1469             return FILE_TYPE_MISMATCH, '%s (expect %s but got %s)' % (self.File, Type, self.Type)
1470
1471         RealFile, RealRoot = RealPath2(self.File, self.Root, self.AlterRoot)
1472         if not RealRoot and not RealFile:
1473             RealFile = self.File
1474             if self.AlterRoot:
1475                 RealFile = os.path.join(self.AlterRoot, self.File)
1476             elif self.Root:
1477                 RealFile = os.path.join(self.Root, self.File)
1478             if len (mws.getPkgPath()) == 0:
1479                 return FILE_NOT_FOUND, os.path.join(self.AlterRoot, RealFile)
1480             else:
1481                 return FILE_NOT_FOUND, "%s is not found in packages path:\n\t%s" % (self.File, '\n\t'.join(mws.getPkgPath()))
1482
1483         ErrorCode = 0
1484         ErrorInfo = ''
1485         if RealRoot != self.Root or RealFile != self.File:
1486             if CaseSensitive and (RealFile != self.File or (RealRoot != self.Root and RealRoot != self.AlterRoot)):
1487                 ErrorCode = FILE_CASE_MISMATCH
1488                 ErrorInfo = self.File + '\n\t' + RealFile + " [in file system]"
1489
1490             self.SubDir, self.Name = os.path.split(RealFile)
1491             self.BaseName, self.Ext = os.path.splitext(self.Name)
1492             if self.SubDir:
1493                 self.Dir = os.path.join(RealRoot, self.SubDir)
1494             else:
1495                 self.Dir = RealRoot
1496             self.File = RealFile
1497             self.Root = RealRoot
1498             self.Path = os.path.join(RealRoot, RealFile)
1499         return ErrorCode, ErrorInfo
1500
1501 ## Parse PE image to get the required PE informaion.
1502 #
1503 class PeImageClass():
1504     ## Constructor
1505     #
1506     #   @param  File FilePath of PeImage
1507     #
1508     def __init__(self, PeFile):
1509         self.FileName   = PeFile
1510         self.IsValid    = False
1511         self.Size       = 0
1512         self.EntryPoint = 0
1513         self.SectionAlignment  = 0
1514         self.SectionHeaderList = []
1515         self.ErrorInfo = ''
1516         try:
1517             PeObject = open(PeFile, 'rb')
1518         except:
1519             self.ErrorInfo = self.FileName + ' can not be found\n'
1520             return
1521         # Read DOS header
1522         ByteArray = array.array('B')
1523         ByteArray.fromfile(PeObject, 0x3E)
1524         ByteList = ByteArray.tolist()
1525         # DOS signature should be 'MZ'
1526         if self._ByteListToStr (ByteList[0x0:0x2]) != 'MZ':
1527             self.ErrorInfo = self.FileName + ' has no valid DOS signature MZ'
1528             return
1529
1530         # Read 4 byte PE Signature
1531         PeOffset = self._ByteListToInt(ByteList[0x3C:0x3E])
1532         PeObject.seek(PeOffset)
1533         ByteArray = array.array('B')
1534         ByteArray.fromfile(PeObject, 4)
1535         # PE signature should be 'PE\0\0'
1536         if ByteArray.tostring() != 'PE\0\0':
1537             self.ErrorInfo = self.FileName + ' has no valid PE signature PE00'
1538             return
1539
1540         # Read PE file header
1541         ByteArray = array.array('B')
1542         ByteArray.fromfile(PeObject, 0x14)
1543         ByteList = ByteArray.tolist()
1544         SecNumber = self._ByteListToInt(ByteList[0x2:0x4])
1545         if SecNumber == 0:
1546             self.ErrorInfo = self.FileName + ' has no section header'
1547             return
1548
1549         # Read PE optional header
1550         OptionalHeaderSize = self._ByteListToInt(ByteArray[0x10:0x12])
1551         ByteArray = array.array('B')
1552         ByteArray.fromfile(PeObject, OptionalHeaderSize)
1553         ByteList = ByteArray.tolist()
1554         self.EntryPoint       = self._ByteListToInt(ByteList[0x10:0x14])
1555         self.SectionAlignment = self._ByteListToInt(ByteList[0x20:0x24])
1556         self.Size             = self._ByteListToInt(ByteList[0x38:0x3C])
1557
1558         # Read each Section Header
1559         for Index in range(SecNumber):
1560             ByteArray = array.array('B')
1561             ByteArray.fromfile(PeObject, 0x28)
1562             ByteList = ByteArray.tolist()
1563             SecName  = self._ByteListToStr(ByteList[0:8])
1564             SecVirtualSize = self._ByteListToInt(ByteList[8:12])
1565             SecRawAddress  = self._ByteListToInt(ByteList[20:24])
1566             SecVirtualAddress = self._ByteListToInt(ByteList[12:16])
1567             self.SectionHeaderList.append((SecName, SecVirtualAddress, SecRawAddress, SecVirtualSize))
1568         self.IsValid = True
1569         PeObject.close()
1570
1571     def _ByteListToStr(self, ByteList):
1572         String = ''
1573         for index in range(len(ByteList)):
1574             if ByteList[index] == 0:
1575                 break
1576             String += chr(ByteList[index])
1577         return String
1578
1579     def _ByteListToInt(self, ByteList):
1580         Value = 0
1581         for index in range(len(ByteList) - 1, -1, -1):
1582             Value = (Value << 8) | int(ByteList[index])
1583         return Value
1584
1585 class DefaultStore():
1586     def __init__(self, DefaultStores ):
1587
1588         self.DefaultStores = DefaultStores
1589     def DefaultStoreID(self, DefaultStoreName):
1590         for key, value in self.DefaultStores.items():
1591             if value == DefaultStoreName:
1592                 return key
1593         return None
1594     def GetDefaultDefault(self):
1595         if not self.DefaultStores or "0" in self.DefaultStores:
1596             return "0", TAB_DEFAULT_STORES_DEFAULT
1597         else:
1598             minvalue = min(int(value_str) for value_str in self.DefaultStores)
1599             return (str(minvalue), self.DefaultStores[str(minvalue)])
1600     def GetMin(self, DefaultSIdList):
1601         if not DefaultSIdList:
1602             return TAB_DEFAULT_STORES_DEFAULT
1603         storeidset = {storeid for storeid, storename in self.DefaultStores.values() if storename in DefaultSIdList}
1604         if not storeidset:
1605             return ""
1606         minid = min(storeidset )
1607         for sid, name in self.DefaultStores.values():
1608             if sid == minid:
1609                 return name
1610
1611 class SkuClass():
1612     DEFAULT = 0
1613     SINGLE = 1
1614     MULTIPLE =2
1615
1616     def __init__(self,SkuIdentifier='', SkuIds=None):
1617         if SkuIds is None:
1618             SkuIds = {}
1619
1620         for SkuName in SkuIds:
1621             SkuId = SkuIds[SkuName][0]
1622             skuid_num = int(SkuId, 16) if SkuId.upper().startswith("0X") else int(SkuId)
1623             if skuid_num > 0xFFFFFFFFFFFFFFFF:
1624                 EdkLogger.error("build", PARAMETER_INVALID,
1625                             ExtraData = "SKU-ID [%s] value %s exceeds the max value of UINT64"
1626                                       % (SkuName, SkuId))
1627
1628         self.AvailableSkuIds = OrderedDict()
1629         self.SkuIdSet = []
1630         self.SkuIdNumberSet = []
1631         self.SkuData = SkuIds
1632         self._SkuInherit = {}
1633         self._SkuIdentifier = SkuIdentifier
1634         if SkuIdentifier == '' or SkuIdentifier is None:
1635             self.SkuIdSet = ['DEFAULT']
1636             self.SkuIdNumberSet = ['0U']
1637         elif SkuIdentifier == 'ALL':
1638             self.SkuIdSet = SkuIds.keys()
1639             self.SkuIdNumberSet = [num[0].strip() + 'U' for num in SkuIds.values()]
1640         else:
1641             r = SkuIdentifier.split('|')
1642             self.SkuIdSet=[(r[k].strip()).upper() for k in range(len(r))]
1643             k = None
1644             try:
1645                 self.SkuIdNumberSet = [SkuIds[k][0].strip() + 'U' for k in self.SkuIdSet]
1646             except Exception:
1647                 EdkLogger.error("build", PARAMETER_INVALID,
1648                             ExtraData = "SKU-ID [%s] is not supported by the platform. [Valid SKU-ID: %s]"
1649                                       % (k, " | ".join(SkuIds.keys())))
1650         for each in self.SkuIdSet:
1651             if each in SkuIds:
1652                 self.AvailableSkuIds[each] = SkuIds[each][0]
1653             else:
1654                 EdkLogger.error("build", PARAMETER_INVALID,
1655                             ExtraData="SKU-ID [%s] is not supported by the platform. [Valid SKU-ID: %s]"
1656                                       % (each, " | ".join(SkuIds.keys())))
1657         if self.SkuUsageType != SkuClass.SINGLE:
1658             self.AvailableSkuIds.update({'DEFAULT':0, 'COMMON':0})
1659         if self.SkuIdSet:
1660             GlobalData.gSkuids = (self.SkuIdSet)
1661             if 'COMMON' in GlobalData.gSkuids:
1662                 GlobalData.gSkuids.remove('COMMON')
1663             if self.SkuUsageType == self.SINGLE:
1664                 if len(GlobalData.gSkuids) != 1:
1665                     if 'DEFAULT' in GlobalData.gSkuids:
1666                         GlobalData.gSkuids.remove('DEFAULT')
1667             if GlobalData.gSkuids:
1668                 GlobalData.gSkuids.sort()
1669
1670     def GetNextSkuId(self, skuname):
1671         if not self._SkuInherit:
1672             self._SkuInherit = {}
1673             for item in self.SkuData.values():
1674                 self._SkuInherit[item[1]]=item[2] if item[2] else "DEFAULT"
1675         return self._SkuInherit.get(skuname, "DEFAULT")
1676
1677     def GetSkuChain(self, sku):
1678         if sku == "DEFAULT":
1679             return ["DEFAULT"]
1680         skulist = [sku]
1681         nextsku = sku
1682         while True:
1683             nextsku = self.GetNextSkuId(nextsku)
1684             skulist.append(nextsku)
1685             if nextsku == "DEFAULT":
1686                 break
1687         skulist.reverse()
1688         return skulist
1689     def SkuOverrideOrder(self):
1690         skuorderset = []
1691         for skuname in self.SkuIdSet:
1692             skuorderset.append(self.GetSkuChain(skuname))
1693
1694         skuorder = []
1695         for index in range(max(len(item) for item in skuorderset)):
1696             for subset in skuorderset:
1697                 if index > len(subset)-1:
1698                     continue
1699                 if subset[index] in skuorder:
1700                     continue
1701                 skuorder.append(subset[index])
1702
1703         return skuorder
1704
1705     @property
1706     def SkuUsageType(self):
1707         if self._SkuIdentifier.upper() == "ALL":
1708             return SkuClass.MULTIPLE
1709
1710         if len(self.SkuIdSet) == 1:
1711             if self.SkuIdSet[0] == 'DEFAULT':
1712                 return SkuClass.DEFAULT
1713             return SkuClass.SINGLE
1714         if len(self.SkuIdSet) == 2 and 'DEFAULT' in self.SkuIdSet:
1715             return SkuClass.SINGLE
1716         return SkuClass.MULTIPLE
1717
1718     def DumpSkuIdArrary(self):
1719         if self.SkuUsageType == SkuClass.SINGLE:
1720             return "{0x0}"
1721         ArrayStrList = []
1722         for skuname in self.AvailableSkuIds:
1723             if skuname == "COMMON":
1724                 continue
1725             while skuname != "DEFAULT":
1726                 ArrayStrList.append(hex(int(self.AvailableSkuIds[skuname])))
1727                 skuname = self.GetNextSkuId(skuname)
1728             ArrayStrList.append("0x0")
1729         return "{{{myList}}}".format(myList=",".join(ArrayStrList))
1730
1731     @property
1732     def AvailableSkuIdSet(self):
1733         return self.AvailableSkuIds
1734
1735     @property
1736     def SystemSkuId(self):
1737         if self.SkuUsageType == SkuClass.SINGLE:
1738             if len(self.SkuIdSet) == 1:
1739                 return self.SkuIdSet[0]
1740             else:
1741                 return self.SkuIdSet[0] if self.SkuIdSet[0] != 'DEFAULT' else self.SkuIdSet[1]
1742         else:
1743             return 'DEFAULT'
1744
1745 ##  Get the integer value from string like "14U" or integer like 2
1746 #
1747 #   @param      Input   The object that may be either a integer value or a string
1748 #
1749 #   @retval     Value    The integer value that the input represents
1750 #
1751 def GetIntegerValue(Input):
1752     if type(Input) in (int, long):
1753         return Input
1754     String = Input
1755     if String.endswith("U"):
1756         String = String[:-1]
1757     if String.endswith("ULL"):
1758         String = String[:-3]
1759     if String.endswith("LL"):
1760         String = String[:-2]
1761
1762     if String.startswith("0x") or String.startswith("0X"):
1763         return int(String, 16)
1764     elif String == '':
1765         return 0
1766     else:
1767         return int(String)
1768
1769 #
1770 # Pack a GUID (registry format) list into a buffer and return it
1771 #
1772 def PackGUID(Guid):
1773     return pack(PACK_PATTERN_GUID,
1774                 int(Guid[0], 16),
1775                 int(Guid[1], 16),
1776                 int(Guid[2], 16),
1777                 int(Guid[3][-4:-2], 16),
1778                 int(Guid[3][-2:], 16),
1779                 int(Guid[4][-12:-10], 16),
1780                 int(Guid[4][-10:-8], 16),
1781                 int(Guid[4][-8:-6], 16),
1782                 int(Guid[4][-6:-4], 16),
1783                 int(Guid[4][-4:-2], 16),
1784                 int(Guid[4][-2:], 16)
1785                 )
1786
1787 #
1788 # Pack a GUID (byte) list into a buffer and return it
1789 #
1790 def PackByteFormatGUID(Guid):
1791     return pack(PACK_PATTERN_GUID,
1792                 Guid[0],
1793                 Guid[1],
1794                 Guid[2],
1795                 Guid[3],
1796                 Guid[4],
1797                 Guid[5],
1798                 Guid[6],
1799                 Guid[7],
1800                 Guid[8],
1801                 Guid[9],
1802                 Guid[10],
1803                 )
1804
1805 ## DeepCopy dict/OrderedDict recusively
1806 #
1807 #   @param      ori_dict    a nested dict or ordereddict
1808 #
1809 #   @retval     new dict or orderdict
1810 #
1811 def CopyDict(ori_dict):
1812     dict_type = ori_dict.__class__
1813     if dict_type not in (dict,OrderedDict):
1814         return ori_dict
1815     new_dict = dict_type()
1816     for key in ori_dict:
1817         if isinstance(ori_dict[key],(dict,OrderedDict)):
1818             new_dict[key] = CopyDict(ori_dict[key])
1819         else:
1820             new_dict[key] = ori_dict[key]
1821     return new_dict
1822
1823 #
1824 # Remove the c/c++ comments: // and /* */
1825 #
1826 def RemoveCComments(ctext):
1827     return re.sub('//.*?\n|/\*.*?\*/', '\n', ctext, flags=re.S)