BaseTools/Source/Python/GenFds/FdfParser.py

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