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