BaseTools/Source/Python/GenFds/FdfParser.py

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