1 ## @file 2 # parse FDF file 3 # 4 # Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR> 5 # Copyright (c) 2015, Hewlett Packard Enterprise Development, L.P.<BR> 6 # 7 # This program and the accompanying materials 8 # are licensed and made available under the terms and conditions of the BSD License 9 # which accompanies this distribution. The full text of the license may be found at 10 # http://opensource.org/licenses/bsd-license.php 11 # 12 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 # 15 16 ## 17 # Import Modules 18 # 19 import re 20 21 import Fd 22 import Region 23 import Fv 24 import AprioriSection 25 import FfsInfStatement 26 import FfsFileStatement 27 import VerSection 28 import UiSection 29 import FvImageSection 30 import DataSection 31 import DepexSection 32 import CompressSection 33 import GuidSection 34 import Capsule 35 import CapsuleData 36 import Rule 37 import RuleComplexFile 38 import RuleSimpleFile 39 import EfiSection 40 import Vtf 41 import ComponentStatement 42 import OptionRom 43 import OptRomInfStatement 44 import OptRomFileStatement 45 46 from GenFdsGlobalVariable import GenFdsGlobalVariable 47 from Common.BuildToolError import * 48 from Common import EdkLogger 49 from Common.Misc import PathClass 50 from Common.String import NormPath 51 import Common.GlobalData as GlobalData 52 from Common.Expression import * 53 from Common import GlobalData 54 from Common.String import ReplaceMacro 55 import uuid 56 from Common.Misc import tdict 57 from Common.MultipleWorkspace import MultipleWorkspace as mws 58 import Common.LongFilePathOs as os 59 from Common.LongFilePathSupport import OpenLongFilePath as open 60 from Capsule import EFI_CERT_TYPE_PKCS7_GUID 61 from Capsule import EFI_CERT_TYPE_RSA2048_SHA256_GUID 62 63 ##define T_CHAR_SPACE ' ' 64 ##define T_CHAR_NULL '\0' 65 ##define T_CHAR_CR '\r' 66 ##define T_CHAR_TAB '\t' 67 ##define T_CHAR_LF '\n' 68 ##define T_CHAR_SLASH '/' 69 ##define T_CHAR_BACKSLASH '\\' 70 ##define T_CHAR_DOUBLE_QUOTE '\"' 71 ##define T_CHAR_SINGLE_QUOTE '\'' 72 ##define T_CHAR_STAR '*' 73 ##define T_CHAR_HASH '#' 74 75 (T_CHAR_SPACE, T_CHAR_NULL, T_CHAR_CR, T_CHAR_TAB, T_CHAR_LF, T_CHAR_SLASH, \ 76 T_CHAR_BACKSLASH, T_CHAR_DOUBLE_QUOTE, T_CHAR_SINGLE_QUOTE, T_CHAR_STAR, T_CHAR_HASH) = \ 77 (' ', '\0', '\r', '\t', '\n', '/', '\\', '\"', '\'', '*', '#') 78 79 SEPERATOR_TUPLE = ('=', '|', ',', '{', '}') 80 81 RegionSizePattern = re.compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*") 82 RegionSizeGuidPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*\|\s*(?P<size>\w+\.\w+)\s*") 83 RegionOffsetPcdPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*$") 84 ShortcutPcdPattern = re.compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\w+\.\w+)\s*") 85 86 AllIncludeFileList = [] 87 88 # Get the closest parent 89 def GetParentAtLine (Line): 90 for Profile in AllIncludeFileList: 91 if Profile.IsLineInFile(Line): 92 return Profile 93 return None 94 95 # Check include loop 96 def IsValidInclude (File, Line): 97 for Profile in AllIncludeFileList: 98 if Profile.IsLineInFile(Line) and Profile.FileName == File: 99 return False 100 101 return True 102 103 def GetRealFileLine (File, Line): 104 105 InsertedLines = 0 106 for Profile in AllIncludeFileList: 107 if Profile.IsLineInFile(Line): 108 return Profile.GetLineInFile(Line) 109 elif Line >= Profile.InsertStartLineNumber and Profile.Level == 1: 110 InsertedLines += Profile.GetTotalLines() 111 112 return (File, Line - InsertedLines) 113 114 ## The exception class that used to report error messages when parsing FDF 115 # 116 # Currently the "ToolName" is set to be "FDF Parser". 117 # 118 class Warning (Exception): 119 ## The constructor 120 # 121 # @param self The object pointer 122 # @param Str The message to record 123 # @param File The FDF name 124 # @param Line The Line number that error occurs 125 # 126 def __init__(self, Str, File = None, Line = None): 127 128 FileLineTuple = GetRealFileLine(File, Line) 129 self.FileName = FileLineTuple[0] 130 self.LineNumber = FileLineTuple[1] 131 self.OriginalLineNumber = Line 132 self.Message = Str 133 self.ToolName = 'FdfParser' 134 135 def __str__(self): 136 return self.Message 137 138 ## The MACRO class that used to record macro value data when parsing include file 139 # 140 # 141 class MacroProfile : 142 ## The constructor 143 # 144 # @param self The object pointer 145 # @param FileName The file that to be parsed 146 # 147 def __init__(self, FileName, Line): 148 self.FileName = FileName 149 self.DefinedAtLine = Line 150 self.MacroName = None 151 self.MacroValue = None 152 153 ## The Include file content class that used to record file data when parsing include file 154 # 155 # May raise Exception when opening file. 156 # 157 class IncludeFileProfile : 158 ## The constructor 159 # 160 # @param self The object pointer 161 # @param FileName The file that to be parsed 162 # 163 def __init__(self, FileName): 164 self.FileName = FileName 165 self.FileLinesList = [] 166 try: 167 fsock = open(FileName, "rb", 0) 168 try: 169 self.FileLinesList = fsock.readlines() 170 finally: 171 fsock.close() 172 173 except: 174 EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName) 175 176 self.InsertStartLineNumber = None 177 self.InsertAdjust = 0 178 self.IncludeFileList = [] 179 self.Level = 1 # first level include file 180 181 def GetTotalLines(self): 182 TotalLines = self.InsertAdjust + len(self.FileLinesList) 183 184 for Profile in self.IncludeFileList: 185 TotalLines += Profile.GetTotalLines() 186 187 return TotalLines 188 189 def IsLineInFile(self, Line): 190 if Line >= self.InsertStartLineNumber and Line < self.InsertStartLineNumber + self.GetTotalLines(): 191 return True 192 193 return False 194 195 def GetLineInFile(self, Line): 196 if not self.IsLineInFile (Line): 197 return (self.FileName, -1) 198 199 InsertedLines = self.InsertStartLineNumber 200 201 for Profile in self.IncludeFileList: 202 if Profile.IsLineInFile(Line): 203 return Profile.GetLineInFile(Line) 204 elif Line >= Profile.InsertStartLineNumber: 205 InsertedLines += Profile.GetTotalLines() 206 207 return (self.FileName, Line - InsertedLines + 1) 208 209 210 211 ## The FDF content class that used to record file data when parsing FDF 212 # 213 # May raise Exception when opening file. 214 # 215 class FileProfile : 216 ## The constructor 217 # 218 # @param self The object pointer 219 # @param FileName The file that to be parsed 220 # 221 def __init__(self, FileName): 222 self.FileLinesList = [] 223 try: 224 fsock = open(FileName, "rb", 0) 225 try: 226 self.FileLinesList = fsock.readlines() 227 finally: 228 fsock.close() 229 230 except: 231 EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName) 232 233 234 self.PcdDict = {} 235 self.InfList = [] 236 self.InfDict = {'ArchTBD':[]} 237 # ECC will use this Dict and List information 238 self.PcdFileLineDict = {} 239 self.InfFileLineList = [] 240 241 self.FdDict = {} 242 self.FdNameNotSet = False 243 self.FvDict = {} 244 self.CapsuleDict = {} 245 self.VtfList = [] 246 self.RuleDict = {} 247 self.OptRomDict = {} 248 self.FmpPayloadDict = {} 249 250 ## The syntax parser for FDF 251 # 252 # PreprocessFile method should be called prior to ParseFile 253 # CycleReferenceCheck method can detect cycles in FDF contents 254 # 255 # GetNext*** procedures mean these procedures will get next token first, then make judgement. 256 # Get*** procedures mean these procedures will make judgement on current token only. 257 # 258 class FdfParser: 259 ## The constructor 260 # 261 # @param self The object pointer 262 # @param FileName The file that to be parsed 263 # 264 def __init__(self, FileName): 265 self.Profile = FileProfile(FileName) 266 self.FileName = FileName 267 self.CurrentLineNumber = 1 268 self.CurrentOffsetWithinLine = 0 269 self.CurrentFdName = None 270 self.CurrentFvName = None 271 self.__Token = "" 272 self.__SkippedChars = "" 273 GlobalData.gFdfParser = self 274 275 # Used to section info 276 self.__CurSection = [] 277 # Key: [section name, UI name, arch] 278 # Value: {MACRO_NAME : MACRO_VALUE} 279 self.__MacroDict = tdict(True, 3) 280 self.__PcdDict = {} 281 282 self.__WipeOffArea = [] 283 if GenFdsGlobalVariable.WorkSpaceDir == '': 284 GenFdsGlobalVariable.WorkSpaceDir = os.getenv("WORKSPACE") 285 286 ## __IsWhiteSpace() method 287 # 288 # Whether char at current FileBufferPos is whitespace 289 # 290 # @param self The object pointer 291 # @param Char The char to test 292 # @retval True The char is a kind of white space 293 # @retval False The char is NOT a kind of white space 294 # 295 def __IsWhiteSpace(self, Char): 296 if Char in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_SPACE, T_CHAR_TAB, T_CHAR_LF): 297 return True 298 else: 299 return False 300 301 ## __SkipWhiteSpace() method 302 # 303 # Skip white spaces from current char, return number of chars skipped 304 # 305 # @param self The object pointer 306 # @retval Count The number of chars skipped 307 # 308 def __SkipWhiteSpace(self): 309 Count = 0 310 while not self.__EndOfFile(): 311 Count += 1 312 if self.__CurrentChar() in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_LF, T_CHAR_SPACE, T_CHAR_TAB): 313 self.__SkippedChars += str(self.__CurrentChar()) 314 self.__GetOneChar() 315 316 else: 317 Count = Count - 1 318 return Count 319 320 ## __EndOfFile() method 321 # 322 # Judge current buffer pos is at file end 323 # 324 # @param self The object pointer 325 # @retval True Current File buffer position is at file end 326 # @retval False Current File buffer position is NOT at file end 327 # 328 def __EndOfFile(self): 329 NumberOfLines = len(self.Profile.FileLinesList) 330 SizeOfLastLine = len(self.Profile.FileLinesList[-1]) 331 if self.CurrentLineNumber == NumberOfLines and self.CurrentOffsetWithinLine >= SizeOfLastLine - 1: 332 return True 333 elif self.CurrentLineNumber > NumberOfLines: 334 return True 335 else: 336 return False 337 338 ## __EndOfLine() method 339 # 340 # Judge current buffer pos is at line end 341 # 342 # @param self The object pointer 343 # @retval True Current File buffer position is at line end 344 # @retval False Current File buffer position is NOT at line end 345 # 346 def __EndOfLine(self): 347 if self.CurrentLineNumber > len(self.Profile.FileLinesList): 348 return True 349 SizeOfCurrentLine = len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) 350 if self.CurrentOffsetWithinLine >= SizeOfCurrentLine: 351 return True 352 else: 353 return False 354 355 ## Rewind() method 356 # 357 # Reset file data buffer to the initial state 358 # 359 # @param self The object pointer 360 # @param DestLine Optional new destination line number. 361 # @param DestOffset Optional new destination offset. 362 # 363 def Rewind(self, DestLine = 1, DestOffset = 0): 364 self.CurrentLineNumber = DestLine 365 self.CurrentOffsetWithinLine = DestOffset 366 367 ## __UndoOneChar() method 368 # 369 # Go back one char in the file buffer 370 # 371 # @param self The object pointer 372 # @retval True Successfully go back one char 373 # @retval False Not able to go back one char as file beginning reached 374 # 375 def __UndoOneChar(self): 376 377 if self.CurrentLineNumber == 1 and self.CurrentOffsetWithinLine == 0: 378 return False 379 elif self.CurrentOffsetWithinLine == 0: 380 self.CurrentLineNumber -= 1 381 self.CurrentOffsetWithinLine = len(self.__CurrentLine()) - 1 382 else: 383 self.CurrentOffsetWithinLine -= 1 384 return True 385 386 ## __GetOneChar() method 387 # 388 # Move forward one char in the file buffer 389 # 390 # @param self The object pointer 391 # 392 def __GetOneChar(self): 393 if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1: 394 self.CurrentLineNumber += 1 395 self.CurrentOffsetWithinLine = 0 396 else: 397 self.CurrentOffsetWithinLine += 1 398 399 ## __CurrentChar() method 400 # 401 # Get the char pointed to by the file buffer pointer 402 # 403 # @param self The object pointer 404 # @retval Char Current char 405 # 406 def __CurrentChar(self): 407 return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] 408 409 ## __NextChar() method 410 # 411 # Get the one char pass the char pointed to by the file buffer pointer 412 # 413 # @param self The object pointer 414 # @retval Char Next char 415 # 416 def __NextChar(self): 417 if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1: 418 return self.Profile.FileLinesList[self.CurrentLineNumber][0] 419 else: 420 return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1] 421 422 ## __SetCurrentCharValue() method 423 # 424 # Modify the value of current char 425 # 426 # @param self The object pointer 427 # @param Value The new value of current char 428 # 429 def __SetCurrentCharValue(self, Value): 430 self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value 431 432 ## __CurrentLine() method 433 # 434 # Get the list that contains current line contents 435 # 436 # @param self The object pointer 437 # @retval List current line contents 438 # 439 def __CurrentLine(self): 440 return self.Profile.FileLinesList[self.CurrentLineNumber - 1] 441 442 def __StringToList(self): 443 self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesList] 444 self.Profile.FileLinesList[-1].append(' ') 445 446 def __ReplaceFragment(self, StartPos, EndPos, Value = ' '): 447 if StartPos[0] == EndPos[0]: 448 Offset = StartPos[1] 449 while Offset <= EndPos[1]: 450 self.Profile.FileLinesList[StartPos[0]][Offset] = Value 451 Offset += 1 452 return 453 454 Offset = StartPos[1] 455 while self.Profile.FileLinesList[StartPos[0]][Offset] not in ('\r', '\n'): 456 self.Profile.FileLinesList[StartPos[0]][Offset] = Value 457 Offset += 1 458 459 Line = StartPos[0] 460 while Line < EndPos[0]: 461 Offset = 0 462 while self.Profile.FileLinesList[Line][Offset] not in ('\r', '\n'): 463 self.Profile.FileLinesList[Line][Offset] = Value 464 Offset += 1 465 Line += 1 466 467 Offset = 0 468 while Offset <= EndPos[1]: 469 self.Profile.FileLinesList[EndPos[0]][Offset] = Value 470 Offset += 1 471 472 473 def __GetMacroName(self): 474 if not self.__GetNextToken(): 475 raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber) 476 MacroName = self.__Token 477 NotFlag = False 478 if MacroName.startswith('!'): 479 NotFlag = True 480 MacroName = MacroName[1:].strip() 481 482 if not MacroName.startswith('$(') or not MacroName.endswith(')'): 483 raise Warning("Macro name expected(Please use '$(%(Token)s)' if '%(Token)s' is a macro.)" % {"Token" : MacroName}, 484 self.FileName, self.CurrentLineNumber) 485 MacroName = MacroName[2:-1] 486 return MacroName, NotFlag 487 488 def __SetMacroValue(self, Macro, Value): 489 if not self.__CurSection: 490 return 491 492 MacroDict = {} 493 if not self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]]: 494 self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]] = MacroDict 495 else: 496 MacroDict = self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]] 497 MacroDict[Macro] = Value 498 499 def __GetMacroValue(self, Macro): 500 # Highest priority 501 if Macro in GlobalData.gCommandLineDefines: 502 return GlobalData.gCommandLineDefines[Macro] 503 if Macro in GlobalData.gGlobalDefines: 504 return GlobalData.gGlobalDefines[Macro] 505 506 if self.__CurSection: 507 MacroDict = self.__MacroDict[ 508 self.__CurSection[0], 509 self.__CurSection[1], 510 self.__CurSection[2] 511 ] 512 if MacroDict and Macro in MacroDict: 513 return MacroDict[Macro] 514 515 # Lowest priority 516 if Macro in GlobalData.gPlatformDefines: 517 return GlobalData.gPlatformDefines[Macro] 518 return None 519 520 def __SectionHeaderParser(self, Section): 521 # [Defines] 522 # [FD.UiName]: use dummy instead if UI name is optional 523 # [FV.UiName] 524 # [Capsule.UiName] 525 # [Rule]: don't take rule section into account, macro is not allowed in this section 526 # [VTF.arch.UiName, arch] 527 # [OptionRom.DriverName] 528 self.__CurSection = [] 529 Section = Section.strip()[1:-1].upper().replace(' ', '').strip('.') 530 ItemList = Section.split('.') 531 Item = ItemList[0] 532 if Item == '' or Item == 'RULE': 533 return 534 535 if Item == 'DEFINES': 536 self.__CurSection = ['COMMON', 'COMMON', 'COMMON'] 537 elif Item == 'VTF' and len(ItemList) == 3: 538 UiName = ItemList[2] 539 Pos = UiName.find(',') 540 if Pos != -1: 541 UiName = UiName[:Pos] 542 self.__CurSection = ['VTF', UiName, ItemList[1]] 543 elif len(ItemList) > 1: 544 self.__CurSection = [ItemList[0], ItemList[1], 'COMMON'] 545 elif len(ItemList) > 0: 546 self.__CurSection = [ItemList[0], 'DUMMY', 'COMMON'] 547 548 ## PreprocessFile() method 549 # 550 # Preprocess file contents, replace comments with spaces. 551 # In the end, rewind the file buffer pointer to the beginning 552 # BUGBUG: No !include statement processing contained in this procedure 553 # !include statement should be expanded at the same FileLinesList[CurrentLineNumber - 1] 554 # 555 # @param self The object pointer 556 # 557 def PreprocessFile(self): 558 559 self.Rewind() 560 InComment = False 561 DoubleSlashComment = False 562 HashComment = False 563 # HashComment in quoted string " " is ignored. 564 InString = False 565 566 while not self.__EndOfFile(): 567 568 if self.__CurrentChar() == T_CHAR_DOUBLE_QUOTE and not InComment: 569 InString = not InString 570 # meet new line, then no longer in a comment for // and '#' 571 if self.__CurrentChar() == T_CHAR_LF: 572 self.CurrentLineNumber += 1 573 self.CurrentOffsetWithinLine = 0 574 if InComment and DoubleSlashComment: 575 InComment = False 576 DoubleSlashComment = False 577 if InComment and HashComment: 578 InComment = False 579 HashComment = False 580 # check for */ comment end 581 elif InComment and not DoubleSlashComment and not HashComment and self.__CurrentChar() == T_CHAR_STAR and self.__NextChar() == T_CHAR_SLASH: 582 self.__SetCurrentCharValue(T_CHAR_SPACE) 583 self.__GetOneChar() 584 self.__SetCurrentCharValue(T_CHAR_SPACE) 585 self.__GetOneChar() 586 InComment = False 587 # set comments to spaces 588 elif InComment: 589 self.__SetCurrentCharValue(T_CHAR_SPACE) 590 self.__GetOneChar() 591 # check for // comment 592 elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH and not self.__EndOfLine(): 593 InComment = True 594 DoubleSlashComment = True 595 # check for '#' comment 596 elif self.__CurrentChar() == T_CHAR_HASH and not self.__EndOfLine() and not InString: 597 InComment = True 598 HashComment = True 599 # check for /* comment start 600 elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_STAR: 601 self.__SetCurrentCharValue( T_CHAR_SPACE) 602 self.__GetOneChar() 603 self.__SetCurrentCharValue( T_CHAR_SPACE) 604 self.__GetOneChar() 605 InComment = True 606 else: 607 self.__GetOneChar() 608 609 # restore from ListOfList to ListOfString 610 self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList] 611 self.Rewind() 612 613 ## PreprocessIncludeFile() method 614 # 615 # Preprocess file contents, replace !include statements with file contents. 616 # In the end, rewind the file buffer pointer to the beginning 617 # 618 # @param self The object pointer 619 # 620 def PreprocessIncludeFile(self): 621 # nested include support 622 Processed = False 623 while self.__GetNextToken(): 624 625 if self.__Token == '!include': 626 Processed = True 627 IncludeLine = self.CurrentLineNumber 628 IncludeOffset = self.CurrentOffsetWithinLine - len('!include') 629 if not self.__GetNextToken(): 630 raise Warning("expected include file name", self.FileName, self.CurrentLineNumber) 631 IncFileName = self.__Token 632 __IncludeMacros = {} 633 for Macro in ['WORKSPACE', 'ECP_SOURCE', 'EFI_SOURCE', 'EDK_SOURCE']: 634 MacroVal = self.__GetMacroValue(Macro) 635 if MacroVal: 636 __IncludeMacros[Macro] = MacroVal 637 638 try: 639 IncludedFile = NormPath(ReplaceMacro(IncFileName, __IncludeMacros, RaiseError=True)) 640 except: 641 raise Warning("only these system environment variables are permitted to start the path of the included file: " 642 "$(WORKSPACE), $(ECP_SOURCE), $(EFI_SOURCE), $(EDK_SOURCE)", 643 self.FileName, self.CurrentLineNumber) 644 # 645 # First search the include file under the same directory as FDF file 646 # 647 IncludedFile1 = PathClass(IncludedFile, os.path.dirname(self.FileName)) 648 ErrorCode = IncludedFile1.Validate()[0] 649 if ErrorCode != 0: 650 # 651 # Then search the include file under the same directory as DSC file 652 # 653 PlatformDir = '' 654 if GenFdsGlobalVariable.ActivePlatform: 655 PlatformDir = GenFdsGlobalVariable.ActivePlatform.Dir 656 elif GlobalData.gActivePlatform: 657 PlatformDir = GlobalData.gActivePlatform.MetaFile.Dir 658 IncludedFile1 = PathClass(IncludedFile, PlatformDir) 659 ErrorCode = IncludedFile1.Validate()[0] 660 if ErrorCode != 0: 661 # 662 # Also search file under the WORKSPACE directory 663 # 664 IncludedFile1 = PathClass(IncludedFile, GlobalData.gWorkspace) 665 ErrorCode = IncludedFile1.Validate()[0] 666 if ErrorCode != 0: 667 raise Warning("The include file does not exist under below directories: \n%s\n%s\n%s\n"%(os.path.dirname(self.FileName), PlatformDir, GlobalData.gWorkspace), 668 self.FileName, self.CurrentLineNumber) 669 670 if not IsValidInclude (IncludedFile1.Path, self.CurrentLineNumber): 671 raise Warning("The include file {0} is causing a include loop.\n".format (IncludedFile1.Path), self.FileName, self.CurrentLineNumber) 672 673 IncFileProfile = IncludeFileProfile(IncludedFile1.Path) 674 675 CurrentLine = self.CurrentLineNumber 676 CurrentOffset = self.CurrentOffsetWithinLine 677 # list index of the insertion, note that line number is 'CurrentLine + 1' 678 InsertAtLine = CurrentLine 679 ParentProfile = GetParentAtLine (CurrentLine) 680 if ParentProfile != None: 681 ParentProfile.IncludeFileList.insert(0, IncFileProfile) 682 IncFileProfile.Level = ParentProfile.Level + 1 683 IncFileProfile.InsertStartLineNumber = InsertAtLine + 1 684 # deal with remaining portions after "!include filename", if exists. 685 if self.__GetNextToken(): 686 if self.CurrentLineNumber == CurrentLine: 687 RemainingLine = self.__CurrentLine()[CurrentOffset:] 688 self.Profile.FileLinesList.insert(self.CurrentLineNumber, RemainingLine) 689 IncFileProfile.InsertAdjust += 1 690 self.CurrentLineNumber += 1 691 self.CurrentOffsetWithinLine = 0 692 693 for Line in IncFileProfile.FileLinesList: 694 self.Profile.FileLinesList.insert(InsertAtLine, Line) 695 self.CurrentLineNumber += 1 696 InsertAtLine += 1 697 698 # reversely sorted to better determine error in file 699 AllIncludeFileList.insert(0, IncFileProfile) 700 701 # comment out the processed include file statement 702 TempList = list(self.Profile.FileLinesList[IncludeLine - 1]) 703 TempList.insert(IncludeOffset, '#') 704 self.Profile.FileLinesList[IncludeLine - 1] = ''.join(TempList) 705 if Processed: # Nested and back-to-back support 706 self.Rewind(DestLine = IncFileProfile.InsertStartLineNumber - 1) 707 Processed = False 708 # Preprocess done. 709 self.Rewind() 710 711 def __GetIfListCurrentItemStat(self, IfList): 712 if len(IfList) == 0: 713 return True 714 715 for Item in IfList: 716 if Item[1] == False: 717 return False 718 719 return True 720 721 ## PreprocessConditionalStatement() method 722 # 723 # Preprocess conditional statement. 724 # In the end, rewind the file buffer pointer to the beginning 725 # 726 # @param self The object pointer 727 # 728 def PreprocessConditionalStatement(self): 729 # IfList is a stack of if branches with elements of list [Pos, CondSatisfied, BranchDetermined] 730 IfList = [] 731 RegionLayoutLine = 0 732 ReplacedLine = -1 733 while self.__GetNextToken(): 734 # Determine section name and the location dependent macro 735 if self.__GetIfListCurrentItemStat(IfList): 736 if self.__Token.startswith('['): 737 Header = self.__Token 738 if not self.__Token.endswith(']'): 739 self.__SkipToToken(']') 740 Header += self.__SkippedChars 741 if Header.find('$(') != -1: 742 raise Warning("macro cannot be used in section header", self.FileName, self.CurrentLineNumber) 743 self.__SectionHeaderParser(Header) 744 continue 745 # Replace macros except in RULE section or out of section 746 elif self.__CurSection and ReplacedLine != self.CurrentLineNumber: 747 ReplacedLine = self.CurrentLineNumber 748 self.__UndoToken() 749 CurLine = self.Profile.FileLinesList[ReplacedLine - 1] 750 PreIndex = 0 751 StartPos = CurLine.find('$(', PreIndex) 752 EndPos = CurLine.find(')', StartPos+2) 753 while StartPos != -1 and EndPos != -1 and self.__Token not in ['!ifdef', '!ifndef', '!if', '!elseif']: 754 MacroName = CurLine[StartPos+2 : EndPos] 755 MacorValue = self.__GetMacroValue(MacroName) 756 if MacorValue != None: 757 CurLine = CurLine.replace('$(' + MacroName + ')', MacorValue, 1) 758 if MacorValue.find('$(') != -1: 759 PreIndex = StartPos 760 else: 761 PreIndex = StartPos + len(MacorValue) 762 else: 763 PreIndex = EndPos + 1 764 StartPos = CurLine.find('$(', PreIndex) 765 EndPos = CurLine.find(')', StartPos+2) 766 self.Profile.FileLinesList[ReplacedLine - 1] = CurLine 767 continue 768 769 if self.__Token == 'DEFINE': 770 if self.__GetIfListCurrentItemStat(IfList): 771 if not self.__CurSection: 772 raise Warning("macro cannot be defined in Rule section or out of section", self.FileName, self.CurrentLineNumber) 773 DefineLine = self.CurrentLineNumber - 1 774 DefineOffset = self.CurrentOffsetWithinLine - len('DEFINE') 775 if not self.__GetNextToken(): 776 raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber) 777 Macro = self.__Token 778 if not self.__IsToken( "="): 779 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 780 781 Value = self.__GetExpression() 782 self.__SetMacroValue(Macro, Value) 783 self.__WipeOffArea.append(((DefineLine, DefineOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) 784 elif self.__Token == 'SET': 785 if not self.__GetIfListCurrentItemStat(IfList): 786 continue 787 SetLine = self.CurrentLineNumber - 1 788 SetOffset = self.CurrentOffsetWithinLine - len('SET') 789 PcdPair = self.__GetNextPcdName() 790 PcdName = "%s.%s" % (PcdPair[1], PcdPair[0]) 791 if not self.__IsToken( "="): 792 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 793 794 Value = self.__GetExpression() 795 Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True) 796 797 self.__PcdDict[PcdName] = Value 798 799 self.Profile.PcdDict[PcdPair] = Value 800 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 801 self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple 802 803 self.__WipeOffArea.append(((SetLine, SetOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) 804 elif self.__Token in ('!ifdef', '!ifndef', '!if'): 805 IfStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token)) 806 IfList.append([IfStartPos, None, None]) 807 808 CondLabel = self.__Token 809 Expression = self.__GetExpression() 810 811 if CondLabel == '!if': 812 ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval') 813 else: 814 ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'in') 815 if CondLabel == '!ifndef': 816 ConditionSatisfied = not ConditionSatisfied 817 818 BranchDetermined = ConditionSatisfied 819 IfList[-1] = [IfList[-1][0], ConditionSatisfied, BranchDetermined] 820 if ConditionSatisfied: 821 self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) 822 elif self.__Token in ('!elseif', '!else'): 823 ElseStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token)) 824 if len(IfList) <= 0: 825 raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber) 826 827 if IfList[-1][1]: 828 IfList[-1] = [ElseStartPos, False, True] 829 self.__WipeOffArea.append((ElseStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) 830 else: 831 self.__WipeOffArea.append((IfList[-1][0], ElseStartPos)) 832 IfList[-1] = [ElseStartPos, True, IfList[-1][2]] 833 if self.__Token == '!elseif': 834 Expression = self.__GetExpression() 835 ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval') 836 IfList[-1] = [IfList[-1][0], ConditionSatisfied, IfList[-1][2]] 837 838 if IfList[-1][1]: 839 if IfList[-1][2]: 840 IfList[-1][1] = False 841 else: 842 IfList[-1][2] = True 843 self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) 844 elif self.__Token == '!endif': 845 if len(IfList) <= 0: 846 raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber) 847 if IfList[-1][1]: 848 self.__WipeOffArea.append(((self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len('!endif')), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) 849 else: 850 self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) 851 852 IfList.pop() 853 elif not IfList: # Don't use PCDs inside conditional directive 854 if self.CurrentLineNumber <= RegionLayoutLine: 855 # Don't try the same line twice 856 continue 857 SetPcd = ShortcutPcdPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) 858 if SetPcd: 859 self.__PcdDict[SetPcd.group('name')] = SetPcd.group('value') 860 RegionLayoutLine = self.CurrentLineNumber 861 continue 862 RegionSize = RegionSizePattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) 863 if not RegionSize: 864 RegionLayoutLine = self.CurrentLineNumber 865 continue 866 RegionSizeGuid = RegionSizeGuidPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber]) 867 if not RegionSizeGuid: 868 RegionLayoutLine = self.CurrentLineNumber + 1 869 continue 870 self.__PcdDict[RegionSizeGuid.group('base')] = RegionSize.group('base') 871 self.__PcdDict[RegionSizeGuid.group('size')] = RegionSize.group('size') 872 RegionLayoutLine = self.CurrentLineNumber + 1 873 874 if IfList: 875 raise Warning("Missing !endif", self.FileName, self.CurrentLineNumber) 876 self.Rewind() 877 878 def __CollectMacroPcd(self): 879 MacroDict = {} 880 881 # PCD macro 882 MacroDict.update(GlobalData.gPlatformPcds) 883 MacroDict.update(self.__PcdDict) 884 885 # Lowest priority 886 MacroDict.update(GlobalData.gPlatformDefines) 887 888 if self.__CurSection: 889 # Defines macro 890 ScopeMacro = self.__MacroDict['COMMON', 'COMMON', 'COMMON'] 891 if ScopeMacro: 892 MacroDict.update(ScopeMacro) 893 894 # Section macro 895 ScopeMacro = self.__MacroDict[ 896 self.__CurSection[0], 897 self.__CurSection[1], 898 self.__CurSection[2] 899 ] 900 if ScopeMacro: 901 MacroDict.update(ScopeMacro) 902 903 MacroDict.update(GlobalData.gGlobalDefines) 904 MacroDict.update(GlobalData.gCommandLineDefines) 905 # Highest priority 906 907 return MacroDict 908 909 def __EvaluateConditional(self, Expression, Line, Op = None, Value = None): 910 FileLineTuple = GetRealFileLine(self.FileName, Line) 911 MacroPcdDict = self.__CollectMacroPcd() 912 if Op == 'eval': 913 try: 914 if Value: 915 return ValueExpression(Expression, MacroPcdDict)(True) 916 else: 917 return ValueExpression(Expression, MacroPcdDict)() 918 except WrnExpression, Excpt: 919 # 920 # Catch expression evaluation warning here. We need to report 921 # the precise number of line and return the evaluation result 922 # 923 EdkLogger.warn('Parser', "Suspicious expression: %s" % str(Excpt), 924 File=self.FileName, ExtraData=self.__CurrentLine(), 925 Line=Line) 926 return Excpt.result 927 except Exception, Excpt: 928 if hasattr(Excpt, 'Pcd'): 929 if Excpt.Pcd in GlobalData.gPlatformOtherPcds: 930 Info = GlobalData.gPlatformOtherPcds[Excpt.Pcd] 931 raise Warning("Cannot use this PCD (%s) in an expression as" 932 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section" 933 " of the DSC file (%s), and it is currently defined in this section:" 934 " %s, line #: %d." % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE'], Info[0], Info[1]), 935 *FileLineTuple) 936 else: 937 raise Warning("PCD (%s) is not defined in DSC file (%s)" % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE']), 938 *FileLineTuple) 939 else: 940 raise Warning(str(Excpt), *FileLineTuple) 941 else: 942 if Expression.startswith('$(') and Expression[-1] == ')': 943 Expression = Expression[2:-1] 944 return Expression in MacroPcdDict 945 946 ## __IsToken() method 947 # 948 # Check whether input string is found from current char position along 949 # If found, the string value is put into self.__Token 950 # 951 # @param self The object pointer 952 # @param String The string to search 953 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive 954 # @retval True Successfully find string, file buffer pointer moved forward 955 # @retval False Not able to find string, file buffer pointer not changed 956 # 957 def __IsToken(self, String, IgnoreCase = False): 958 self.__SkipWhiteSpace() 959 960 # Only consider the same line, no multi-line token allowed 961 StartPos = self.CurrentOffsetWithinLine 962 index = -1 963 if IgnoreCase: 964 index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper()) 965 else: 966 index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String) 967 if index == 0: 968 self.CurrentOffsetWithinLine += len(String) 969 self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] 970 return True 971 return False 972 973 ## __IsKeyword() method 974 # 975 # Check whether input keyword is found from current char position along, whole word only! 976 # If found, the string value is put into self.__Token 977 # 978 # @param self The object pointer 979 # @param Keyword The string to search 980 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive 981 # @retval True Successfully find string, file buffer pointer moved forward 982 # @retval False Not able to find string, file buffer pointer not changed 983 # 984 def __IsKeyword(self, KeyWord, IgnoreCase = False): 985 self.__SkipWhiteSpace() 986 987 # Only consider the same line, no multi-line token allowed 988 StartPos = self.CurrentOffsetWithinLine 989 index = -1 990 if IgnoreCase: 991 index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(KeyWord.upper()) 992 else: 993 index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(KeyWord) 994 if index == 0: 995 followingChar = self.__CurrentLine()[self.CurrentOffsetWithinLine + len(KeyWord)] 996 if not str(followingChar).isspace() and followingChar not in SEPERATOR_TUPLE: 997 return False 998 self.CurrentOffsetWithinLine += len(KeyWord) 999 self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] 1000 return True 1001 return False 1002 1003 def __GetExpression(self): 1004 Line = self.Profile.FileLinesList[self.CurrentLineNumber - 1] 1005 Index = len(Line) - 1 1006 while Line[Index] in ['\r', '\n']: 1007 Index -= 1 1008 ExpressionString = self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:Index+1] 1009 self.CurrentOffsetWithinLine += len(ExpressionString) 1010 ExpressionString = ExpressionString.strip() 1011 return ExpressionString 1012 1013 ## __GetNextWord() method 1014 # 1015 # Get next C name from file lines 1016 # If found, the string value is put into self.__Token 1017 # 1018 # @param self The object pointer 1019 # @retval True Successfully find a C name string, file buffer pointer moved forward 1020 # @retval False Not able to find a C name string, file buffer pointer not changed 1021 # 1022 def __GetNextWord(self): 1023 self.__SkipWhiteSpace() 1024 if self.__EndOfFile(): 1025 return False 1026 1027 TempChar = self.__CurrentChar() 1028 StartPos = self.CurrentOffsetWithinLine 1029 if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_': 1030 self.__GetOneChar() 1031 while not self.__EndOfLine(): 1032 TempChar = self.__CurrentChar() 1033 if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \ 1034 or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-': 1035 self.__GetOneChar() 1036 1037 else: 1038 break 1039 1040 self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] 1041 return True 1042 1043 return False 1044 1045 ## __GetNextToken() method 1046 # 1047 # Get next token unit before a seperator 1048 # If found, the string value is put into self.__Token 1049 # 1050 # @param self The object pointer 1051 # @retval True Successfully find a token unit, file buffer pointer moved forward 1052 # @retval False Not able to find a token unit, file buffer pointer not changed 1053 # 1054 def __GetNextToken(self): 1055 # Skip leading spaces, if exist. 1056 self.__SkipWhiteSpace() 1057 if self.__EndOfFile(): 1058 return False 1059 # Record the token start position, the position of the first non-space char. 1060 StartPos = self.CurrentOffsetWithinLine 1061 StartLine = self.CurrentLineNumber 1062 while StartLine == self.CurrentLineNumber: 1063 TempChar = self.__CurrentChar() 1064 # Try to find the end char that is not a space and not in seperator tuple. 1065 # That is, when we got a space or any char in the tuple, we got the end of token. 1066 if not str(TempChar).isspace() and TempChar not in SEPERATOR_TUPLE: 1067 self.__GetOneChar() 1068 # if we happen to meet a seperator as the first char, we must proceed to get it. 1069 # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens. 1070 elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE: 1071 self.__GetOneChar() 1072 break 1073 else: 1074 break 1075 # else: 1076 # return False 1077 1078 EndPos = self.CurrentOffsetWithinLine 1079 if self.CurrentLineNumber != StartLine: 1080 EndPos = len(self.Profile.FileLinesList[StartLine-1]) 1081 self.__Token = self.Profile.FileLinesList[StartLine-1][StartPos : EndPos] 1082 if StartPos != self.CurrentOffsetWithinLine: 1083 return True 1084 else: 1085 return False 1086 1087 def __GetNextOp(self): 1088 # Skip leading spaces, if exist. 1089 self.__SkipWhiteSpace() 1090 if self.__EndOfFile(): 1091 return False 1092 # Record the token start position, the position of the first non-space char. 1093 StartPos = self.CurrentOffsetWithinLine 1094 while not self.__EndOfLine(): 1095 TempChar = self.__CurrentChar() 1096 # Try to find the end char that is not a space 1097 if not str(TempChar).isspace(): 1098 self.__GetOneChar() 1099 else: 1100 break 1101 else: 1102 return False 1103 1104 if StartPos != self.CurrentOffsetWithinLine: 1105 self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] 1106 return True 1107 else: 1108 return False 1109 ## __GetNextGuid() method 1110 # 1111 # Get next token unit before a seperator 1112 # If found, the GUID string is put into self.__Token 1113 # 1114 # @param self The object pointer 1115 # @retval True Successfully find a registry format GUID, file buffer pointer moved forward 1116 # @retval False Not able to find a registry format GUID, file buffer pointer not changed 1117 # 1118 def __GetNextGuid(self): 1119 1120 if not self.__GetNextToken(): 1121 return False 1122 p = re.compile('[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}') 1123 if p.match(self.__Token) != None: 1124 return True 1125 else: 1126 self.__UndoToken() 1127 return False 1128 1129 def __Verify(self, Name, Value, Scope): 1130 if Scope in ['UINT64', 'UINT8']: 1131 ValueNumber = 0 1132 try: 1133 if Value.upper().startswith('0X'): 1134 ValueNumber = int (Value, 16) 1135 else: 1136 ValueNumber = int (Value) 1137 except: 1138 EdkLogger.error("FdfParser", FORMAT_INVALID, "The value is not valid dec or hex number for %s." % Name) 1139 if ValueNumber < 0: 1140 EdkLogger.error("FdfParser", FORMAT_INVALID, "The value can't be set to negative value for %s." % Name) 1141 if Scope == 'UINT64': 1142 if ValueNumber >= 0x10000000000000000: 1143 EdkLogger.error("FdfParser", FORMAT_INVALID, "Too large value for %s." % Name) 1144 if Scope == 'UINT8': 1145 if ValueNumber >= 0x100: 1146 EdkLogger.error("FdfParser", FORMAT_INVALID, "Too large value for %s." % Name) 1147 return True 1148 1149 ## __UndoToken() method 1150 # 1151 # Go back one token unit in file buffer 1152 # 1153 # @param self The object pointer 1154 # 1155 def __UndoToken(self): 1156 self.__UndoOneChar() 1157 while self.__CurrentChar().isspace(): 1158 if not self.__UndoOneChar(): 1159 self.__GetOneChar() 1160 return 1161 1162 1163 StartPos = self.CurrentOffsetWithinLine 1164 CurrentLine = self.CurrentLineNumber 1165 while CurrentLine == self.CurrentLineNumber: 1166 1167 TempChar = self.__CurrentChar() 1168 # Try to find the end char that is not a space and not in seperator tuple. 1169 # That is, when we got a space or any char in the tuple, we got the end of token. 1170 if not str(TempChar).isspace() and not TempChar in SEPERATOR_TUPLE: 1171 if not self.__UndoOneChar(): 1172 return 1173 # if we happen to meet a seperator as the first char, we must proceed to get it. 1174 # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens. 1175 elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE: 1176 return 1177 else: 1178 break 1179 1180 self.__GetOneChar() 1181 1182 ## __HexDigit() method 1183 # 1184 # Whether char input is a Hex data bit 1185 # 1186 # @param self The object pointer 1187 # @param TempChar The char to test 1188 # @retval True The char is a Hex data bit 1189 # @retval False The char is NOT a Hex data bit 1190 # 1191 def __HexDigit(self, TempChar): 1192 if (TempChar >= 'a' and TempChar <= 'f') or (TempChar >= 'A' and TempChar <= 'F') \ 1193 or (TempChar >= '0' and TempChar <= '9'): 1194 return True 1195 else: 1196 return False 1197 1198 def __IsHex(self, HexStr): 1199 if not HexStr.upper().startswith("0X"): 1200 return False 1201 if len(self.__Token) <= 2: 1202 return False 1203 charList = [c for c in HexStr[2 : ] if not self.__HexDigit( c)] 1204 if len(charList) == 0: 1205 return True 1206 else: 1207 return False 1208 ## __GetNextHexNumber() method 1209 # 1210 # Get next HEX data before a seperator 1211 # If found, the HEX data is put into self.__Token 1212 # 1213 # @param self The object pointer 1214 # @retval True Successfully find a HEX data, file buffer pointer moved forward 1215 # @retval False Not able to find a HEX data, file buffer pointer not changed 1216 # 1217 def __GetNextHexNumber(self): 1218 if not self.__GetNextToken(): 1219 return False 1220 if self.__IsHex(self.__Token): 1221 return True 1222 else: 1223 self.__UndoToken() 1224 return False 1225 1226 ## __GetNextDecimalNumber() method 1227 # 1228 # Get next decimal data before a seperator 1229 # If found, the decimal data is put into self.__Token 1230 # 1231 # @param self The object pointer 1232 # @retval True Successfully find a decimal data, file buffer pointer moved forward 1233 # @retval False Not able to find a decimal data, file buffer pointer not changed 1234 # 1235 def __GetNextDecimalNumber(self): 1236 if not self.__GetNextToken(): 1237 return False 1238 if self.__Token.isdigit(): 1239 return True 1240 else: 1241 self.__UndoToken() 1242 return False 1243 1244 ## __GetNextPcdName() method 1245 # 1246 # Get next PCD token space C name and PCD C name pair before a seperator 1247 # If found, the decimal data is put into self.__Token 1248 # 1249 # @param self The object pointer 1250 # @retval Tuple PCD C name and PCD token space C name pair 1251 # 1252 def __GetNextPcdName(self): 1253 if not self.__GetNextWord(): 1254 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber) 1255 pcdTokenSpaceCName = self.__Token 1256 1257 if not self.__IsToken( "."): 1258 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber) 1259 1260 if not self.__GetNextWord(): 1261 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber) 1262 pcdCName = self.__Token 1263 1264 return (pcdCName, pcdTokenSpaceCName) 1265 1266 ## __GetStringData() method 1267 # 1268 # Get string contents quoted in "" 1269 # If found, the decimal data is put into self.__Token 1270 # 1271 # @param self The object pointer 1272 # @retval True Successfully find a string data, file buffer pointer moved forward 1273 # @retval False Not able to find a string data, file buffer pointer not changed 1274 # 1275 def __GetStringData(self): 1276 if self.__Token.startswith("\"") or self.__Token.startswith("L\""): 1277 self.__UndoToken() 1278 self.__SkipToToken("\"") 1279 currentLineNumber = self.CurrentLineNumber 1280 1281 if not self.__SkipToToken("\""): 1282 raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber) 1283 if currentLineNumber != self.CurrentLineNumber: 1284 raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber) 1285 self.__Token = self.__SkippedChars.rstrip('\"') 1286 return True 1287 1288 elif self.__Token.startswith("\'") or self.__Token.startswith("L\'"): 1289 self.__UndoToken() 1290 self.__SkipToToken("\'") 1291 currentLineNumber = self.CurrentLineNumber 1292 1293 if not self.__SkipToToken("\'"): 1294 raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber) 1295 if currentLineNumber != self.CurrentLineNumber: 1296 raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber) 1297 self.__Token = self.__SkippedChars.rstrip('\'') 1298 return True 1299 1300 else: 1301 return False 1302 1303 ## __SkipToToken() method 1304 # 1305 # Search forward in file buffer for the string 1306 # The skipped chars are put into self.__SkippedChars 1307 # 1308 # @param self The object pointer 1309 # @param String The string to search 1310 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive 1311 # @retval True Successfully find the string, file buffer pointer moved forward 1312 # @retval False Not able to find the string, file buffer pointer not changed 1313 # 1314 def __SkipToToken(self, String, IgnoreCase = False): 1315 StartPos = self.GetFileBufferPos() 1316 1317 self.__SkippedChars = "" 1318 while not self.__EndOfFile(): 1319 index = -1 1320 if IgnoreCase: 1321 index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper()) 1322 else: 1323 index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String) 1324 if index == 0: 1325 self.CurrentOffsetWithinLine += len(String) 1326 self.__SkippedChars += String 1327 return True 1328 self.__SkippedChars += str(self.__CurrentChar()) 1329 self.__GetOneChar() 1330 1331 self.SetFileBufferPos( StartPos) 1332 self.__SkippedChars = "" 1333 return False 1334 1335 ## GetFileBufferPos() method 1336 # 1337 # Return the tuple of current line and offset within the line 1338 # 1339 # @param self The object pointer 1340 # @retval Tuple Line number and offset pair 1341 # 1342 def GetFileBufferPos(self): 1343 return (self.CurrentLineNumber, self.CurrentOffsetWithinLine) 1344 1345 ## SetFileBufferPos() method 1346 # 1347 # Restore the file buffer position 1348 # 1349 # @param self The object pointer 1350 # @param Pos The new file buffer position 1351 # 1352 def SetFileBufferPos(self, Pos): 1353 (self.CurrentLineNumber, self.CurrentOffsetWithinLine) = Pos 1354 1355 ## Preprocess() method 1356 # 1357 # Preprocess comment, conditional directive, include directive, replace macro. 1358 # Exception will be raised if syntax error found 1359 # 1360 # @param self The object pointer 1361 # 1362 def Preprocess(self): 1363 self.__StringToList() 1364 self.PreprocessFile() 1365 self.PreprocessIncludeFile() 1366 self.__StringToList() 1367 self.PreprocessFile() 1368 self.PreprocessConditionalStatement() 1369 self.__StringToList() 1370 for Pos in self.__WipeOffArea: 1371 self.__ReplaceFragment(Pos[0], Pos[1]) 1372 self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList] 1373 1374 while self.__GetDefines(): 1375 pass 1376 1377 ## ParseFile() method 1378 # 1379 # Parse the file profile buffer to extract fd, fv ... information 1380 # Exception will be raised if syntax error found 1381 # 1382 # @param self The object pointer 1383 # 1384 def ParseFile(self): 1385 1386 try: 1387 self.Preprocess() 1388 # 1389 # Keep processing sections of the FDF until no new sections or a syntax error is found 1390 # 1391 while self.__GetFd() or self.__GetFv() or self.__GetFmp() or self.__GetCapsule() or self.__GetVtf() or self.__GetRule() or self.__GetOptionRom(): 1392 pass 1393 1394 except Warning, X: 1395 self.__UndoToken() 1396 #'\n\tGot Token: \"%s\" from File %s\n' % (self.__Token, FileLineTuple[0]) + \ 1397 # At this point, the closest parent would be the included file itself 1398 Profile = GetParentAtLine(X.OriginalLineNumber) 1399 if Profile != None: 1400 X.Message += ' near line %d, column %d: %s' \ 1401 % (X.LineNumber, 0, Profile.FileLinesList[X.LineNumber-1]) 1402 else: 1403 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1404 X.Message += ' near line %d, column %d: %s' \ 1405 % (FileLineTuple[1], self.CurrentOffsetWithinLine + 1, self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :].rstrip('\n').rstrip('\r')) 1406 raise 1407 1408 ## SectionParser() method 1409 # 1410 # Parse the file section info 1411 # Exception will be raised if syntax error found 1412 # 1413 # @param self The object pointer 1414 # @param section The section string 1415 1416 def SectionParser(self, section): 1417 S = section.upper() 1418 if not S.startswith("[DEFINES") and not S.startswith("[FD.") and not S.startswith("[FV.") and not S.startswith("[CAPSULE.") \ 1419 and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM.") and not S.startswith('[FMPPAYLOAD.'): 1420 raise Warning("Unknown section or section appear sequence error (The correct sequence should be [DEFINES], [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.], [FMPPAYLOAD.])", self.FileName, self.CurrentLineNumber) 1421 1422 ## __GetDefines() method 1423 # 1424 # Get Defines section contents and store its data into AllMacrosList 1425 # 1426 # @param self The object pointer 1427 # @retval True Successfully find a Defines 1428 # @retval False Not able to find a Defines 1429 # 1430 def __GetDefines(self): 1431 1432 if not self.__GetNextToken(): 1433 return False 1434 1435 S = self.__Token.upper() 1436 if S.startswith("[") and not S.startswith("[DEFINES"): 1437 self.SectionParser(S) 1438 self.__UndoToken() 1439 return False 1440 1441 self.__UndoToken() 1442 if not self.__IsToken("[DEFINES", True): 1443 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1444 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ 1445 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) 1446 raise Warning("expected [DEFINES", self.FileName, self.CurrentLineNumber) 1447 1448 if not self.__IsToken( "]"): 1449 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 1450 1451 while self.__GetNextWord(): 1452 # handle the SET statement 1453 if self.__Token == 'SET': 1454 self.__UndoToken() 1455 self.__GetSetStatement(None) 1456 continue 1457 1458 Macro = self.__Token 1459 1460 if not self.__IsToken("="): 1461 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1462 if not self.__GetNextToken() or self.__Token.startswith('['): 1463 raise Warning("expected MACRO value", self.FileName, self.CurrentLineNumber) 1464 Value = self.__Token 1465 1466 return False 1467 1468 ## __GetFd() method 1469 # 1470 # Get FD section contents and store its data into FD dictionary of self.Profile 1471 # 1472 # @param self The object pointer 1473 # @retval True Successfully find a FD 1474 # @retval False Not able to find a FD 1475 # 1476 def __GetFd(self): 1477 1478 if not self.__GetNextToken(): 1479 return False 1480 1481 S = self.__Token.upper() 1482 if S.startswith("[") and not S.startswith("[FD."): 1483 if not S.startswith("[FV.") and not S.startswith('[FMPPAYLOAD.') and not S.startswith("[CAPSULE.") \ 1484 and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."): 1485 raise Warning("Unknown section", self.FileName, self.CurrentLineNumber) 1486 self.__UndoToken() 1487 return False 1488 1489 self.__UndoToken() 1490 if not self.__IsToken("[FD.", True): 1491 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1492 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ 1493 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) 1494 raise Warning("expected [FD.]", self.FileName, self.CurrentLineNumber) 1495 1496 FdName = self.__GetUiName() 1497 if FdName == "": 1498 if len (self.Profile.FdDict) == 0: 1499 FdName = GenFdsGlobalVariable.PlatformName 1500 if FdName == "" and GlobalData.gActivePlatform: 1501 FdName = GlobalData.gActivePlatform.PlatformName 1502 self.Profile.FdNameNotSet = True 1503 else: 1504 raise Warning("expected FdName in [FD.] section", self.FileName, self.CurrentLineNumber) 1505 self.CurrentFdName = FdName.upper() 1506 1507 if self.CurrentFdName in self.Profile.FdDict: 1508 raise Warning("Unexpected the same FD name", self.FileName, self.CurrentLineNumber) 1509 1510 if not self.__IsToken( "]"): 1511 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 1512 1513 FdObj = Fd.FD() 1514 FdObj.FdUiName = self.CurrentFdName 1515 self.Profile.FdDict[self.CurrentFdName] = FdObj 1516 1517 if len (self.Profile.FdDict) > 1 and self.Profile.FdNameNotSet: 1518 raise Warning("expected all FDs have their name", self.FileName, self.CurrentLineNumber) 1519 1520 Status = self.__GetCreateFile(FdObj) 1521 if not Status: 1522 raise Warning("FD name error", self.FileName, self.CurrentLineNumber) 1523 1524 while self.__GetTokenStatements(FdObj): 1525 pass 1526 for Attr in ("BaseAddress", "Size", "ErasePolarity"): 1527 if getattr(FdObj, Attr) == None: 1528 self.__GetNextToken() 1529 raise Warning("Keyword %s missing" % Attr, self.FileName, self.CurrentLineNumber) 1530 1531 if not FdObj.BlockSizeList: 1532 FdObj.BlockSizeList.append((1, FdObj.Size, None)) 1533 1534 self.__GetDefineStatements(FdObj) 1535 1536 self.__GetSetStatements(FdObj) 1537 1538 if not self.__GetRegionLayout(FdObj): 1539 raise Warning("expected region layout", self.FileName, self.CurrentLineNumber) 1540 1541 while self.__GetRegionLayout(FdObj): 1542 pass 1543 return True 1544 1545 ## __GetUiName() method 1546 # 1547 # Return the UI name of a section 1548 # 1549 # @param self The object pointer 1550 # @retval FdName UI name 1551 # 1552 def __GetUiName(self): 1553 Name = "" 1554 if self.__GetNextWord(): 1555 Name = self.__Token 1556 1557 return Name 1558 1559 ## __GetCreateFile() method 1560 # 1561 # Return the output file name of object 1562 # 1563 # @param self The object pointer 1564 # @param Obj object whose data will be stored in file 1565 # @retval FdName UI name 1566 # 1567 def __GetCreateFile(self, Obj): 1568 1569 if self.__IsKeyword( "CREATE_FILE"): 1570 if not self.__IsToken( "="): 1571 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1572 1573 if not self.__GetNextToken(): 1574 raise Warning("expected file name", self.FileName, self.CurrentLineNumber) 1575 1576 FileName = self.__Token 1577 Obj.CreateFileName = FileName 1578 1579 return True 1580 1581 ## __GetTokenStatements() method 1582 # 1583 # Get token statements 1584 # 1585 # @param self The object pointer 1586 # @param Obj for whom token statement is got 1587 # 1588 def __GetTokenStatements(self, Obj): 1589 if self.__IsKeyword( "BaseAddress"): 1590 if not self.__IsToken( "="): 1591 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1592 1593 if not self.__GetNextHexNumber(): 1594 raise Warning("expected Hex base address", self.FileName, self.CurrentLineNumber) 1595 1596 Obj.BaseAddress = self.__Token 1597 1598 if self.__IsToken( "|"): 1599 pcdPair = self.__GetNextPcdName() 1600 Obj.BaseAddressPcd = pcdPair 1601 self.Profile.PcdDict[pcdPair] = Obj.BaseAddress 1602 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1603 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple 1604 return True 1605 1606 if self.__IsKeyword( "Size"): 1607 if not self.__IsToken( "="): 1608 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1609 1610 if not self.__GetNextHexNumber(): 1611 raise Warning("expected Hex size", self.FileName, self.CurrentLineNumber) 1612 1613 Size = self.__Token 1614 if self.__IsToken( "|"): 1615 pcdPair = self.__GetNextPcdName() 1616 Obj.SizePcd = pcdPair 1617 self.Profile.PcdDict[pcdPair] = Size 1618 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1619 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple 1620 Obj.Size = long(Size, 0) 1621 return True 1622 1623 if self.__IsKeyword( "ErasePolarity"): 1624 if not self.__IsToken( "="): 1625 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1626 1627 if not self.__GetNextToken(): 1628 raise Warning("expected Erase Polarity", self.FileName, self.CurrentLineNumber) 1629 1630 if self.__Token != "1" and self.__Token != "0": 1631 raise Warning("expected 1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber) 1632 1633 Obj.ErasePolarity = self.__Token 1634 return True 1635 1636 return self.__GetBlockStatements(Obj) 1637 1638 ## __GetAddressStatements() method 1639 # 1640 # Get address statements 1641 # 1642 # @param self The object pointer 1643 # @param Obj for whom address statement is got 1644 # @retval True Successfully find 1645 # @retval False Not able to find 1646 # 1647 def __GetAddressStatements(self, Obj): 1648 1649 if self.__IsKeyword("BsBaseAddress"): 1650 if not self.__IsToken( "="): 1651 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1652 1653 if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber(): 1654 raise Warning("expected address", self.FileName, self.CurrentLineNumber) 1655 1656 BsAddress = long(self.__Token, 0) 1657 Obj.BsBaseAddress = BsAddress 1658 1659 if self.__IsKeyword("RtBaseAddress"): 1660 if not self.__IsToken( "="): 1661 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1662 1663 if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber(): 1664 raise Warning("expected address", self.FileName, self.CurrentLineNumber) 1665 1666 RtAddress = long(self.__Token, 0) 1667 Obj.RtBaseAddress = RtAddress 1668 1669 ## __GetBlockStatements() method 1670 # 1671 # Get block statements 1672 # 1673 # @param self The object pointer 1674 # @param Obj for whom block statement is got 1675 # 1676 def __GetBlockStatements(self, Obj): 1677 IsBlock = False 1678 while self.__GetBlockStatement(Obj): 1679 IsBlock = True 1680 1681 Item = Obj.BlockSizeList[-1] 1682 if Item[0] == None or Item[1] == None: 1683 raise Warning("expected block statement", self.FileName, self.CurrentLineNumber) 1684 return IsBlock 1685 1686 ## __GetBlockStatement() method 1687 # 1688 # Get block statement 1689 # 1690 # @param self The object pointer 1691 # @param Obj for whom block statement is got 1692 # @retval True Successfully find 1693 # @retval False Not able to find 1694 # 1695 def __GetBlockStatement(self, Obj): 1696 if not self.__IsKeyword( "BlockSize"): 1697 return False 1698 1699 if not self.__IsToken( "="): 1700 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1701 1702 if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber(): 1703 raise Warning("expected Hex or Integer block size", self.FileName, self.CurrentLineNumber) 1704 1705 BlockSize = self.__Token 1706 BlockSizePcd = None 1707 if self.__IsToken( "|"): 1708 PcdPair = self.__GetNextPcdName() 1709 BlockSizePcd = PcdPair 1710 self.Profile.PcdDict[PcdPair] = BlockSize 1711 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1712 self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple 1713 BlockSize = long(BlockSize, 0) 1714 1715 BlockNumber = None 1716 if self.__IsKeyword( "NumBlocks"): 1717 if not self.__IsToken( "="): 1718 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1719 1720 if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber(): 1721 raise Warning("expected block numbers", self.FileName, self.CurrentLineNumber) 1722 1723 BlockNumber = long(self.__Token, 0) 1724 1725 Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd)) 1726 return True 1727 1728 ## __GetDefineStatements() method 1729 # 1730 # Get define statements 1731 # 1732 # @param self The object pointer 1733 # @param Obj for whom define statement is got 1734 # @retval True Successfully find 1735 # @retval False Not able to find 1736 # 1737 def __GetDefineStatements(self, Obj): 1738 while self.__GetDefineStatement( Obj): 1739 pass 1740 1741 ## __GetDefineStatement() method 1742 # 1743 # Get define statement 1744 # 1745 # @param self The object pointer 1746 # @param Obj for whom define statement is got 1747 # @retval True Successfully find 1748 # @retval False Not able to find 1749 # 1750 def __GetDefineStatement(self, Obj): 1751 if self.__IsKeyword("DEFINE"): 1752 self.__GetNextToken() 1753 Macro = self.__Token 1754 if not self.__IsToken( "="): 1755 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1756 1757 if not self.__GetNextToken(): 1758 raise Warning("expected value", self.FileName, self.CurrentLineNumber) 1759 1760 Value = self.__Token 1761 Macro = '$(' + Macro + ')' 1762 Obj.DefineVarDict[Macro] = Value 1763 return True 1764 1765 return False 1766 1767 ## __GetSetStatements() method 1768 # 1769 # Get set statements 1770 # 1771 # @param self The object pointer 1772 # @param Obj for whom set statement is got 1773 # @retval True Successfully find 1774 # @retval False Not able to find 1775 # 1776 def __GetSetStatements(self, Obj): 1777 while self.__GetSetStatement(Obj): 1778 pass 1779 1780 ## __GetSetStatement() method 1781 # 1782 # Get set statement 1783 # 1784 # @param self The object pointer 1785 # @param Obj for whom set statement is got 1786 # @retval True Successfully find 1787 # @retval False Not able to find 1788 # 1789 def __GetSetStatement(self, Obj): 1790 if self.__IsKeyword("SET"): 1791 PcdPair = self.__GetNextPcdName() 1792 1793 if not self.__IsToken( "="): 1794 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1795 1796 Value = self.__GetExpression() 1797 Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True) 1798 1799 if Obj: 1800 Obj.SetVarDict[PcdPair] = Value 1801 self.Profile.PcdDict[PcdPair] = Value 1802 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1803 self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple 1804 return True 1805 1806 return False 1807 1808 ## __CalcRegionExpr(self) 1809 # 1810 # Calculate expression for offset or size of a region 1811 # 1812 # @return: None if invalid expression 1813 # Calculated number if successfully 1814 # 1815 def __CalcRegionExpr(self): 1816 StartPos = self.GetFileBufferPos() 1817 Expr = '' 1818 PairCount = 0 1819 while not self.__EndOfFile(): 1820 CurCh = self.__CurrentChar() 1821 if CurCh == '(': 1822 PairCount += 1 1823 elif CurCh == ')': 1824 PairCount -= 1 1825 1826 if CurCh in '|\r\n' and PairCount == 0: 1827 break 1828 Expr += CurCh 1829 self.__GetOneChar() 1830 try: 1831 return long( 1832 ValueExpression(Expr, 1833 self.__CollectMacroPcd() 1834 )(True),0) 1835 except Exception: 1836 self.SetFileBufferPos(StartPos) 1837 return None 1838 1839 ## __GetRegionLayout() method 1840 # 1841 # Get region layout for FD 1842 # 1843 # @param self The object pointer 1844 # @param Fd for whom region is got 1845 # @retval True Successfully find 1846 # @retval False Not able to find 1847 # 1848 def __GetRegionLayout(self, Fd): 1849 Offset = self.__CalcRegionExpr() 1850 if Offset == None: 1851 return False 1852 1853 RegionObj = Region.Region() 1854 RegionObj.Offset = Offset 1855 Fd.RegionList.append(RegionObj) 1856 1857 if not self.__IsToken( "|"): 1858 raise Warning("expected '|'", self.FileName, self.CurrentLineNumber) 1859 1860 Size = self.__CalcRegionExpr() 1861 if Size == None: 1862 raise Warning("expected Region Size", self.FileName, self.CurrentLineNumber) 1863 RegionObj.Size = Size 1864 1865 if not self.__GetNextWord(): 1866 return True 1867 1868 if not self.__Token in ("SET", "FV", "FILE", "DATA", "CAPSULE", "INF"): 1869 # 1870 # If next token is a word which is not a valid FV type, it might be part of [PcdOffset[|PcdSize]] 1871 # Or it might be next region's offset described by an expression which starts with a PCD. 1872 # PcdOffset[|PcdSize] or OffsetPcdExpression|Size 1873 # 1874 self.__UndoToken() 1875 IsRegionPcd = (RegionSizeGuidPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]) or 1876 RegionOffsetPcdPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:])) 1877 if IsRegionPcd: 1878 RegionObj.PcdOffset = self.__GetNextPcdName() 1879 self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(Fd.BaseAddress, 0)) 1880 self.__PcdDict['%s.%s' % (RegionObj.PcdOffset[1], RegionObj.PcdOffset[0])] = "0x%x" % RegionObj.Offset 1881 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1882 self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple 1883 if self.__IsToken( "|"): 1884 RegionObj.PcdSize = self.__GetNextPcdName() 1885 self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size 1886 self.__PcdDict['%s.%s' % (RegionObj.PcdSize[1], RegionObj.PcdSize[0])] = "0x%x" % RegionObj.Size 1887 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 1888 self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple 1889 1890 if not self.__GetNextWord(): 1891 return True 1892 1893 if self.__Token == "SET": 1894 self.__UndoToken() 1895 self.__GetSetStatements( RegionObj) 1896 if not self.__GetNextWord(): 1897 return True 1898 1899 elif self.__Token == "FV": 1900 self.__UndoToken() 1901 self.__GetRegionFvType( RegionObj) 1902 1903 elif self.__Token == "CAPSULE": 1904 self.__UndoToken() 1905 self.__GetRegionCapType( RegionObj) 1906 1907 elif self.__Token == "FILE": 1908 self.__UndoToken() 1909 self.__GetRegionFileType(RegionObj) 1910 1911 elif self.__Token == "INF": 1912 self.__UndoToken() 1913 RegionObj.RegionType = "INF" 1914 while self.__IsKeyword("INF"): 1915 self.__UndoToken() 1916 ffsInf = self.__ParseInfStatement() 1917 if not ffsInf: 1918 break 1919 RegionObj.RegionDataList.append(ffsInf) 1920 1921 elif self.__Token == "DATA": 1922 self.__UndoToken() 1923 self.__GetRegionDataType(RegionObj) 1924 else: 1925 self.__UndoToken() 1926 if self.__GetRegionLayout(Fd): 1927 return True 1928 raise Warning("A valid region type was not found. " 1929 "Valid types are [SET, FV, CAPSULE, FILE, DATA, INF]. This error occurred", 1930 self.FileName, self.CurrentLineNumber) 1931 1932 return True 1933 1934 ## __GetRegionFvType() method 1935 # 1936 # Get region fv data for region 1937 # 1938 # @param self The object pointer 1939 # @param RegionObj for whom region data is got 1940 # 1941 def __GetRegionFvType(self, RegionObj): 1942 1943 if not self.__IsKeyword( "FV"): 1944 raise Warning("expected Keyword 'FV'", self.FileName, self.CurrentLineNumber) 1945 1946 if not self.__IsToken( "="): 1947 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1948 1949 if not self.__GetNextToken(): 1950 raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) 1951 1952 RegionObj.RegionType = "FV" 1953 RegionObj.RegionDataList.append((self.__Token).upper()) 1954 1955 while self.__IsKeyword( "FV"): 1956 1957 if not self.__IsToken( "="): 1958 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1959 1960 if not self.__GetNextToken(): 1961 raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) 1962 1963 RegionObj.RegionDataList.append((self.__Token).upper()) 1964 1965 ## __GetRegionCapType() method 1966 # 1967 # Get region capsule data for region 1968 # 1969 # @param self The object pointer 1970 # @param RegionObj for whom region data is got 1971 # 1972 def __GetRegionCapType(self, RegionObj): 1973 1974 if not self.__IsKeyword("CAPSULE"): 1975 raise Warning("expected Keyword 'CAPSULE'", self.FileName, self.CurrentLineNumber) 1976 1977 if not self.__IsToken("="): 1978 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1979 1980 if not self.__GetNextToken(): 1981 raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber) 1982 1983 RegionObj.RegionType = "CAPSULE" 1984 RegionObj.RegionDataList.append(self.__Token) 1985 1986 while self.__IsKeyword("CAPSULE"): 1987 1988 if not self.__IsToken("="): 1989 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 1990 1991 if not self.__GetNextToken(): 1992 raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber) 1993 1994 RegionObj.RegionDataList.append(self.__Token) 1995 1996 ## __GetRegionFileType() method 1997 # 1998 # Get region file data for region 1999 # 2000 # @param self The object pointer 2001 # @param RegionObj for whom region data is got 2002 # 2003 def __GetRegionFileType(self, RegionObj): 2004 2005 if not self.__IsKeyword( "FILE"): 2006 raise Warning("expected Keyword 'FILE'", self.FileName, self.CurrentLineNumber) 2007 2008 if not self.__IsToken( "="): 2009 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2010 2011 if not self.__GetNextToken(): 2012 raise Warning("expected File name", self.FileName, self.CurrentLineNumber) 2013 2014 RegionObj.RegionType = "FILE" 2015 RegionObj.RegionDataList.append( self.__Token) 2016 2017 while self.__IsKeyword( "FILE"): 2018 2019 if not self.__IsToken( "="): 2020 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2021 2022 if not self.__GetNextToken(): 2023 raise Warning("expected FILE name", self.FileName, self.CurrentLineNumber) 2024 2025 RegionObj.RegionDataList.append(self.__Token) 2026 2027 ## __GetRegionDataType() method 2028 # 2029 # Get region array data for region 2030 # 2031 # @param self The object pointer 2032 # @param RegionObj for whom region data is got 2033 # 2034 def __GetRegionDataType(self, RegionObj): 2035 2036 if not self.__IsKeyword( "DATA"): 2037 raise Warning("expected Region Data type", self.FileName, self.CurrentLineNumber) 2038 2039 if not self.__IsToken( "="): 2040 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2041 2042 if not self.__IsToken( "{"): 2043 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 2044 2045 if not self.__GetNextHexNumber(): 2046 raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber) 2047 2048 if len(self.__Token) > 18: 2049 raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber) 2050 2051 # convert hex string value to byte hex string array 2052 AllString = self.__Token 2053 AllStrLen = len (AllString) 2054 DataString = "" 2055 while AllStrLen > 4: 2056 DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + "," 2057 AllStrLen = AllStrLen - 2 2058 DataString = DataString + AllString[:AllStrLen] + "," 2059 2060 # byte value array 2061 if len (self.__Token) <= 4: 2062 while self.__IsToken(","): 2063 if not self.__GetNextHexNumber(): 2064 raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber) 2065 if len(self.__Token) > 4: 2066 raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) 2067 DataString += self.__Token 2068 DataString += "," 2069 2070 if not self.__IsToken( "}"): 2071 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2072 2073 DataString = DataString.rstrip(",") 2074 RegionObj.RegionType = "DATA" 2075 RegionObj.RegionDataList.append( DataString) 2076 2077 while self.__IsKeyword( "DATA"): 2078 2079 if not self.__IsToken( "="): 2080 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2081 2082 if not self.__IsToken( "{"): 2083 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 2084 2085 if not self.__GetNextHexNumber(): 2086 raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber) 2087 2088 if len(self.__Token) > 18: 2089 raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber) 2090 2091 # convert hex string value to byte hex string array 2092 AllString = self.__Token 2093 AllStrLen = len (AllString) 2094 DataString = "" 2095 while AllStrLen > 4: 2096 DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + "," 2097 AllStrLen = AllStrLen - 2 2098 DataString = DataString + AllString[:AllStrLen] + "," 2099 2100 # byte value array 2101 if len (self.__Token) <= 4: 2102 while self.__IsToken(","): 2103 if not self.__GetNextHexNumber(): 2104 raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber) 2105 if len(self.__Token) > 4: 2106 raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) 2107 DataString += self.__Token 2108 DataString += "," 2109 2110 if not self.__IsToken( "}"): 2111 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2112 2113 DataString = DataString.rstrip(",") 2114 RegionObj.RegionDataList.append( DataString) 2115 2116 ## __GetFv() method 2117 # 2118 # Get FV section contents and store its data into FV dictionary of self.Profile 2119 # 2120 # @param self The object pointer 2121 # @retval True Successfully find a FV 2122 # @retval False Not able to find a FV 2123 # 2124 def __GetFv(self): 2125 if not self.__GetNextToken(): 2126 return False 2127 2128 S = self.__Token.upper() 2129 if S.startswith("[") and not S.startswith("[FV."): 2130 self.SectionParser(S) 2131 self.__UndoToken() 2132 return False 2133 2134 self.__UndoToken() 2135 if not self.__IsToken("[FV.", True): 2136 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 2137 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ 2138 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) 2139 raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2140 2141 FvName = self.__GetUiName() 2142 self.CurrentFvName = FvName.upper() 2143 2144 if not self.__IsToken( "]"): 2145 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 2146 2147 FvObj = Fv.FV() 2148 FvObj.UiFvName = self.CurrentFvName 2149 self.Profile.FvDict[self.CurrentFvName] = FvObj 2150 2151 Status = self.__GetCreateFile(FvObj) 2152 if not Status: 2153 raise Warning("FV name error", self.FileName, self.CurrentLineNumber) 2154 2155 self.__GetDefineStatements(FvObj) 2156 2157 self.__GetAddressStatements(FvObj) 2158 2159 FvObj.FvExtEntryTypeValue = [] 2160 FvObj.FvExtEntryType = [] 2161 FvObj.FvExtEntryData = [] 2162 while True: 2163 self.__GetSetStatements(FvObj) 2164 2165 if not (self.__GetBlockStatement(FvObj) or self.__GetFvBaseAddress(FvObj) or 2166 self.__GetFvForceRebase(FvObj) or self.__GetFvAlignment(FvObj) or 2167 self.__GetFvAttributes(FvObj) or self.__GetFvNameGuid(FvObj) or 2168 self.__GetFvExtEntryStatement(FvObj) or self.__GetFvNameString(FvObj)): 2169 break 2170 2171 if FvObj.FvNameString == 'TRUE' and not FvObj.FvNameGuid: 2172 raise Warning("FvNameString found but FvNameGuid was not found", self.FileName, self.CurrentLineNumber) 2173 2174 self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy()) 2175 self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy()) 2176 2177 while True: 2178 isInf = self.__GetInfStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy()) 2179 isFile = self.__GetFileStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy()) 2180 if not isInf and not isFile: 2181 break 2182 2183 return True 2184 2185 ## __GetFvAlignment() method 2186 # 2187 # Get alignment for FV 2188 # 2189 # @param self The object pointer 2190 # @param Obj for whom alignment is got 2191 # @retval True Successfully find a alignment statement 2192 # @retval False Not able to find a alignment statement 2193 # 2194 def __GetFvAlignment(self, Obj): 2195 2196 if not self.__IsKeyword( "FvAlignment"): 2197 return False 2198 2199 if not self.__IsToken( "="): 2200 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2201 2202 if not self.__GetNextToken(): 2203 raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber) 2204 2205 if self.__Token.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \ 2206 "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \ 2207 "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \ 2208 "1G", "2G"): 2209 raise Warning("Unknown alignment value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2210 Obj.FvAlignment = self.__Token 2211 return True 2212 2213 ## __GetFvBaseAddress() method 2214 # 2215 # Get BaseAddress for FV 2216 # 2217 # @param self The object pointer 2218 # @param Obj for whom FvBaseAddress is got 2219 # @retval True Successfully find a FvBaseAddress statement 2220 # @retval False Not able to find a FvBaseAddress statement 2221 # 2222 def __GetFvBaseAddress(self, Obj): 2223 2224 if not self.__IsKeyword("FvBaseAddress"): 2225 return False 2226 2227 if not self.__IsToken( "="): 2228 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2229 2230 if not self.__GetNextToken(): 2231 raise Warning("expected FV base address value", self.FileName, self.CurrentLineNumber) 2232 2233 IsValidBaseAddrValue = re.compile('^0[x|X][0-9a-fA-F]+') 2234 2235 if not IsValidBaseAddrValue.match(self.__Token.upper()): 2236 raise Warning("Unknown FV base address value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2237 Obj.FvBaseAddress = self.__Token 2238 return True 2239 2240 ## __GetFvForceRebase() method 2241 # 2242 # Get FvForceRebase for FV 2243 # 2244 # @param self The object pointer 2245 # @param Obj for whom FvForceRebase is got 2246 # @retval True Successfully find a FvForceRebase statement 2247 # @retval False Not able to find a FvForceRebase statement 2248 # 2249 def __GetFvForceRebase(self, Obj): 2250 2251 if not self.__IsKeyword("FvForceRebase"): 2252 return False 2253 2254 if not self.__IsToken( "="): 2255 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2256 2257 if not self.__GetNextToken(): 2258 raise Warning("expected FvForceRebase value", self.FileName, self.CurrentLineNumber) 2259 2260 if self.__Token.upper() not in ["TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"]: 2261 raise Warning("Unknown FvForceRebase value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2262 2263 if self.__Token.upper() in ["TRUE", "1", "0X1", "0X01"]: 2264 Obj.FvForceRebase = True 2265 elif self.__Token.upper() in ["FALSE", "0", "0X0", "0X00"]: 2266 Obj.FvForceRebase = False 2267 else: 2268 Obj.FvForceRebase = None 2269 2270 return True 2271 2272 2273 ## __GetFvAttributes() method 2274 # 2275 # Get attributes for FV 2276 # 2277 # @param self The object pointer 2278 # @param Obj for whom attribute is got 2279 # @retval None 2280 # 2281 def __GetFvAttributes(self, FvObj): 2282 IsWordToken = False 2283 while self.__GetNextWord(): 2284 IsWordToken = True 2285 name = self.__Token 2286 if name not in ("ERASE_POLARITY", "MEMORY_MAPPED", \ 2287 "STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \ 2288 "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \ 2289 "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \ 2290 "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \ 2291 "WRITE_POLICY_RELIABLE", "WEAK_ALIGNMENT"): 2292 self.__UndoToken() 2293 return False 2294 2295 if not self.__IsToken( "="): 2296 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2297 2298 if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"): 2299 raise Warning("expected TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber) 2300 2301 FvObj.FvAttributeDict[name] = self.__Token 2302 2303 return IsWordToken 2304 2305 ## __GetFvNameGuid() method 2306 # 2307 # Get FV GUID for FV 2308 # 2309 # @param self The object pointer 2310 # @param Obj for whom GUID is got 2311 # @retval None 2312 # 2313 def __GetFvNameGuid(self, FvObj): 2314 2315 if not self.__IsKeyword( "FvNameGuid"): 2316 return False 2317 2318 if not self.__IsToken( "="): 2319 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2320 2321 if not self.__GetNextGuid(): 2322 raise Warning("expected FV GUID value", self.FileName, self.CurrentLineNumber) 2323 2324 FvObj.FvNameGuid = self.__Token 2325 2326 return True 2327 2328 def __GetFvNameString(self, FvObj): 2329 2330 if not self.__IsKeyword( "FvNameString"): 2331 return False 2332 2333 if not self.__IsToken( "="): 2334 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2335 2336 if not self.__GetNextToken() or self.__Token not in ('TRUE', 'FALSE'): 2337 raise Warning("expected TRUE or FALSE for FvNameString", self.FileName, self.CurrentLineNumber) 2338 2339 FvObj.FvNameString = self.__Token 2340 2341 return True 2342 2343 def __GetFvExtEntryStatement(self, FvObj): 2344 2345 if not self.__IsKeyword( "FV_EXT_ENTRY"): 2346 return False 2347 2348 if not self.__IsKeyword ("TYPE"): 2349 raise Warning("expected 'TYPE'", self.FileName, self.CurrentLineNumber) 2350 2351 if not self.__IsToken( "="): 2352 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2353 2354 if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber(): 2355 raise Warning("expected Hex FV extension entry type value At Line ", self.FileName, self.CurrentLineNumber) 2356 2357 FvObj.FvExtEntryTypeValue += [self.__Token] 2358 2359 if not self.__IsToken( "{"): 2360 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 2361 2362 if not self.__IsKeyword ("FILE") and not self.__IsKeyword ("DATA"): 2363 raise Warning("expected 'FILE' or 'DATA'", self.FileName, self.CurrentLineNumber) 2364 2365 FvObj.FvExtEntryType += [self.__Token] 2366 2367 if self.__Token == 'DATA': 2368 2369 if not self.__IsToken( "="): 2370 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2371 2372 if not self.__IsToken( "{"): 2373 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 2374 2375 if not self.__GetNextHexNumber(): 2376 raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber) 2377 2378 if len(self.__Token) > 4: 2379 raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) 2380 2381 DataString = self.__Token 2382 DataString += "," 2383 2384 while self.__IsToken(","): 2385 if not self.__GetNextHexNumber(): 2386 raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber) 2387 if len(self.__Token) > 4: 2388 raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) 2389 DataString += self.__Token 2390 DataString += "," 2391 2392 if not self.__IsToken( "}"): 2393 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2394 2395 if not self.__IsToken( "}"): 2396 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2397 2398 DataString = DataString.rstrip(",") 2399 FvObj.FvExtEntryData += [DataString] 2400 2401 if self.__Token == 'FILE': 2402 2403 if not self.__IsToken( "="): 2404 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2405 2406 if not self.__GetNextToken(): 2407 raise Warning("expected FV Extension Entry file path At Line ", self.FileName, self.CurrentLineNumber) 2408 2409 FvObj.FvExtEntryData += [self.__Token] 2410 2411 if not self.__IsToken( "}"): 2412 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2413 2414 return True 2415 2416 ## __GetAprioriSection() method 2417 # 2418 # Get token statements 2419 # 2420 # @param self The object pointer 2421 # @param FvObj for whom apriori is got 2422 # @param MacroDict dictionary used to replace macro 2423 # @retval True Successfully find apriori statement 2424 # @retval False Not able to find apriori statement 2425 # 2426 def __GetAprioriSection(self, FvObj, MacroDict = {}): 2427 2428 if not self.__IsKeyword( "APRIORI"): 2429 return False 2430 2431 if not self.__IsKeyword("PEI") and not self.__IsKeyword("DXE"): 2432 raise Warning("expected Apriori file type", self.FileName, self.CurrentLineNumber) 2433 AprType = self.__Token 2434 2435 if not self.__IsToken( "{"): 2436 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 2437 2438 AprSectionObj = AprioriSection.AprioriSection() 2439 AprSectionObj.AprioriType = AprType 2440 2441 self.__GetDefineStatements(AprSectionObj) 2442 MacroDict.update(AprSectionObj.DefineVarDict) 2443 2444 while True: 2445 IsInf = self.__GetInfStatement( AprSectionObj, MacroDict = MacroDict) 2446 IsFile = self.__GetFileStatement( AprSectionObj) 2447 if not IsInf and not IsFile: 2448 break 2449 2450 if not self.__IsToken( "}"): 2451 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2452 2453 FvObj.AprioriSectionList.append(AprSectionObj) 2454 return True 2455 2456 def __ParseInfStatement(self): 2457 if not self.__IsKeyword("INF"): 2458 return None 2459 2460 ffsInf = FfsInfStatement.FfsInfStatement() 2461 self.__GetInfOptions(ffsInf) 2462 2463 if not self.__GetNextToken(): 2464 raise Warning("expected INF file path", self.FileName, self.CurrentLineNumber) 2465 ffsInf.InfFileName = self.__Token 2466 2467 ffsInf.CurrentLineNum = self.CurrentLineNumber 2468 ffsInf.CurrentLineContent = self.__CurrentLine() 2469 2470 #Replace $(SAPCE) with real space 2471 ffsInf.InfFileName = ffsInf.InfFileName.replace('$(SPACE)', ' ') 2472 2473 if ffsInf.InfFileName.replace('$(WORKSPACE)', '').find('$') == -1: 2474 #do case sensitive check for file path 2475 ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() 2476 if ErrorCode != 0: 2477 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) 2478 2479 if not ffsInf.InfFileName in self.Profile.InfList: 2480 self.Profile.InfList.append(ffsInf.InfFileName) 2481 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 2482 self.Profile.InfFileLineList.append(FileLineTuple) 2483 if ffsInf.UseArch: 2484 if ffsInf.UseArch not in self.Profile.InfDict: 2485 self.Profile.InfDict[ffsInf.UseArch] = [ffsInf.InfFileName] 2486 else: 2487 self.Profile.InfDict[ffsInf.UseArch].append(ffsInf.InfFileName) 2488 else: 2489 self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName) 2490 2491 if self.__IsToken('|'): 2492 if self.__IsKeyword('RELOCS_STRIPPED'): 2493 ffsInf.KeepReloc = False 2494 elif self.__IsKeyword('RELOCS_RETAINED'): 2495 ffsInf.KeepReloc = True 2496 else: 2497 raise Warning("Unknown reloc strip flag '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2498 return ffsInf 2499 2500 ## __GetInfStatement() method 2501 # 2502 # Get INF statements 2503 # 2504 # @param self The object pointer 2505 # @param Obj for whom inf statement is got 2506 # @param MacroDict dictionary used to replace macro 2507 # @retval True Successfully find inf statement 2508 # @retval False Not able to find inf statement 2509 # 2510 def __GetInfStatement(self, Obj, ForCapsule=False, MacroDict={}): 2511 ffsInf = self.__ParseInfStatement() 2512 if not ffsInf: 2513 return False 2514 2515 if ForCapsule: 2516 capsuleFfs = CapsuleData.CapsuleFfs() 2517 capsuleFfs.Ffs = ffsInf 2518 Obj.CapsuleDataList.append(capsuleFfs) 2519 else: 2520 Obj.FfsList.append(ffsInf) 2521 return True 2522 2523 ## __GetInfOptions() method 2524 # 2525 # Get options for INF 2526 # 2527 # @param self The object pointer 2528 # @param FfsInfObj for whom option is got 2529 # 2530 def __GetInfOptions(self, FfsInfObj): 2531 if self.__IsKeyword("FILE_GUID"): 2532 if not self.__IsToken("="): 2533 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2534 if not self.__GetNextGuid(): 2535 raise Warning("expected GUID value", self.FileName, self.CurrentLineNumber) 2536 FfsInfObj.OverrideGuid = self.__Token 2537 2538 if self.__IsKeyword( "RuleOverride"): 2539 if not self.__IsToken( "="): 2540 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2541 if not self.__GetNextToken(): 2542 raise Warning("expected Rule name", self.FileName, self.CurrentLineNumber) 2543 FfsInfObj.Rule = self.__Token 2544 2545 if self.__IsKeyword( "VERSION"): 2546 if not self.__IsToken( "="): 2547 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2548 if not self.__GetNextToken(): 2549 raise Warning("expected Version", self.FileName, self.CurrentLineNumber) 2550 2551 if self.__GetStringData(): 2552 FfsInfObj.Version = self.__Token 2553 2554 if self.__IsKeyword( "UI"): 2555 if not self.__IsToken( "="): 2556 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2557 if not self.__GetNextToken(): 2558 raise Warning("expected UI name", self.FileName, self.CurrentLineNumber) 2559 2560 if self.__GetStringData(): 2561 FfsInfObj.Ui = self.__Token 2562 2563 if self.__IsKeyword( "USE"): 2564 if not self.__IsToken( "="): 2565 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2566 if not self.__GetNextToken(): 2567 raise Warning("expected ARCH name", self.FileName, self.CurrentLineNumber) 2568 FfsInfObj.UseArch = self.__Token 2569 2570 2571 if self.__GetNextToken(): 2572 p = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\))') 2573 if p.match(self.__Token) and p.match(self.__Token).span()[1] == len(self.__Token): 2574 FfsInfObj.KeyStringList.append(self.__Token) 2575 if not self.__IsToken(","): 2576 return 2577 else: 2578 self.__UndoToken() 2579 return 2580 2581 while self.__GetNextToken(): 2582 if not p.match(self.__Token): 2583 raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber) 2584 FfsInfObj.KeyStringList.append(self.__Token) 2585 2586 if not self.__IsToken(","): 2587 break 2588 2589 ## __GetFileStatement() method 2590 # 2591 # Get FILE statements 2592 # 2593 # @param self The object pointer 2594 # @param Obj for whom FILE statement is got 2595 # @param MacroDict dictionary used to replace macro 2596 # @retval True Successfully find FILE statement 2597 # @retval False Not able to find FILE statement 2598 # 2599 def __GetFileStatement(self, Obj, ForCapsule = False, MacroDict = {}): 2600 2601 if not self.__IsKeyword( "FILE"): 2602 return False 2603 2604 if not self.__GetNextWord(): 2605 raise Warning("expected FFS type", self.FileName, self.CurrentLineNumber) 2606 2607 if ForCapsule and self.__Token == 'DATA': 2608 self.__UndoToken() 2609 self.__UndoToken() 2610 return False 2611 2612 FfsFileObj = FfsFileStatement.FileStatement() 2613 FfsFileObj.FvFileType = self.__Token 2614 2615 if not self.__IsToken( "="): 2616 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2617 2618 if not self.__GetNextGuid(): 2619 if not self.__GetNextWord(): 2620 raise Warning("expected File GUID", self.FileName, self.CurrentLineNumber) 2621 if self.__Token == 'PCD': 2622 if not self.__IsToken( "("): 2623 raise Warning("expected '('", self.FileName, self.CurrentLineNumber) 2624 PcdPair = self.__GetNextPcdName() 2625 if not self.__IsToken( ")"): 2626 raise Warning("expected ')'", self.FileName, self.CurrentLineNumber) 2627 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')' 2628 2629 FfsFileObj.NameGuid = self.__Token 2630 2631 self.__GetFilePart( FfsFileObj, MacroDict.copy()) 2632 2633 if ForCapsule: 2634 capsuleFfs = CapsuleData.CapsuleFfs() 2635 capsuleFfs.Ffs = FfsFileObj 2636 Obj.CapsuleDataList.append(capsuleFfs) 2637 else: 2638 Obj.FfsList.append(FfsFileObj) 2639 2640 return True 2641 2642 ## __FileCouldHaveRelocFlag() method 2643 # 2644 # Check whether reloc strip flag can be set for a file type. 2645 # 2646 # @param self The object pointer 2647 # @param FileType The file type to check with 2648 # @retval True This type could have relocation strip flag 2649 # @retval False No way to have it 2650 # 2651 2652 def __FileCouldHaveRelocFlag (self, FileType): 2653 if FileType in ('SEC', 'PEI_CORE', 'PEIM', 'PEI_DXE_COMBO'): 2654 return True 2655 else: 2656 return False 2657 2658 ## __SectionCouldHaveRelocFlag() method 2659 # 2660 # Check whether reloc strip flag can be set for a section type. 2661 # 2662 # @param self The object pointer 2663 # @param SectionType The section type to check with 2664 # @retval True This type could have relocation strip flag 2665 # @retval False No way to have it 2666 # 2667 2668 def __SectionCouldHaveRelocFlag (self, SectionType): 2669 if SectionType in ('TE', 'PE32'): 2670 return True 2671 else: 2672 return False 2673 2674 ## __GetFilePart() method 2675 # 2676 # Get components for FILE statement 2677 # 2678 # @param self The object pointer 2679 # @param FfsFileObj for whom component is got 2680 # @param MacroDict dictionary used to replace macro 2681 # 2682 def __GetFilePart(self, FfsFileObj, MacroDict = {}): 2683 2684 self.__GetFileOpts( FfsFileObj) 2685 2686 if not self.__IsToken("{"): 2687 if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): 2688 if self.__FileCouldHaveRelocFlag(FfsFileObj.FvFileType): 2689 if self.__Token == 'RELOCS_STRIPPED': 2690 FfsFileObj.KeepReloc = False 2691 else: 2692 FfsFileObj.KeepReloc = True 2693 else: 2694 raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) 2695 2696 if not self.__IsToken("{"): 2697 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 2698 2699 if not self.__GetNextToken(): 2700 raise Warning("expected File name or section data", self.FileName, self.CurrentLineNumber) 2701 2702 if self.__Token == "FV": 2703 if not self.__IsToken( "="): 2704 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2705 if not self.__GetNextToken(): 2706 raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) 2707 FfsFileObj.FvName = self.__Token 2708 2709 elif self.__Token == "FD": 2710 if not self.__IsToken( "="): 2711 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2712 if not self.__GetNextToken(): 2713 raise Warning("expected FD name", self.FileName, self.CurrentLineNumber) 2714 FfsFileObj.FdName = self.__Token 2715 2716 elif self.__Token in ("DEFINE", "APRIORI", "SECTION"): 2717 self.__UndoToken() 2718 self.__GetSectionData( FfsFileObj, MacroDict) 2719 2720 elif hasattr(FfsFileObj, 'FvFileType') and FfsFileObj.FvFileType == 'RAW': 2721 self.__UndoToken() 2722 self.__GetRAWData(FfsFileObj, MacroDict) 2723 2724 else: 2725 FfsFileObj.CurrentLineNum = self.CurrentLineNumber 2726 FfsFileObj.CurrentLineContent = self.__CurrentLine() 2727 FfsFileObj.FileName = self.__Token.replace('$(SPACE)', ' ') 2728 self.__VerifyFile(FfsFileObj.FileName) 2729 2730 if not self.__IsToken( "}"): 2731 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2732 2733 ## __GetRAWData() method 2734 # 2735 # Get RAW data for FILE statement 2736 # 2737 # @param self The object pointer 2738 # @param FfsFileObj for whom section is got 2739 # @param MacroDict dictionary used to replace macro 2740 # 2741 def __GetRAWData(self, FfsFileObj, MacroDict = {}): 2742 FfsFileObj.FileName = [] 2743 FfsFileObj.SubAlignment = [] 2744 while True: 2745 AlignValue = None 2746 if self.__GetAlignment(): 2747 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 2748 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2749 #For FFS, Auto is default option same to "" 2750 if not self.__Token == "Auto": 2751 AlignValue = self.__Token 2752 if not self.__GetNextToken(): 2753 raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber) 2754 2755 FileName = self.__Token.replace('$(SPACE)', ' ') 2756 if FileName == '}': 2757 self.__UndoToken() 2758 raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber) 2759 2760 self.__VerifyFile(FileName) 2761 File = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir) 2762 FfsFileObj.FileName.append(File.Path) 2763 FfsFileObj.SubAlignment.append(AlignValue) 2764 2765 if self.__IsToken( "}"): 2766 self.__UndoToken() 2767 break 2768 2769 if len(FfsFileObj.SubAlignment) == 1: 2770 FfsFileObj.SubAlignment = FfsFileObj.SubAlignment[0] 2771 if len(FfsFileObj.FileName) == 1: 2772 FfsFileObj.FileName = FfsFileObj.FileName[0] 2773 2774 ## __GetFileOpts() method 2775 # 2776 # Get options for FILE statement 2777 # 2778 # @param self The object pointer 2779 # @param FfsFileObj for whom options is got 2780 # 2781 def __GetFileOpts(self, FfsFileObj): 2782 2783 if self.__GetNextToken(): 2784 Pattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)') 2785 if Pattern.match(self.__Token): 2786 FfsFileObj.KeyStringList.append(self.__Token) 2787 if self.__IsToken(","): 2788 while self.__GetNextToken(): 2789 if not Pattern.match(self.__Token): 2790 raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber) 2791 FfsFileObj.KeyStringList.append(self.__Token) 2792 2793 if not self.__IsToken(","): 2794 break 2795 2796 else: 2797 self.__UndoToken() 2798 2799 if self.__IsKeyword( "FIXED", True): 2800 FfsFileObj.Fixed = True 2801 2802 if self.__IsKeyword( "CHECKSUM", True): 2803 FfsFileObj.CheckSum = True 2804 2805 if self.__GetAlignment(): 2806 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 2807 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2808 #For FFS, Auto is default option same to "" 2809 if not self.__Token == "Auto": 2810 FfsFileObj.Alignment = self.__Token 2811 2812 ## __GetAlignment() method 2813 # 2814 # Return the alignment value 2815 # 2816 # @param self The object pointer 2817 # @retval True Successfully find alignment 2818 # @retval False Not able to find alignment 2819 # 2820 def __GetAlignment(self): 2821 if self.__IsKeyword( "Align", True): 2822 if not self.__IsToken( "="): 2823 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2824 2825 if not self.__GetNextToken(): 2826 raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber) 2827 return True 2828 2829 return False 2830 2831 ## __GetFilePart() method 2832 # 2833 # Get section data for FILE statement 2834 # 2835 # @param self The object pointer 2836 # @param FfsFileObj for whom section is got 2837 # @param MacroDict dictionary used to replace macro 2838 # 2839 def __GetSectionData(self, FfsFileObj, MacroDict = {}): 2840 Dict = {} 2841 Dict.update(MacroDict) 2842 2843 self.__GetDefineStatements(FfsFileObj) 2844 2845 Dict.update(FfsFileObj.DefineVarDict) 2846 self.__GetAprioriSection(FfsFileObj, Dict.copy()) 2847 self.__GetAprioriSection(FfsFileObj, Dict.copy()) 2848 2849 while True: 2850 IsLeafSection = self.__GetLeafSection(FfsFileObj, Dict) 2851 IsEncapSection = self.__GetEncapsulationSec(FfsFileObj) 2852 if not IsLeafSection and not IsEncapSection: 2853 break 2854 2855 ## __GetLeafSection() method 2856 # 2857 # Get leaf section for Obj 2858 # 2859 # @param self The object pointer 2860 # @param Obj for whom leaf section is got 2861 # @param MacroDict dictionary used to replace macro 2862 # @retval True Successfully find section statement 2863 # @retval False Not able to find section statement 2864 # 2865 def __GetLeafSection(self, Obj, MacroDict = {}): 2866 2867 OldPos = self.GetFileBufferPos() 2868 2869 if not self.__IsKeyword( "SECTION"): 2870 if len(Obj.SectionList) == 0: 2871 raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber) 2872 else: 2873 return False 2874 2875 AlignValue = None 2876 if self.__GetAlignment(): 2877 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 2878 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2879 AlignValue = self.__Token 2880 2881 BuildNum = None 2882 if self.__IsKeyword( "BUILD_NUM"): 2883 if not self.__IsToken( "="): 2884 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2885 2886 if not self.__GetNextToken(): 2887 raise Warning("expected Build number value", self.FileName, self.CurrentLineNumber) 2888 2889 BuildNum = self.__Token 2890 2891 if self.__IsKeyword( "VERSION"): 2892 if AlignValue == 'Auto': 2893 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) 2894 if not self.__IsToken( "="): 2895 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2896 if not self.__GetNextToken(): 2897 raise Warning("expected version", self.FileName, self.CurrentLineNumber) 2898 VerSectionObj = VerSection.VerSection() 2899 VerSectionObj.Alignment = AlignValue 2900 VerSectionObj.BuildNum = BuildNum 2901 if self.__GetStringData(): 2902 VerSectionObj.StringData = self.__Token 2903 else: 2904 VerSectionObj.FileName = self.__Token 2905 Obj.SectionList.append(VerSectionObj) 2906 2907 elif self.__IsKeyword( "UI"): 2908 if AlignValue == 'Auto': 2909 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) 2910 if not self.__IsToken( "="): 2911 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2912 if not self.__GetNextToken(): 2913 raise Warning("expected UI", self.FileName, self.CurrentLineNumber) 2914 UiSectionObj = UiSection.UiSection() 2915 UiSectionObj.Alignment = AlignValue 2916 if self.__GetStringData(): 2917 UiSectionObj.StringData = self.__Token 2918 else: 2919 UiSectionObj.FileName = self.__Token 2920 Obj.SectionList.append(UiSectionObj) 2921 2922 elif self.__IsKeyword( "FV_IMAGE"): 2923 if AlignValue == 'Auto': 2924 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) 2925 if not self.__IsToken( "="): 2926 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2927 if not self.__GetNextToken(): 2928 raise Warning("expected FV name or FV file path", self.FileName, self.CurrentLineNumber) 2929 2930 FvName = self.__Token 2931 FvObj = None 2932 2933 if self.__IsToken( "{"): 2934 FvObj = Fv.FV() 2935 FvObj.UiFvName = FvName.upper() 2936 self.__GetDefineStatements(FvObj) 2937 MacroDict.update(FvObj.DefineVarDict) 2938 self.__GetBlockStatement(FvObj) 2939 self.__GetSetStatements(FvObj) 2940 self.__GetFvAlignment(FvObj) 2941 self.__GetFvAttributes(FvObj) 2942 self.__GetAprioriSection(FvObj, MacroDict.copy()) 2943 self.__GetAprioriSection(FvObj, MacroDict.copy()) 2944 2945 while True: 2946 IsInf = self.__GetInfStatement(FvObj, MacroDict.copy()) 2947 IsFile = self.__GetFileStatement(FvObj, MacroDict.copy()) 2948 if not IsInf and not IsFile: 2949 break 2950 2951 if not self.__IsToken( "}"): 2952 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 2953 2954 FvImageSectionObj = FvImageSection.FvImageSection() 2955 FvImageSectionObj.Alignment = AlignValue 2956 if FvObj != None: 2957 FvImageSectionObj.Fv = FvObj 2958 FvImageSectionObj.FvName = None 2959 else: 2960 FvImageSectionObj.FvName = FvName.upper() 2961 FvImageSectionObj.FvFileName = FvName 2962 2963 Obj.SectionList.append(FvImageSectionObj) 2964 2965 elif self.__IsKeyword("PEI_DEPEX_EXP") or self.__IsKeyword("DXE_DEPEX_EXP") or self.__IsKeyword("SMM_DEPEX_EXP"): 2966 if AlignValue == 'Auto': 2967 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) 2968 DepexSectionObj = DepexSection.DepexSection() 2969 DepexSectionObj.Alignment = AlignValue 2970 DepexSectionObj.DepexType = self.__Token 2971 2972 if not self.__IsToken( "="): 2973 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 2974 if not self.__IsToken( "{"): 2975 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 2976 if not self.__SkipToToken( "}"): 2977 raise Warning("expected Depex expression ending '}'", self.FileName, self.CurrentLineNumber) 2978 2979 DepexSectionObj.Expression = self.__SkippedChars.rstrip('}') 2980 Obj.SectionList.append(DepexSectionObj) 2981 2982 else: 2983 if not self.__GetNextWord(): 2984 raise Warning("expected section type", self.FileName, self.CurrentLineNumber) 2985 2986 # Encapsulation section appear, UndoToken and return 2987 if self.__Token == "COMPRESS" or self.__Token == "GUIDED": 2988 self.SetFileBufferPos(OldPos) 2989 return False 2990 2991 if self.__Token not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\ 2992 "UI", "VERSION", "PEI_DEPEX", "SUBTYPE_GUID", "SMM_DEPEX"): 2993 raise Warning("Unknown section type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 2994 if AlignValue == 'Auto'and (not self.__Token == 'PE32') and (not self.__Token == 'TE'): 2995 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) 2996 2997 # DataSection 2998 DataSectionObj = DataSection.DataSection() 2999 DataSectionObj.Alignment = AlignValue 3000 DataSectionObj.SecType = self.__Token 3001 3002 if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): 3003 if self.__FileCouldHaveRelocFlag(Obj.FvFileType) and self.__SectionCouldHaveRelocFlag(DataSectionObj.SecType): 3004 if self.__Token == 'RELOCS_STRIPPED': 3005 DataSectionObj.KeepReloc = False 3006 else: 3007 DataSectionObj.KeepReloc = True 3008 else: 3009 raise Warning("File type %s, section type %s, could not have reloc strip flag%d" % (Obj.FvFileType, DataSectionObj.SecType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) 3010 3011 if self.__IsToken("="): 3012 if not self.__GetNextToken(): 3013 raise Warning("expected section file path", self.FileName, self.CurrentLineNumber) 3014 DataSectionObj.SectFileName = self.__Token 3015 self.__VerifyFile(DataSectionObj.SectFileName) 3016 else: 3017 if not self.__GetCglSection(DataSectionObj): 3018 return False 3019 3020 Obj.SectionList.append(DataSectionObj) 3021 3022 return True 3023 3024 ## __VerifyFile 3025 # 3026 # Check if file exists or not: 3027 # If current phase if GenFds, the file must exist; 3028 # If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist 3029 # @param FileName: File path to be verified. 3030 # 3031 def __VerifyFile(self, FileName): 3032 if FileName.replace('$(WORKSPACE)', '').find('$') != -1: 3033 return 3034 if not GlobalData.gAutoGenPhase or not self.__GetMacroValue("OUTPUT_DIRECTORY") in FileName: 3035 ErrorCode, ErrorInfo = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() 3036 if ErrorCode != 0: 3037 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) 3038 3039 ## __GetCglSection() method 3040 # 3041 # Get compressed or GUIDed section for Obj 3042 # 3043 # @param self The object pointer 3044 # @param Obj for whom leaf section is got 3045 # @param AlignValue alignment value for complex section 3046 # @retval True Successfully find section statement 3047 # @retval False Not able to find section statement 3048 # 3049 def __GetCglSection(self, Obj, AlignValue = None): 3050 3051 if self.__IsKeyword( "COMPRESS"): 3052 type = "PI_STD" 3053 if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"): 3054 type = self.__Token 3055 3056 if not self.__IsToken("{"): 3057 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 3058 3059 CompressSectionObj = CompressSection.CompressSection() 3060 CompressSectionObj.Alignment = AlignValue 3061 CompressSectionObj.CompType = type 3062 # Recursive sections... 3063 while True: 3064 IsLeafSection = self.__GetLeafSection(CompressSectionObj) 3065 IsEncapSection = self.__GetEncapsulationSec(CompressSectionObj) 3066 if not IsLeafSection and not IsEncapSection: 3067 break 3068 3069 3070 if not self.__IsToken( "}"): 3071 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 3072 Obj.SectionList.append(CompressSectionObj) 3073 3074 # else: 3075 # raise Warning("Compress type not known") 3076 3077 return True 3078 3079 elif self.__IsKeyword( "GUIDED"): 3080 GuidValue = None 3081 if self.__GetNextGuid(): 3082 GuidValue = self.__Token 3083 3084 AttribDict = self.__GetGuidAttrib() 3085 if not self.__IsToken("{"): 3086 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 3087 GuidSectionObj = GuidSection.GuidSection() 3088 GuidSectionObj.Alignment = AlignValue 3089 GuidSectionObj.NameGuid = GuidValue 3090 GuidSectionObj.SectionType = "GUIDED" 3091 GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"] 3092 GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"] 3093 GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"] 3094 # Recursive sections... 3095 while True: 3096 IsLeafSection = self.__GetLeafSection(GuidSectionObj) 3097 IsEncapSection = self.__GetEncapsulationSec(GuidSectionObj) 3098 if not IsLeafSection and not IsEncapSection: 3099 break 3100 3101 if not self.__IsToken( "}"): 3102 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 3103 Obj.SectionList.append(GuidSectionObj) 3104 3105 return True 3106 3107 return False 3108 3109 ## __GetGuidAttri() method 3110 # 3111 # Get attributes for GUID section 3112 # 3113 # @param self The object pointer 3114 # @retval AttribDict Dictionary of key-value pair of section attributes 3115 # 3116 def __GetGuidAttrib(self): 3117 3118 AttribDict = {} 3119 AttribDict["PROCESSING_REQUIRED"] = "NONE" 3120 AttribDict["AUTH_STATUS_VALID"] = "NONE" 3121 AttribDict["EXTRA_HEADER_SIZE"] = -1 3122 while self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID") \ 3123 or self.__IsKeyword("EXTRA_HEADER_SIZE"): 3124 AttribKey = self.__Token 3125 3126 if not self.__IsToken("="): 3127 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3128 3129 if not self.__GetNextToken(): 3130 raise Warning("expected TRUE(1)/FALSE(0)/Number", self.FileName, self.CurrentLineNumber) 3131 elif AttribKey == "EXTRA_HEADER_SIZE": 3132 Base = 10 3133 if self.__Token[0:2].upper() == "0X": 3134 Base = 16 3135 try: 3136 AttribDict[AttribKey] = int(self.__Token, Base) 3137 continue 3138 except ValueError: 3139 raise Warning("expected Number", self.FileName, self.CurrentLineNumber) 3140 elif self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"): 3141 raise Warning("expected TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber) 3142 AttribDict[AttribKey] = self.__Token 3143 3144 return AttribDict 3145 3146 ## __GetEncapsulationSec() method 3147 # 3148 # Get encapsulation section for FILE 3149 # 3150 # @param self The object pointer 3151 # @param FfsFile for whom section is got 3152 # @retval True Successfully find section statement 3153 # @retval False Not able to find section statement 3154 # 3155 def __GetEncapsulationSec(self, FfsFileObj): 3156 3157 OldPos = self.GetFileBufferPos() 3158 if not self.__IsKeyword( "SECTION"): 3159 if len(FfsFileObj.SectionList) == 0: 3160 raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber) 3161 else: 3162 return False 3163 3164 AlignValue = None 3165 if self.__GetAlignment(): 3166 if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 3167 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3168 AlignValue = self.__Token 3169 3170 if not self.__GetCglSection(FfsFileObj, AlignValue): 3171 self.SetFileBufferPos(OldPos) 3172 return False 3173 else: 3174 return True 3175 3176 def __GetFmp(self): 3177 if not self.__GetNextToken(): 3178 return False 3179 S = self.__Token.upper() 3180 if S.startswith("[") and not S.startswith("[FMPPAYLOAD."): 3181 self.SectionParser(S) 3182 self.__UndoToken() 3183 return False 3184 3185 self.__UndoToken() 3186 self.__SkipToToken("[FMPPAYLOAD.", True) 3187 FmpUiName = self.__GetUiName().upper() 3188 if FmpUiName in self.Profile.FmpPayloadDict: 3189 raise Warning("Duplicated FMP UI name found: %s" % FmpUiName, self.FileName, self.CurrentLineNumber) 3190 3191 FmpData = CapsuleData.CapsulePayload() 3192 FmpData.UiName = FmpUiName 3193 3194 if not self.__IsToken( "]"): 3195 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 3196 3197 if not self.__GetNextToken(): 3198 raise Warning("The FMP payload section is empty!", self.FileName, self.CurrentLineNumber) 3199 FmpKeyList = ['IMAGE_HEADER_INIT_VERSION', 'IMAGE_TYPE_ID', 'IMAGE_INDEX', 'HARDWARE_INSTANCE', 'CERTIFICATE_GUID', 'MONOTONIC_COUNT'] 3200 while self.__Token in FmpKeyList: 3201 Name = self.__Token 3202 FmpKeyList.remove(Name) 3203 if not self.__IsToken("="): 3204 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3205 if Name == 'IMAGE_TYPE_ID': 3206 if not self.__GetNextGuid(): 3207 raise Warning("expected GUID value for IMAGE_TYPE_ID.", self.FileName, self.CurrentLineNumber) 3208 FmpData.ImageTypeId = self.__Token 3209 elif Name == 'CERTIFICATE_GUID': 3210 if not self.__GetNextGuid(): 3211 raise Warning("expected GUID value for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber) 3212 FmpData.Certificate_Guid = self.__Token 3213 if uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_RSA2048_SHA256_GUID and uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_PKCS7_GUID: 3214 raise Warning("Only support EFI_CERT_TYPE_RSA2048_SHA256_GUID or EFI_CERT_TYPE_PKCS7_GUID for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber) 3215 else: 3216 if not self.__GetNextToken(): 3217 raise Warning("expected value of %s" % Name, self.FileName, self.CurrentLineNumber) 3218 Value = self.__Token 3219 if Name == 'IMAGE_HEADER_INIT_VERSION': 3220 if self.__Verify(Name, Value, 'UINT8'): 3221 FmpData.Version = Value 3222 elif Name == 'IMAGE_INDEX': 3223 if self.__Verify(Name, Value, 'UINT8'): 3224 FmpData.ImageIndex = Value 3225 elif Name == 'HARDWARE_INSTANCE': 3226 if self.__Verify(Name, Value, 'UINT8'): 3227 FmpData.HardwareInstance = Value 3228 elif Name == 'MONOTONIC_COUNT': 3229 if self.__Verify(Name, Value, 'UINT64'): 3230 FmpData.MonotonicCount = Value 3231 if FmpData.MonotonicCount.upper().startswith('0X'): 3232 FmpData.MonotonicCount = (long)(FmpData.MonotonicCount, 16) 3233 else: 3234 FmpData.MonotonicCount = (long)(FmpData.MonotonicCount) 3235 if not self.__GetNextToken(): 3236 break 3237 else: 3238 self.__UndoToken() 3239 3240 if (FmpData.MonotonicCount and not FmpData.Certificate_Guid) or (not FmpData.MonotonicCount and FmpData.Certificate_Guid): 3241 EdkLogger.error("FdfParser", FORMAT_INVALID, "CERTIFICATE_GUID and MONOTONIC_COUNT must be work as a pair.") 3242 # remove CERTIFICATE_GUID and MONOTONIC_COUNT from FmpKeyList, since these keys are optional 3243 if 'CERTIFICATE_GUID' in FmpKeyList: 3244 FmpKeyList.remove('CERTIFICATE_GUID') 3245 if 'MONOTONIC_COUNT' in FmpKeyList: 3246 FmpKeyList.remove('MONOTONIC_COUNT') 3247 if FmpKeyList: 3248 raise Warning("Missing keywords %s in FMP payload section." % ', '.join(FmpKeyList), self.FileName, self.CurrentLineNumber) 3249 # get the Image file and Vendor code file 3250 self.__GetFMPCapsuleData(FmpData) 3251 if not FmpData.ImageFile: 3252 raise Warning("Missing image file in FMP payload section.", self.FileName, self.CurrentLineNumber) 3253 # check whether more than one Vendor code file 3254 if len(FmpData.VendorCodeFile) > 1: 3255 raise Warning("At most one Image file and one Vendor code file are allowed in FMP payload section.", self.FileName, self.CurrentLineNumber) 3256 self.Profile.FmpPayloadDict[FmpUiName] = FmpData 3257 return True 3258 3259 ## __GetCapsule() method 3260 # 3261 # Get capsule section contents and store its data into capsule list of self.Profile 3262 # 3263 # @param self The object pointer 3264 # @retval True Successfully find a capsule 3265 # @retval False Not able to find a capsule 3266 # 3267 def __GetCapsule(self): 3268 3269 if not self.__GetNextToken(): 3270 return False 3271 3272 S = self.__Token.upper() 3273 if S.startswith("[") and not S.startswith("[CAPSULE."): 3274 self.SectionParser(S) 3275 self.__UndoToken() 3276 return False 3277 3278 self.__UndoToken() 3279 if not self.__IsToken("[CAPSULE.", True): 3280 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 3281 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ 3282 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) 3283 raise Warning("expected [Capsule.]", self.FileName, self.CurrentLineNumber) 3284 3285 CapsuleObj = Capsule.Capsule() 3286 3287 CapsuleName = self.__GetUiName() 3288 if not CapsuleName: 3289 raise Warning("expected capsule name", self.FileName, self.CurrentLineNumber) 3290 3291 CapsuleObj.UiCapsuleName = CapsuleName.upper() 3292 3293 if not self.__IsToken( "]"): 3294 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 3295 3296 if self.__IsKeyword("CREATE_FILE"): 3297 if not self.__IsToken( "="): 3298 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3299 3300 if not self.__GetNextToken(): 3301 raise Warning("expected file name", self.FileName, self.CurrentLineNumber) 3302 3303 CapsuleObj.CreateFile = self.__Token 3304 3305 self.__GetCapsuleStatements(CapsuleObj) 3306 self.Profile.CapsuleDict[CapsuleObj.UiCapsuleName] = CapsuleObj 3307 return True 3308 3309 ## __GetCapsuleStatements() method 3310 # 3311 # Get statements for capsule 3312 # 3313 # @param self The object pointer 3314 # @param Obj for whom statements are got 3315 # 3316 def __GetCapsuleStatements(self, Obj): 3317 self.__GetCapsuleTokens(Obj) 3318 self.__GetDefineStatements(Obj) 3319 self.__GetSetStatements(Obj) 3320 self.__GetCapsuleData(Obj) 3321 3322 ## __GetCapsuleTokens() method 3323 # 3324 # Get token statements for capsule 3325 # 3326 # @param self The object pointer 3327 # @param Obj for whom token statements are got 3328 # 3329 def __GetCapsuleTokens(self, Obj): 3330 if not self.__GetNextToken(): 3331 return False 3332 while self.__Token in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"): 3333 Name = self.__Token.strip() 3334 if not self.__IsToken("="): 3335 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3336 if not self.__GetNextToken(): 3337 raise Warning("expected value", self.FileName, self.CurrentLineNumber) 3338 if Name == 'CAPSULE_FLAGS': 3339 if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"): 3340 raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber) 3341 Value = self.__Token.strip() 3342 while self.__IsToken(","): 3343 Value += ',' 3344 if not self.__GetNextToken(): 3345 raise Warning("expected value", self.FileName, self.CurrentLineNumber) 3346 if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"): 3347 raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber) 3348 Value += self.__Token.strip() 3349 elif Name == 'OEM_CAPSULE_FLAGS': 3350 Value = self.__Token.strip() 3351 if not Value.upper().startswith('0X'): 3352 raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber) 3353 try: 3354 Value = int(Value, 0) 3355 except ValueError: 3356 raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber) 3357 if not 0x0000 <= Value <= 0xFFFF: 3358 raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber) 3359 Value = self.__Token.strip() 3360 else: 3361 Value = self.__Token.strip() 3362 Obj.TokensDict[Name] = Value 3363 if not self.__GetNextToken(): 3364 return False 3365 self.__UndoToken() 3366 3367 ## __GetCapsuleData() method 3368 # 3369 # Get capsule data for capsule 3370 # 3371 # @param self The object pointer 3372 # @param Obj for whom capsule data are got 3373 # 3374 def __GetCapsuleData(self, Obj): 3375 3376 while True: 3377 IsInf = self.__GetInfStatement(Obj, True) 3378 IsFile = self.__GetFileStatement(Obj, True) 3379 IsFv = self.__GetFvStatement(Obj) 3380 IsFd = self.__GetFdStatement(Obj) 3381 IsAnyFile = self.__GetAnyFileStatement(Obj) 3382 IsAfile = self.__GetAfileStatement(Obj) 3383 IsFmp = self.__GetFmpStatement(Obj) 3384 if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile or IsAfile or IsFmp): 3385 break 3386 3387 ## __GetFMPCapsuleData() method 3388 # 3389 # Get capsule data for FMP capsule 3390 # 3391 # @param self The object pointer 3392 # @param Obj for whom capsule data are got 3393 # 3394 def __GetFMPCapsuleData(self, Obj): 3395 3396 while True: 3397 IsFv = self.__GetFvStatement(Obj, True) 3398 IsFd = self.__GetFdStatement(Obj, True) 3399 IsAnyFile = self.__GetAnyFileStatement(Obj, True) 3400 if not (IsFv or IsFd or IsAnyFile): 3401 break 3402 3403 ## __GetFvStatement() method 3404 # 3405 # Get FV for capsule 3406 # 3407 # @param self The object pointer 3408 # @param CapsuleObj for whom FV is got 3409 # @retval True Successfully find a FV statement 3410 # @retval False Not able to find a FV statement 3411 # 3412 def __GetFvStatement(self, CapsuleObj, FMPCapsule = False): 3413 3414 if not self.__IsKeyword("FV"): 3415 return False 3416 3417 if not self.__IsToken("="): 3418 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3419 3420 if not self.__GetNextToken(): 3421 raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) 3422 3423 if self.__Token.upper() not in self.Profile.FvDict.keys(): 3424 raise Warning("FV name does not exist", self.FileName, self.CurrentLineNumber) 3425 3426 CapsuleFv = CapsuleData.CapsuleFv() 3427 CapsuleFv.FvName = self.__Token 3428 if FMPCapsule: 3429 if not CapsuleObj.ImageFile: 3430 CapsuleObj.ImageFile.append(CapsuleFv) 3431 else: 3432 CapsuleObj.VendorCodeFile.append(CapsuleFv) 3433 else: 3434 CapsuleObj.CapsuleDataList.append(CapsuleFv) 3435 return True 3436 3437 ## __GetFdStatement() method 3438 # 3439 # Get FD for capsule 3440 # 3441 # @param self The object pointer 3442 # @param CapsuleObj for whom FD is got 3443 # @retval True Successfully find a FD statement 3444 # @retval False Not able to find a FD statement 3445 # 3446 def __GetFdStatement(self, CapsuleObj, FMPCapsule = False): 3447 3448 if not self.__IsKeyword("FD"): 3449 return False 3450 3451 if not self.__IsToken("="): 3452 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3453 3454 if not self.__GetNextToken(): 3455 raise Warning("expected FD name", self.FileName, self.CurrentLineNumber) 3456 3457 if self.__Token.upper() not in self.Profile.FdDict.keys(): 3458 raise Warning("FD name does not exist", self.FileName, self.CurrentLineNumber) 3459 3460 CapsuleFd = CapsuleData.CapsuleFd() 3461 CapsuleFd.FdName = self.__Token 3462 if FMPCapsule: 3463 if not CapsuleObj.ImageFile: 3464 CapsuleObj.ImageFile.append(CapsuleFd) 3465 else: 3466 CapsuleObj.VendorCodeFile.append(CapsuleFd) 3467 else: 3468 CapsuleObj.CapsuleDataList.append(CapsuleFd) 3469 return True 3470 3471 def __GetFmpStatement(self, CapsuleObj): 3472 if not self.__IsKeyword("FMP_PAYLOAD"): 3473 if not self.__IsKeyword("FMP"): 3474 return False 3475 3476 if not self.__IsKeyword("PAYLOAD"): 3477 self.__UndoToken() 3478 return False 3479 3480 if not self.__IsToken("="): 3481 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3482 3483 if not self.__GetNextToken(): 3484 raise Warning("expected payload name after FMP_PAYLOAD =", self.FileName, self.CurrentLineNumber) 3485 Payload = self.__Token.upper() 3486 if Payload not in self.Profile.FmpPayloadDict: 3487 raise Warning("This FMP Payload does not exist: %s" % self.__Token, self.FileName, self.CurrentLineNumber) 3488 CapsuleObj.FmpPayloadList.append(self.Profile.FmpPayloadDict[Payload]) 3489 return True 3490 3491 def __ParseRawFileStatement(self): 3492 if not self.__IsKeyword("FILE"): 3493 return None 3494 3495 if not self.__IsKeyword("DATA"): 3496 self.__UndoToken() 3497 return None 3498 3499 if not self.__IsToken("="): 3500 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3501 3502 if not self.__GetNextToken(): 3503 raise Warning("expected File name", self.FileName, self.CurrentLineNumber) 3504 3505 AnyFileName = self.__Token 3506 self.__VerifyFile(AnyFileName) 3507 3508 if not os.path.isabs(AnyFileName): 3509 AnyFileName = mws.join(GenFdsGlobalVariable.WorkSpaceDir, AnyFileName) 3510 3511 return AnyFileName 3512 3513 ## __GetAnyFileStatement() method 3514 # 3515 # Get AnyFile for capsule 3516 # 3517 # @param self The object pointer 3518 # @param CapsuleObj for whom AnyFile is got 3519 # @retval True Successfully find a Anyfile statement 3520 # @retval False Not able to find a AnyFile statement 3521 # 3522 def __GetAnyFileStatement(self, CapsuleObj, FMPCapsule = False): 3523 AnyFileName = self.__ParseRawFileStatement() 3524 if not AnyFileName: 3525 return False 3526 3527 CapsuleAnyFile = CapsuleData.CapsuleAnyFile() 3528 CapsuleAnyFile.FileName = AnyFileName 3529 if FMPCapsule: 3530 if not CapsuleObj.ImageFile: 3531 CapsuleObj.ImageFile.append(CapsuleAnyFile) 3532 else: 3533 CapsuleObj.VendorCodeFile.append(CapsuleAnyFile) 3534 else: 3535 CapsuleObj.CapsuleDataList.append(CapsuleAnyFile) 3536 return True 3537 3538 ## __GetAfileStatement() method 3539 # 3540 # Get Afile for capsule 3541 # 3542 # @param self The object pointer 3543 # @param CapsuleObj for whom Afile is got 3544 # @retval True Successfully find a Afile statement 3545 # @retval False Not able to find a Afile statement 3546 # 3547 def __GetAfileStatement(self, CapsuleObj): 3548 3549 if not self.__IsKeyword("APPEND"): 3550 return False 3551 3552 if not self.__IsToken("="): 3553 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3554 3555 if not self.__GetNextToken(): 3556 raise Warning("expected Afile name", self.FileName, self.CurrentLineNumber) 3557 3558 AfileName = self.__Token 3559 AfileBaseName = os.path.basename(AfileName) 3560 3561 if os.path.splitext(AfileBaseName)[1] not in [".bin",".BIN",".Bin",".dat",".DAT",".Dat",".data",".DATA",".Data"]: 3562 raise Warning('invalid binary file type, should be one of "bin","BIN","Bin","dat","DAT","Dat","data","DATA","Data"', \ 3563 self.FileName, self.CurrentLineNumber) 3564 3565 if not os.path.isabs(AfileName): 3566 AfileName = GenFdsGlobalVariable.ReplaceWorkspaceMacro(AfileName) 3567 self.__VerifyFile(AfileName) 3568 else: 3569 if not os.path.exists(AfileName): 3570 raise Warning('%s does not exist' % AfileName, self.FileName, self.CurrentLineNumber) 3571 else: 3572 pass 3573 3574 CapsuleAfile = CapsuleData.CapsuleAfile() 3575 CapsuleAfile.FileName = AfileName 3576 CapsuleObj.CapsuleDataList.append(CapsuleAfile) 3577 return True 3578 3579 ## __GetRule() method 3580 # 3581 # Get Rule section contents and store its data into rule list of self.Profile 3582 # 3583 # @param self The object pointer 3584 # @retval True Successfully find a Rule 3585 # @retval False Not able to find a Rule 3586 # 3587 def __GetRule(self): 3588 3589 if not self.__GetNextToken(): 3590 return False 3591 3592 S = self.__Token.upper() 3593 if S.startswith("[") and not S.startswith("[RULE."): 3594 self.SectionParser(S) 3595 self.__UndoToken() 3596 return False 3597 self.__UndoToken() 3598 if not self.__IsToken("[Rule.", True): 3599 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 3600 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ 3601 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) 3602 raise Warning("expected [Rule.]", self.FileName, self.CurrentLineNumber) 3603 3604 if not self.__SkipToToken("."): 3605 raise Warning("expected '.'", self.FileName, self.CurrentLineNumber) 3606 3607 Arch = self.__SkippedChars.rstrip(".") 3608 if Arch.upper() not in ("IA32", "X64", "IPF", "EBC", "ARM", "AARCH64", "COMMON"): 3609 raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber) 3610 3611 ModuleType = self.__GetModuleType() 3612 3613 TemplateName = "" 3614 if self.__IsToken("."): 3615 if not self.__GetNextWord(): 3616 raise Warning("expected template name", self.FileName, self.CurrentLineNumber) 3617 TemplateName = self.__Token 3618 3619 if not self.__IsToken( "]"): 3620 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 3621 3622 RuleObj = self.__GetRuleFileStatements() 3623 RuleObj.Arch = Arch.upper() 3624 RuleObj.ModuleType = ModuleType 3625 RuleObj.TemplateName = TemplateName 3626 if TemplateName == '' : 3627 self.Profile.RuleDict['RULE' + \ 3628 '.' + \ 3629 Arch.upper() + \ 3630 '.' + \ 3631 ModuleType.upper() ] = RuleObj 3632 else : 3633 self.Profile.RuleDict['RULE' + \ 3634 '.' + \ 3635 Arch.upper() + \ 3636 '.' + \ 3637 ModuleType.upper() + \ 3638 '.' + \ 3639 TemplateName.upper() ] = RuleObj 3640 # self.Profile.RuleList.append(rule) 3641 return True 3642 3643 ## __GetModuleType() method 3644 # 3645 # Return the module type 3646 # 3647 # @param self The object pointer 3648 # @retval string module type 3649 # 3650 def __GetModuleType(self): 3651 3652 if not self.__GetNextWord(): 3653 raise Warning("expected Module type", self.FileName, self.CurrentLineNumber) 3654 if self.__Token.upper() not in ("SEC", "PEI_CORE", "PEIM", "DXE_CORE", \ 3655 "DXE_DRIVER", "DXE_SAL_DRIVER", \ 3656 "DXE_SMM_DRIVER", "DXE_RUNTIME_DRIVER", \ 3657 "UEFI_DRIVER", "UEFI_APPLICATION", "USER_DEFINED", "DEFAULT", "BASE", \ 3658 "SECURITY_CORE", "COMBINED_PEIM_DRIVER", "PIC_PEIM", "RELOCATABLE_PEIM", \ 3659 "PE32_PEIM", "BS_DRIVER", "RT_DRIVER", "SAL_RT_DRIVER", "APPLICATION", "ACPITABLE", "SMM_CORE"): 3660 raise Warning("Unknown Module type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3661 return self.__Token 3662 3663 ## __GetFileExtension() method 3664 # 3665 # Return the file extension 3666 # 3667 # @param self The object pointer 3668 # @retval string file name extension 3669 # 3670 def __GetFileExtension(self): 3671 if not self.__IsToken("."): 3672 raise Warning("expected '.'", self.FileName, self.CurrentLineNumber) 3673 3674 Ext = "" 3675 if self.__GetNextToken(): 3676 Pattern = re.compile(r'([a-zA-Z][a-zA-Z0-9]*)') 3677 if Pattern.match(self.__Token): 3678 Ext = self.__Token 3679 return '.' + Ext 3680 else: 3681 raise Warning("Unknown file extension '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3682 3683 else: 3684 raise Warning("expected file extension", self.FileName, self.CurrentLineNumber) 3685 3686 ## __GetRuleFileStatement() method 3687 # 3688 # Get rule contents 3689 # 3690 # @param self The object pointer 3691 # @retval Rule Rule object 3692 # 3693 def __GetRuleFileStatements(self): 3694 3695 if not self.__IsKeyword("FILE"): 3696 raise Warning("expected FILE", self.FileName, self.CurrentLineNumber) 3697 3698 if not self.__GetNextWord(): 3699 raise Warning("expected FFS type", self.FileName, self.CurrentLineNumber) 3700 3701 Type = self.__Token.strip().upper() 3702 if Type not in ("RAW", "FREEFORM", "SEC", "PEI_CORE", "PEIM",\ 3703 "PEI_DXE_COMBO", "DRIVER", "DXE_CORE", "APPLICATION", "FV_IMAGE", "SMM", "SMM_CORE"): 3704 raise Warning("Unknown FV type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3705 3706 if not self.__IsToken("="): 3707 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3708 3709 if not self.__IsKeyword("$(NAMED_GUID)"): 3710 if not self.__GetNextWord(): 3711 raise Warning("expected $(NAMED_GUID)", self.FileName, self.CurrentLineNumber) 3712 if self.__Token == 'PCD': 3713 if not self.__IsToken( "("): 3714 raise Warning("expected '('", self.FileName, self.CurrentLineNumber) 3715 PcdPair = self.__GetNextPcdName() 3716 if not self.__IsToken( ")"): 3717 raise Warning("expected ')'", self.FileName, self.CurrentLineNumber) 3718 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')' 3719 3720 NameGuid = self.__Token 3721 3722 KeepReloc = None 3723 if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): 3724 if self.__FileCouldHaveRelocFlag(Type): 3725 if self.__Token == 'RELOCS_STRIPPED': 3726 KeepReloc = False 3727 else: 3728 KeepReloc = True 3729 else: 3730 raise Warning("File type %s could not have reloc strip flag%d" % (Type, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) 3731 3732 KeyStringList = [] 3733 if self.__GetNextToken(): 3734 Pattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)') 3735 if Pattern.match(self.__Token): 3736 KeyStringList.append(self.__Token) 3737 if self.__IsToken(","): 3738 while self.__GetNextToken(): 3739 if not Pattern.match(self.__Token): 3740 raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber) 3741 KeyStringList.append(self.__Token) 3742 3743 if not self.__IsToken(","): 3744 break 3745 3746 else: 3747 self.__UndoToken() 3748 3749 3750 Fixed = False 3751 if self.__IsKeyword("Fixed", True): 3752 Fixed = True 3753 3754 CheckSum = False 3755 if self.__IsKeyword("CheckSum", True): 3756 CheckSum = True 3757 3758 AlignValue = "" 3759 if self.__GetAlignment(): 3760 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 3761 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3762 #For FFS, Auto is default option same to "" 3763 if not self.__Token == "Auto": 3764 AlignValue = self.__Token 3765 3766 if self.__IsToken("{"): 3767 # Complex file rule expected 3768 Rule = RuleComplexFile.RuleComplexFile() 3769 Rule.FvFileType = Type 3770 Rule.NameGuid = NameGuid 3771 Rule.Alignment = AlignValue 3772 Rule.CheckSum = CheckSum 3773 Rule.Fixed = Fixed 3774 Rule.KeyStringList = KeyStringList 3775 if KeepReloc != None: 3776 Rule.KeepReloc = KeepReloc 3777 3778 while True: 3779 IsEncapsulate = self.__GetRuleEncapsulationSection(Rule) 3780 IsLeaf = self.__GetEfiSection(Rule) 3781 if not IsEncapsulate and not IsLeaf: 3782 break 3783 3784 if not self.__IsToken("}"): 3785 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 3786 3787 return Rule 3788 3789 else: 3790 # Simple file rule expected 3791 if not self.__GetNextWord(): 3792 raise Warning("expected leaf section type", self.FileName, self.CurrentLineNumber) 3793 3794 SectionName = self.__Token 3795 3796 if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\ 3797 "UI", "PEI_DEPEX", "VERSION", "SUBTYPE_GUID", "SMM_DEPEX"): 3798 raise Warning("Unknown leaf section name '%s'" % SectionName, self.FileName, self.CurrentLineNumber) 3799 3800 3801 if self.__IsKeyword("Fixed", True): 3802 Fixed = True 3803 3804 if self.__IsKeyword("CheckSum", True): 3805 CheckSum = True 3806 3807 SectAlignment = "" 3808 if self.__GetAlignment(): 3809 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 3810 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3811 if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'): 3812 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) 3813 SectAlignment = self.__Token 3814 3815 Ext = None 3816 if self.__IsToken('|'): 3817 Ext = self.__GetFileExtension() 3818 elif not self.__GetNextToken(): 3819 raise Warning("expected File name", self.FileName, self.CurrentLineNumber) 3820 3821 Rule = RuleSimpleFile.RuleSimpleFile() 3822 Rule.SectionType = SectionName 3823 Rule.FvFileType = Type 3824 Rule.NameGuid = NameGuid 3825 Rule.Alignment = AlignValue 3826 Rule.SectAlignment = SectAlignment 3827 Rule.CheckSum = CheckSum 3828 Rule.Fixed = Fixed 3829 Rule.KeyStringList = KeyStringList 3830 if KeepReloc != None: 3831 Rule.KeepReloc = KeepReloc 3832 Rule.FileExtension = Ext 3833 Rule.FileName = self.__Token 3834 return Rule 3835 3836 ## __GetEfiSection() method 3837 # 3838 # Get section list for Rule 3839 # 3840 # @param self The object pointer 3841 # @param Obj for whom section is got 3842 # @retval True Successfully find section statement 3843 # @retval False Not able to find section statement 3844 # 3845 def __GetEfiSection(self, Obj): 3846 3847 OldPos = self.GetFileBufferPos() 3848 if not self.__GetNextWord(): 3849 return False 3850 SectionName = self.__Token 3851 3852 if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\ 3853 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"): 3854 self.__UndoToken() 3855 return False 3856 3857 if SectionName == "FV_IMAGE": 3858 FvImageSectionObj = FvImageSection.FvImageSection() 3859 if self.__IsKeyword("FV_IMAGE"): 3860 pass 3861 if self.__IsToken( "{"): 3862 FvObj = Fv.FV() 3863 self.__GetDefineStatements(FvObj) 3864 self.__GetBlockStatement(FvObj) 3865 self.__GetSetStatements(FvObj) 3866 self.__GetFvAlignment(FvObj) 3867 self.__GetFvAttributes(FvObj) 3868 self.__GetAprioriSection(FvObj) 3869 self.__GetAprioriSection(FvObj) 3870 3871 while True: 3872 IsInf = self.__GetInfStatement(FvObj) 3873 IsFile = self.__GetFileStatement(FvObj) 3874 if not IsInf and not IsFile: 3875 break 3876 3877 if not self.__IsToken( "}"): 3878 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 3879 FvImageSectionObj.Fv = FvObj 3880 FvImageSectionObj.FvName = None 3881 3882 else: 3883 if not self.__IsKeyword("FV"): 3884 raise Warning("expected 'FV'", self.FileName, self.CurrentLineNumber) 3885 FvImageSectionObj.FvFileType = self.__Token 3886 3887 if self.__GetAlignment(): 3888 if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 3889 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3890 FvImageSectionObj.Alignment = self.__Token 3891 3892 if self.__IsToken('|'): 3893 FvImageSectionObj.FvFileExtension = self.__GetFileExtension() 3894 elif self.__GetNextToken(): 3895 if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\ 3896 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"): 3897 FvImageSectionObj.FvFileName = self.__Token 3898 else: 3899 self.__UndoToken() 3900 else: 3901 raise Warning("expected FV file name", self.FileName, self.CurrentLineNumber) 3902 3903 Obj.SectionList.append(FvImageSectionObj) 3904 return True 3905 3906 EfiSectionObj = EfiSection.EfiSection() 3907 EfiSectionObj.SectionType = SectionName 3908 3909 if not self.__GetNextToken(): 3910 raise Warning("expected file type", self.FileName, self.CurrentLineNumber) 3911 3912 if self.__Token == "STRING": 3913 if not self.__RuleSectionCouldHaveString(EfiSectionObj.SectionType): 3914 raise Warning("%s section could NOT have string data%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) 3915 3916 if not self.__IsToken('='): 3917 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3918 3919 if not self.__GetNextToken(): 3920 raise Warning("expected Quoted String", self.FileName, self.CurrentLineNumber) 3921 3922 if self.__GetStringData(): 3923 EfiSectionObj.StringData = self.__Token 3924 3925 if self.__IsKeyword("BUILD_NUM"): 3926 if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType): 3927 raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) 3928 3929 if not self.__IsToken("="): 3930 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3931 if not self.__GetNextToken(): 3932 raise Warning("expected Build number", self.FileName, self.CurrentLineNumber) 3933 EfiSectionObj.BuildNum = self.__Token 3934 3935 else: 3936 EfiSectionObj.FileType = self.__Token 3937 self.__CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType) 3938 3939 if self.__IsKeyword("Optional"): 3940 if not self.__RuleSectionCouldBeOptional(EfiSectionObj.SectionType): 3941 raise Warning("%s section could NOT be optional%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) 3942 EfiSectionObj.Optional = True 3943 3944 if self.__IsKeyword("BUILD_NUM"): 3945 if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType): 3946 raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) 3947 3948 if not self.__IsToken("="): 3949 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 3950 if not self.__GetNextToken(): 3951 raise Warning("expected Build number", self.FileName, self.CurrentLineNumber) 3952 EfiSectionObj.BuildNum = self.__Token 3953 3954 if self.__GetAlignment(): 3955 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"): 3956 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 3957 if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'): 3958 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) 3959 EfiSectionObj.Alignment = self.__Token 3960 3961 if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): 3962 if self.__SectionCouldHaveRelocFlag(EfiSectionObj.SectionType): 3963 if self.__Token == 'RELOCS_STRIPPED': 3964 EfiSectionObj.KeepReloc = False 3965 else: 3966 EfiSectionObj.KeepReloc = True 3967 if Obj.KeepReloc != None and Obj.KeepReloc != EfiSectionObj.KeepReloc: 3968 raise Warning("Section type %s has reloc strip flag conflict with Rule" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber) 3969 else: 3970 raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber) 3971 3972 3973 if self.__IsToken('|'): 3974 EfiSectionObj.FileExtension = self.__GetFileExtension() 3975 elif self.__GetNextToken(): 3976 if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\ 3977 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"): 3978 3979 if self.__Token.startswith('PCD'): 3980 self.__UndoToken() 3981 self.__GetNextWord() 3982 3983 if self.__Token == 'PCD': 3984 if not self.__IsToken( "("): 3985 raise Warning("expected '('", self.FileName, self.CurrentLineNumber) 3986 PcdPair = self.__GetNextPcdName() 3987 if not self.__IsToken( ")"): 3988 raise Warning("expected ')'", self.FileName, self.CurrentLineNumber) 3989 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')' 3990 3991 EfiSectionObj.FileName = self.__Token 3992 3993 else: 3994 self.__UndoToken() 3995 else: 3996 raise Warning("expected section file name", self.FileName, self.CurrentLineNumber) 3997 3998 Obj.SectionList.append(EfiSectionObj) 3999 return True 4000 4001 ## __RuleSectionCouldBeOptional() method 4002 # 4003 # Get whether a section could be optional 4004 # 4005 # @param self The object pointer 4006 # @param SectionType The section type to check 4007 # @retval True section could be optional 4008 # @retval False section never optional 4009 # 4010 def __RuleSectionCouldBeOptional(self, SectionType): 4011 if SectionType in ("DXE_DEPEX", "UI", "VERSION", "PEI_DEPEX", "RAW", "SMM_DEPEX"): 4012 return True 4013 else: 4014 return False 4015 4016 ## __RuleSectionCouldHaveBuildNum() method 4017 # 4018 # Get whether a section could have build number information 4019 # 4020 # @param self The object pointer 4021 # @param SectionType The section type to check 4022 # @retval True section could have build number information 4023 # @retval False section never have build number information 4024 # 4025 def __RuleSectionCouldHaveBuildNum(self, SectionType): 4026 if SectionType in ("VERSION"): 4027 return True 4028 else: 4029 return False 4030 4031 ## __RuleSectionCouldHaveString() method 4032 # 4033 # Get whether a section could have string 4034 # 4035 # @param self The object pointer 4036 # @param SectionType The section type to check 4037 # @retval True section could have string 4038 # @retval False section never have string 4039 # 4040 def __RuleSectionCouldHaveString(self, SectionType): 4041 if SectionType in ("UI", "VERSION"): 4042 return True 4043 else: 4044 return False 4045 4046 ## __CheckRuleSectionFileType() method 4047 # 4048 # Get whether a section matches a file type 4049 # 4050 # @param self The object pointer 4051 # @param SectionType The section type to check 4052 # @param FileType The file type to check 4053 # 4054 def __CheckRuleSectionFileType(self, SectionType, FileType): 4055 if SectionType == "COMPAT16": 4056 if FileType not in ("COMPAT16", "SEC_COMPAT16"): 4057 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4058 elif SectionType == "PE32": 4059 if FileType not in ("PE32", "SEC_PE32"): 4060 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4061 elif SectionType == "PIC": 4062 if FileType not in ("PIC", "PIC"): 4063 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4064 elif SectionType == "TE": 4065 if FileType not in ("TE", "SEC_TE"): 4066 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4067 elif SectionType == "RAW": 4068 if FileType not in ("BIN", "SEC_BIN", "RAW", "ASL", "ACPI"): 4069 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4070 elif SectionType == "DXE_DEPEX" or SectionType == "SMM_DEPEX": 4071 if FileType not in ("DXE_DEPEX", "SEC_DXE_DEPEX", "SMM_DEPEX"): 4072 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4073 elif SectionType == "UI": 4074 if FileType not in ("UI", "SEC_UI"): 4075 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4076 elif SectionType == "VERSION": 4077 if FileType not in ("VERSION", "SEC_VERSION"): 4078 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4079 elif SectionType == "PEI_DEPEX": 4080 if FileType not in ("PEI_DEPEX", "SEC_PEI_DEPEX"): 4081 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4082 elif SectionType == "GUID": 4083 if FileType not in ("PE32", "SEC_GUID"): 4084 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) 4085 4086 ## __GetRuleEncapsulationSection() method 4087 # 4088 # Get encapsulation section for Rule 4089 # 4090 # @param self The object pointer 4091 # @param Rule for whom section is got 4092 # @retval True Successfully find section statement 4093 # @retval False Not able to find section statement 4094 # 4095 def __GetRuleEncapsulationSection(self, Rule): 4096 4097 if self.__IsKeyword( "COMPRESS"): 4098 Type = "PI_STD" 4099 if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"): 4100 Type = self.__Token 4101 4102 if not self.__IsToken("{"): 4103 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 4104 4105 CompressSectionObj = CompressSection.CompressSection() 4106 4107 CompressSectionObj.CompType = Type 4108 # Recursive sections... 4109 while True: 4110 IsEncapsulate = self.__GetRuleEncapsulationSection(CompressSectionObj) 4111 IsLeaf = self.__GetEfiSection(CompressSectionObj) 4112 if not IsEncapsulate and not IsLeaf: 4113 break 4114 4115 if not self.__IsToken( "}"): 4116 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 4117 Rule.SectionList.append(CompressSectionObj) 4118 4119 return True 4120 4121 elif self.__IsKeyword( "GUIDED"): 4122 GuidValue = None 4123 if self.__GetNextGuid(): 4124 GuidValue = self.__Token 4125 4126 if self.__IsKeyword( "$(NAMED_GUID)"): 4127 GuidValue = self.__Token 4128 4129 AttribDict = self.__GetGuidAttrib() 4130 4131 if not self.__IsToken("{"): 4132 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) 4133 GuidSectionObj = GuidSection.GuidSection() 4134 GuidSectionObj.NameGuid = GuidValue 4135 GuidSectionObj.SectionType = "GUIDED" 4136 GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"] 4137 GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"] 4138 GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"] 4139 4140 # Efi sections... 4141 while True: 4142 IsEncapsulate = self.__GetRuleEncapsulationSection(GuidSectionObj) 4143 IsLeaf = self.__GetEfiSection(GuidSectionObj) 4144 if not IsEncapsulate and not IsLeaf: 4145 break 4146 4147 if not self.__IsToken( "}"): 4148 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) 4149 Rule.SectionList.append(GuidSectionObj) 4150 4151 return True 4152 4153 return False 4154 4155 ## __GetVtf() method 4156 # 4157 # Get VTF section contents and store its data into VTF list of self.Profile 4158 # 4159 # @param self The object pointer 4160 # @retval True Successfully find a VTF 4161 # @retval False Not able to find a VTF 4162 # 4163 def __GetVtf(self): 4164 4165 if not self.__GetNextToken(): 4166 return False 4167 4168 S = self.__Token.upper() 4169 if S.startswith("[") and not S.startswith("[VTF."): 4170 self.SectionParser(S) 4171 self.__UndoToken() 4172 return False 4173 4174 self.__UndoToken() 4175 if not self.__IsToken("[VTF.", True): 4176 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 4177 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ 4178 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) 4179 raise Warning("expected [VTF.]", self.FileName, self.CurrentLineNumber) 4180 4181 if not self.__SkipToToken("."): 4182 raise Warning("expected '.'", self.FileName, self.CurrentLineNumber) 4183 4184 Arch = self.__SkippedChars.rstrip(".").upper() 4185 if Arch not in ("IA32", "X64", "IPF", "ARM", "AARCH64"): 4186 raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber) 4187 4188 if not self.__GetNextWord(): 4189 raise Warning("expected VTF name", self.FileName, self.CurrentLineNumber) 4190 Name = self.__Token.upper() 4191 4192 VtfObj = Vtf.Vtf() 4193 VtfObj.UiName = Name 4194 VtfObj.KeyArch = Arch 4195 4196 if self.__IsToken(","): 4197 if not self.__GetNextWord(): 4198 raise Warning("expected Arch list", self.FileName, self.CurrentLineNumber) 4199 if self.__Token.upper() not in ("IA32", "X64", "IPF", "ARM", "AARCH64"): 4200 raise Warning("Unknown Arch '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 4201 VtfObj.ArchList = self.__Token.upper() 4202 4203 if not self.__IsToken( "]"): 4204 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 4205 4206 if self.__IsKeyword("IA32_RST_BIN"): 4207 if not self.__IsToken("="): 4208 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4209 4210 if not self.__GetNextToken(): 4211 raise Warning("expected Reset file", self.FileName, self.CurrentLineNumber) 4212 4213 VtfObj.ResetBin = self.__Token 4214 if VtfObj.ResetBin.replace('$(WORKSPACE)', '').find('$') == -1: 4215 #check for file path 4216 ErrorCode, ErrorInfo = PathClass(NormPath(VtfObj.ResetBin), GenFdsGlobalVariable.WorkSpaceDir).Validate() 4217 if ErrorCode != 0: 4218 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) 4219 4220 while self.__GetComponentStatement(VtfObj): 4221 pass 4222 4223 self.Profile.VtfList.append(VtfObj) 4224 return True 4225 4226 ## __GetComponentStatement() method 4227 # 4228 # Get components in VTF 4229 # 4230 # @param self The object pointer 4231 # @param VtfObj for whom component is got 4232 # @retval True Successfully find a component 4233 # @retval False Not able to find a component 4234 # 4235 def __GetComponentStatement(self, VtfObj): 4236 4237 if not self.__IsKeyword("COMP_NAME"): 4238 return False 4239 4240 if not self.__IsToken("="): 4241 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4242 4243 if not self.__GetNextWord(): 4244 raise Warning("expected Component Name", self.FileName, self.CurrentLineNumber) 4245 4246 CompStatementObj = ComponentStatement.ComponentStatement() 4247 CompStatementObj.CompName = self.__Token 4248 4249 if not self.__IsKeyword("COMP_LOC"): 4250 raise Warning("expected COMP_LOC", self.FileName, self.CurrentLineNumber) 4251 4252 if not self.__IsToken("="): 4253 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4254 4255 CompStatementObj.CompLoc = "" 4256 if self.__GetNextWord(): 4257 CompStatementObj.CompLoc = self.__Token 4258 if self.__IsToken('|'): 4259 if not self.__GetNextWord(): 4260 raise Warning("Expected Region Name", self.FileName, self.CurrentLineNumber) 4261 4262 if self.__Token not in ("F", "N", "S"): #, "H", "L", "PH", "PL"): not support 4263 raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 4264 4265 CompStatementObj.FilePos = self.__Token 4266 else: 4267 self.CurrentLineNumber += 1 4268 self.CurrentOffsetWithinLine = 0 4269 4270 if not self.__IsKeyword("COMP_TYPE"): 4271 raise Warning("expected COMP_TYPE", self.FileName, self.CurrentLineNumber) 4272 4273 if not self.__IsToken("="): 4274 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4275 4276 if not self.__GetNextToken(): 4277 raise Warning("expected Component type", self.FileName, self.CurrentLineNumber) 4278 if self.__Token not in ("FIT", "PAL_B", "PAL_A", "OEM"): 4279 if not self.__Token.startswith("0x") or len(self.__Token) < 3 or len(self.__Token) > 4 or \ 4280 not self.__HexDigit(self.__Token[2]) or not self.__HexDigit(self.__Token[-1]): 4281 raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 4282 CompStatementObj.CompType = self.__Token 4283 4284 if not self.__IsKeyword("COMP_VER"): 4285 raise Warning("expected COMP_VER", self.FileName, self.CurrentLineNumber) 4286 4287 if not self.__IsToken("="): 4288 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4289 4290 if not self.__GetNextToken(): 4291 raise Warning("expected Component version", self.FileName, self.CurrentLineNumber) 4292 4293 Pattern = re.compile('-$|[0-9a-fA-F]{1,2}\.[0-9a-fA-F]{1,2}$', re.DOTALL) 4294 if Pattern.match(self.__Token) == None: 4295 raise Warning("Unknown version format '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 4296 CompStatementObj.CompVer = self.__Token 4297 4298 if not self.__IsKeyword("COMP_CS"): 4299 raise Warning("expected COMP_CS", self.FileName, self.CurrentLineNumber) 4300 4301 if not self.__IsToken("="): 4302 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4303 4304 if not self.__GetNextToken(): 4305 raise Warning("expected Component CS", self.FileName, self.CurrentLineNumber) 4306 if self.__Token not in ("1", "0"): 4307 raise Warning("Unknown Component CS '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 4308 CompStatementObj.CompCs = self.__Token 4309 4310 4311 if not self.__IsKeyword("COMP_BIN"): 4312 raise Warning("expected COMP_BIN", self.FileName, self.CurrentLineNumber) 4313 4314 if not self.__IsToken("="): 4315 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4316 4317 if not self.__GetNextToken(): 4318 raise Warning("expected Component file", self.FileName, self.CurrentLineNumber) 4319 4320 CompStatementObj.CompBin = self.__Token 4321 if CompStatementObj.CompBin != '-' and CompStatementObj.CompBin.replace('$(WORKSPACE)', '').find('$') == -1: 4322 #check for file path 4323 ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompBin), GenFdsGlobalVariable.WorkSpaceDir).Validate() 4324 if ErrorCode != 0: 4325 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) 4326 4327 if not self.__IsKeyword("COMP_SYM"): 4328 raise Warning("expected COMP_SYM", self.FileName, self.CurrentLineNumber) 4329 4330 if not self.__IsToken("="): 4331 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4332 4333 if not self.__GetNextToken(): 4334 raise Warning("expected Component symbol file", self.FileName, self.CurrentLineNumber) 4335 4336 CompStatementObj.CompSym = self.__Token 4337 if CompStatementObj.CompSym != '-' and CompStatementObj.CompSym.replace('$(WORKSPACE)', '').find('$') == -1: 4338 #check for file path 4339 ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompSym), GenFdsGlobalVariable.WorkSpaceDir).Validate() 4340 if ErrorCode != 0: 4341 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) 4342 4343 if not self.__IsKeyword("COMP_SIZE"): 4344 raise Warning("expected COMP_SIZE", self.FileName, self.CurrentLineNumber) 4345 4346 if not self.__IsToken("="): 4347 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4348 4349 if self.__IsToken("-"): 4350 CompStatementObj.CompSize = self.__Token 4351 elif self.__GetNextDecimalNumber(): 4352 CompStatementObj.CompSize = self.__Token 4353 elif self.__GetNextHexNumber(): 4354 CompStatementObj.CompSize = self.__Token 4355 else: 4356 raise Warning("Unknown size '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 4357 4358 VtfObj.ComponentStatementList.append(CompStatementObj) 4359 return True 4360 4361 ## __GetOptionRom() method 4362 # 4363 # Get OptionROM section contents and store its data into OptionROM list of self.Profile 4364 # 4365 # @param self The object pointer 4366 # @retval True Successfully find a OptionROM 4367 # @retval False Not able to find a OptionROM 4368 # 4369 def __GetOptionRom(self): 4370 4371 if not self.__GetNextToken(): 4372 return False 4373 4374 S = self.__Token.upper() 4375 if S.startswith("[") and not S.startswith("[OPTIONROM."): 4376 self.SectionParser(S) 4377 self.__UndoToken() 4378 return False 4379 4380 self.__UndoToken() 4381 if not self.__IsToken("[OptionRom.", True): 4382 raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) 4383 4384 OptRomName = self.__GetUiName() 4385 4386 if not self.__IsToken( "]"): 4387 raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) 4388 4389 OptRomObj = OptionRom.OPTIONROM() 4390 OptRomObj.DriverName = OptRomName 4391 self.Profile.OptRomDict[OptRomName] = OptRomObj 4392 4393 while True: 4394 isInf = self.__GetOptRomInfStatement(OptRomObj) 4395 isFile = self.__GetOptRomFileStatement(OptRomObj) 4396 if not isInf and not isFile: 4397 break 4398 4399 return True 4400 4401 ## __GetOptRomInfStatement() method 4402 # 4403 # Get INF statements 4404 # 4405 # @param self The object pointer 4406 # @param Obj for whom inf statement is got 4407 # @retval True Successfully find inf statement 4408 # @retval False Not able to find inf statement 4409 # 4410 def __GetOptRomInfStatement(self, Obj): 4411 4412 if not self.__IsKeyword( "INF"): 4413 return False 4414 4415 ffsInf = OptRomInfStatement.OptRomInfStatement() 4416 self.__GetInfOptions( ffsInf) 4417 4418 if not self.__GetNextToken(): 4419 raise Warning("expected INF file path", self.FileName, self.CurrentLineNumber) 4420 ffsInf.InfFileName = self.__Token 4421 if ffsInf.InfFileName.replace('$(WORKSPACE)', '').find('$') == -1: 4422 #check for file path 4423 ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() 4424 if ErrorCode != 0: 4425 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) 4426 4427 if not ffsInf.InfFileName in self.Profile.InfList: 4428 self.Profile.InfList.append(ffsInf.InfFileName) 4429 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) 4430 self.Profile.InfFileLineList.append(FileLineTuple) 4431 if ffsInf.UseArch: 4432 if ffsInf.UseArch not in self.Profile.InfDict: 4433 self.Profile.InfDict[ffsInf.UseArch] = [ffsInf.InfFileName] 4434 else: 4435 self.Profile.InfDict[ffsInf.UseArch].append(ffsInf.InfFileName) 4436 else: 4437 self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName) 4438 4439 4440 self.__GetOptRomOverrides (ffsInf) 4441 4442 Obj.FfsList.append(ffsInf) 4443 return True 4444 4445 ## __GetOptRomOverrides() method 4446 # 4447 # Get overrides for OptROM INF & FILE 4448 # 4449 # @param self The object pointer 4450 # @param FfsInfObj for whom overrides is got 4451 # 4452 def __GetOptRomOverrides(self, Obj): 4453 if self.__IsToken('{'): 4454 Overrides = OptionRom.OverrideAttribs() 4455 while True: 4456 if self.__IsKeyword( "PCI_VENDOR_ID"): 4457 if not self.__IsToken( "="): 4458 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4459 if not self.__GetNextHexNumber(): 4460 raise Warning("expected Hex vendor id", self.FileName, self.CurrentLineNumber) 4461 Overrides.PciVendorId = self.__Token 4462 continue 4463 4464 if self.__IsKeyword( "PCI_CLASS_CODE"): 4465 if not self.__IsToken( "="): 4466 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4467 if not self.__GetNextHexNumber(): 4468 raise Warning("expected Hex class code", self.FileName, self.CurrentLineNumber) 4469 Overrides.PciClassCode = self.__Token 4470 continue 4471 4472 if self.__IsKeyword( "PCI_DEVICE_ID"): 4473 if not self.__IsToken( "="): 4474 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4475 if not self.__GetNextHexNumber(): 4476 raise Warning("expected Hex device id", self.FileName, self.CurrentLineNumber) 4477 4478 Overrides.PciDeviceId = self.__Token 4479 continue 4480 4481 if self.__IsKeyword( "PCI_REVISION"): 4482 if not self.__IsToken( "="): 4483 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4484 if not self.__GetNextHexNumber(): 4485 raise Warning("expected Hex revision", self.FileName, self.CurrentLineNumber) 4486 Overrides.PciRevision = self.__Token 4487 continue 4488 4489 if self.__IsKeyword( "PCI_COMPRESS"): 4490 if not self.__IsToken( "="): 4491 raise Warning("expected '='", self.FileName, self.CurrentLineNumber) 4492 if not self.__GetNextToken(): 4493 raise Warning("expected TRUE/FALSE for compress", self.FileName, self.CurrentLineNumber) 4494 Overrides.NeedCompress = self.__Token.upper() == 'TRUE' 4495 continue 4496 4497 if self.__IsToken( "}"): 4498 break 4499 else: 4500 EdkLogger.error("FdfParser", FORMAT_INVALID, File=self.FileName, Line=self.CurrentLineNumber) 4501 4502 Obj.OverrideAttribs = Overrides 4503 4504 ## __GetOptRomFileStatement() method 4505 # 4506 # Get FILE statements 4507 # 4508 # @param self The object pointer 4509 # @param Obj for whom FILE statement is got 4510 # @retval True Successfully find FILE statement 4511 # @retval False Not able to find FILE statement 4512 # 4513 def __GetOptRomFileStatement(self, Obj): 4514 4515 if not self.__IsKeyword( "FILE"): 4516 return False 4517 4518 FfsFileObj = OptRomFileStatement.OptRomFileStatement() 4519 4520 if not self.__IsKeyword("EFI") and not self.__IsKeyword("BIN"): 4521 raise Warning("expected Binary type (EFI/BIN)", self.FileName, self.CurrentLineNumber) 4522 FfsFileObj.FileType = self.__Token 4523 4524 if not self.__GetNextToken(): 4525 raise Warning("expected File path", self.FileName, self.CurrentLineNumber) 4526 FfsFileObj.FileName = self.__Token 4527 if FfsFileObj.FileName.replace('$(WORKSPACE)', '').find('$') == -1: 4528 #check for file path 4529 ErrorCode, ErrorInfo = PathClass(NormPath(FfsFileObj.FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() 4530 if ErrorCode != 0: 4531 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) 4532 4533 if FfsFileObj.FileType == 'EFI': 4534 self.__GetOptRomOverrides(FfsFileObj) 4535 4536 Obj.FfsList.append(FfsFileObj) 4537 4538 return True 4539 4540 ## __GetCapInFd() method 4541 # 4542 # Get Cap list contained in FD 4543 # 4544 # @param self The object pointer 4545 # @param FdName FD name 4546 # @retval CapList List of Capsule in FD 4547 # 4548 def __GetCapInFd (self, FdName): 4549 4550 CapList = [] 4551 if FdName.upper() in self.Profile.FdDict.keys(): 4552 FdObj = self.Profile.FdDict[FdName.upper()] 4553 for elementRegion in FdObj.RegionList: 4554 if elementRegion.RegionType == 'CAPSULE': 4555 for elementRegionData in elementRegion.RegionDataList: 4556 if elementRegionData.endswith(".cap"): 4557 continue 4558 if elementRegionData != None and elementRegionData.upper() not in CapList: 4559 CapList.append(elementRegionData.upper()) 4560 return CapList 4561 4562 ## __GetReferencedFdCapTuple() method 4563 # 4564 # Get FV and FD list referenced by a capsule image 4565 # 4566 # @param self The object pointer 4567 # @param CapObj Capsule section to be searched 4568 # @param RefFdList referenced FD by section 4569 # @param RefFvList referenced FV by section 4570 # 4571 def __GetReferencedFdCapTuple(self, CapObj, RefFdList = [], RefFvList = []): 4572 4573 for CapsuleDataObj in CapObj.CapsuleDataList : 4574 if hasattr(CapsuleDataObj, 'FvName') and CapsuleDataObj.FvName != None and CapsuleDataObj.FvName.upper() not in RefFvList: 4575 RefFvList.append (CapsuleDataObj.FvName.upper()) 4576 elif hasattr(CapsuleDataObj, 'FdName') and CapsuleDataObj.FdName != None and CapsuleDataObj.FdName.upper() not in RefFdList: 4577 RefFdList.append (CapsuleDataObj.FdName.upper()) 4578 elif CapsuleDataObj.Ffs != None: 4579 if isinstance(CapsuleDataObj.Ffs, FfsFileStatement.FileStatement): 4580 if CapsuleDataObj.Ffs.FvName != None and CapsuleDataObj.Ffs.FvName.upper() not in RefFvList: 4581 RefFvList.append(CapsuleDataObj.Ffs.FvName.upper()) 4582 elif CapsuleDataObj.Ffs.FdName != None and CapsuleDataObj.Ffs.FdName.upper() not in RefFdList: 4583 RefFdList.append(CapsuleDataObj.Ffs.FdName.upper()) 4584 else: 4585 self.__GetReferencedFdFvTupleFromSection(CapsuleDataObj.Ffs, RefFdList, RefFvList) 4586 4587 ## __GetFvInFd() method 4588 # 4589 # Get FV list contained in FD 4590 # 4591 # @param self The object pointer 4592 # @param FdName FD name 4593 # @retval FvList list of FV in FD 4594 # 4595 def __GetFvInFd (self, FdName): 4596 4597 FvList = [] 4598 if FdName.upper() in self.Profile.FdDict.keys(): 4599 FdObj = self.Profile.FdDict[FdName.upper()] 4600 for elementRegion in FdObj.RegionList: 4601 if elementRegion.RegionType == 'FV': 4602 for elementRegionData in elementRegion.RegionDataList: 4603 if elementRegionData.endswith(".fv"): 4604 continue 4605 if elementRegionData != None and elementRegionData.upper() not in FvList: 4606 FvList.append(elementRegionData.upper()) 4607 return FvList 4608 4609 ## __GetReferencedFdFvTuple() method 4610 # 4611 # Get FD and FV list referenced by a FFS file 4612 # 4613 # @param self The object pointer 4614 # @param FfsFile contains sections to be searched 4615 # @param RefFdList referenced FD by section 4616 # @param RefFvList referenced FV by section 4617 # 4618 def __GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []): 4619 4620 for FfsObj in FvObj.FfsList: 4621 if isinstance(FfsObj, FfsFileStatement.FileStatement): 4622 if FfsObj.FvName != None and FfsObj.FvName.upper() not in RefFvList: 4623 RefFvList.append(FfsObj.FvName.upper()) 4624 elif FfsObj.FdName != None and FfsObj.FdName.upper() not in RefFdList: 4625 RefFdList.append(FfsObj.FdName.upper()) 4626 else: 4627 self.__GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList) 4628 4629 ## __GetReferencedFdFvTupleFromSection() method 4630 # 4631 # Get FD and FV list referenced by a FFS section 4632 # 4633 # @param self The object pointer 4634 # @param FfsFile contains sections to be searched 4635 # @param FdList referenced FD by section 4636 # @param FvList referenced FV by section 4637 # 4638 def __GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []): 4639 4640 SectionStack = [] 4641 SectionStack.extend(FfsFile.SectionList) 4642 while SectionStack != []: 4643 SectionObj = SectionStack.pop() 4644 if isinstance(SectionObj, FvImageSection.FvImageSection): 4645 if SectionObj.FvName != None and SectionObj.FvName.upper() not in FvList: 4646 FvList.append(SectionObj.FvName.upper()) 4647 if SectionObj.Fv != None and SectionObj.Fv.UiFvName != None and SectionObj.Fv.UiFvName.upper() not in FvList: 4648 FvList.append(SectionObj.Fv.UiFvName.upper()) 4649 self.__GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList) 4650 4651 if isinstance(SectionObj, CompressSection.CompressSection) or isinstance(SectionObj, GuidSection.GuidSection): 4652 SectionStack.extend(SectionObj.SectionList) 4653 4654 ## CycleReferenceCheck() method 4655 # 4656 # Check whether cycle reference exists in FDF 4657 # 4658 # @param self The object pointer 4659 # @retval True cycle reference exists 4660 # @retval False Not exists cycle reference 4661 # 4662 def CycleReferenceCheck(self): 4663 # 4664 # Check the cycle between FV and FD image 4665 # 4666 MaxLength = len (self.Profile.FvDict) 4667 for FvName in self.Profile.FvDict.keys(): 4668 LogStr = "\nCycle Reference Checking for FV: %s\n" % FvName 4669 RefFvStack = [] 4670 RefFvStack.append(FvName) 4671 FdAnalyzedList = [] 4672 4673 Index = 0 4674 while RefFvStack != [] and Index < MaxLength: 4675 Index = Index + 1 4676 FvNameFromStack = RefFvStack.pop() 4677 if FvNameFromStack.upper() in self.Profile.FvDict.keys(): 4678 FvObj = self.Profile.FvDict[FvNameFromStack.upper()] 4679 else: 4680 continue 4681 4682 RefFdList = [] 4683 RefFvList = [] 4684 self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList) 4685 4686 for RefFdName in RefFdList: 4687 if RefFdName in FdAnalyzedList: 4688 continue 4689 4690 LogStr += "FV %s contains FD %s\n" % (FvNameFromStack, RefFdName) 4691 FvInFdList = self.__GetFvInFd(RefFdName) 4692 if FvInFdList != []: 4693 for FvNameInFd in FvInFdList: 4694 LogStr += "FD %s contains FV %s\n" % (RefFdName,FvNameInFd) 4695 if FvNameInFd not in RefFvStack: 4696 RefFvStack.append(FvNameInFd) 4697 4698 if FvName in RefFvStack or FvNameFromStack in RefFvStack: 4699 EdkLogger.info(LogStr) 4700 return True 4701 FdAnalyzedList.append(RefFdName) 4702 4703 for RefFvName in RefFvList: 4704 LogStr += "FV %s contains FV %s\n" % (FvNameFromStack, RefFvName) 4705 if RefFvName not in RefFvStack: 4706 RefFvStack.append(RefFvName) 4707 4708 if FvName in RefFvStack or FvNameFromStack in RefFvStack: 4709 EdkLogger.info(LogStr) 4710 return True 4711 4712 # 4713 # Check the cycle between Capsule and FD image 4714 # 4715 MaxLength = len (self.Profile.CapsuleDict) 4716 for CapName in self.Profile.CapsuleDict.keys(): 4717 # 4718 # Capsule image to be checked. 4719 # 4720 LogStr = "\n\n\nCycle Reference Checking for Capsule: %s\n" % CapName 4721 RefCapStack = [] 4722 RefCapStack.append(CapName) 4723 FdAnalyzedList = [] 4724 FvAnalyzedList = [] 4725 4726 Index = 0 4727 while RefCapStack != [] and Index < MaxLength: 4728 Index = Index + 1 4729 CapNameFromStack = RefCapStack.pop() 4730 if CapNameFromStack.upper() in self.Profile.CapsuleDict.keys(): 4731 CapObj = self.Profile.CapsuleDict[CapNameFromStack.upper()] 4732 else: 4733 continue 4734 4735 RefFvList = [] 4736 RefFdList = [] 4737 self.__GetReferencedFdCapTuple(CapObj, RefFdList, RefFvList) 4738 4739 FvListLength = 0 4740 FdListLength = 0 4741 while FvListLength < len (RefFvList) or FdListLength < len (RefFdList): 4742 for RefFdName in RefFdList: 4743 if RefFdName in FdAnalyzedList: 4744 continue 4745 4746 LogStr += "Capsule %s contains FD %s\n" % (CapNameFromStack, RefFdName) 4747 CapInFdList = self.__GetCapInFd(RefFdName) 4748 if CapInFdList != []: 4749 for CapNameInFd in CapInFdList: 4750 LogStr += "FD %s contains Capsule %s\n" % (RefFdName,CapNameInFd) 4751 if CapNameInFd not in RefCapStack: 4752 RefCapStack.append(CapNameInFd) 4753 4754 if CapName in RefCapStack or CapNameFromStack in RefCapStack: 4755 EdkLogger.info(LogStr) 4756 return True 4757 4758 FvInFdList = self.__GetFvInFd(RefFdName) 4759 if FvInFdList != []: 4760 for FvNameInFd in FvInFdList: 4761 LogStr += "FD %s contains FV %s\n" % (RefFdName,FvNameInFd) 4762 if FvNameInFd not in RefFvList: 4763 RefFvList.append(FvNameInFd) 4764 4765 FdAnalyzedList.append(RefFdName) 4766 # 4767 # the number of the parsed FV and FD image 4768 # 4769 FvListLength = len (RefFvList) 4770 FdListLength = len (RefFdList) 4771 for RefFvName in RefFvList: 4772 if RefFvName in FvAnalyzedList: 4773 continue 4774 LogStr += "Capsule %s contains FV %s\n" % (CapNameFromStack, RefFvName) 4775 if RefFvName.upper() in self.Profile.FvDict.keys(): 4776 FvObj = self.Profile.FvDict[RefFvName.upper()] 4777 else: 4778 continue 4779 self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList) 4780 FvAnalyzedList.append(RefFvName) 4781 4782 return False 4783 4784 if __name__ == "__main__": 4785 import sys 4786 try: 4787 test_file = sys.argv[1] 4788 except IndexError, v: 4789 print "Usage: %s filename" % sys.argv[0] 4790 sys.exit(1) 4791 4792 parser = FdfParser(test_file) 4793 try: 4794 parser.ParseFile() 4795 parser.CycleReferenceCheck() 4796 except Warning, X: 4797 print str(X) 4798 else: 4799 print "Success!" 4800 4801
