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