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