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"):
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"):
2771                     raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
2772                 #For FFS, Auto is default option same to ""
2773                 if not self.__Token == "Auto":
2774                     AlignValue = self.__Token
2775             if not self.__GetNextToken():
2776                 raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber)
2777
2778             FileName = self.__Token.replace('$(SPACE)', ' ')
2779             if FileName == '}':
2780                 self.__UndoToken()
2781                 raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber)
2782
2783             self.__VerifyFile(FileName)
2784             File = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir)
2785             FfsFileObj.FileName.append(File.Path)
2786             FfsFileObj.SubAlignment.append(AlignValue)
2787
2788             if self.__IsToken( "}"):
2789                 self.__UndoToken()
2790                 break
2791
2792         if len(FfsFileObj.SubAlignment) == 1:
2793             FfsFileObj.SubAlignment = FfsFileObj.SubAlignment[0]
2794         if len(FfsFileObj.FileName) == 1:
2795             FfsFileObj.FileName = FfsFileObj.FileName[0]
2796
2797     ## __GetFileOpts() method
2798     #
2799     #   Get options for FILE statement
2800     #
2801     #   @param  self        The object pointer
2802     #   @param  FfsFileObj   for whom options is got
2803     #
2804     def __GetFileOpts(self, FfsFileObj):
2805
2806         if self.__GetNextToken():
2807             Pattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
2808             if Pattern.match(self.__Token):
2809                 FfsFileObj.KeyStringList.append(self.__Token)
2810                 if self.__IsToken(","):
2811                     while self.__GetNextToken():
2812                         if not Pattern.match(self.__Token):
2813                             raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)
2814                         FfsFileObj.KeyStringList.append(self.__Token)
2815
2816                         if not self.__IsToken(","):
2817                             break
2818
2819             else:
2820                 self.__UndoToken()
2821
2822         if self.__IsKeyword( "FIXED", True):
2823             FfsFileObj.Fixed = True
2824
2825         if self.__IsKeyword( "CHECKSUM", True):
2826             FfsFileObj.CheckSum = True
2827
2828         if self.__GetAlignment():
2829             if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2830                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
2831             #For FFS, Auto is default option same to ""
2832             if not self.__Token == "Auto":
2833                 FfsFileObj.Alignment = self.__Token
2834
2835     ## __GetAlignment() method
2836     #
2837     #   Return the alignment value
2838     #
2839     #   @param  self        The object pointer
2840     #   @retval True        Successfully find alignment
2841     #   @retval False       Not able to find alignment
2842     #
2843     def __GetAlignment(self):
2844         if self.__IsKeyword( "Align", True):
2845             if not self.__IsToken( "="):
2846                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
2847
2848             if not self.__GetNextToken():
2849                 raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber)
2850             return True
2851
2852         return False
2853
2854     ## __GetFilePart() method
2855     #
2856     #   Get section data for FILE statement
2857     #
2858     #   @param  self        The object pointer
2859     #   @param  FfsFileObj   for whom section is got
2860     #   @param  MacroDict   dictionary used to replace macro
2861     #
2862     def __GetSectionData(self, FfsFileObj, MacroDict = {}):
2863         Dict = {}
2864         Dict.update(MacroDict)
2865
2866         self.__GetDefineStatements(FfsFileObj)
2867
2868         Dict.update(FfsFileObj.DefineVarDict)
2869         self.__GetAprioriSection(FfsFileObj, Dict.copy())
2870         self.__GetAprioriSection(FfsFileObj, Dict.copy())
2871
2872         while True:
2873             IsLeafSection = self.__GetLeafSection(FfsFileObj, Dict)
2874             IsEncapSection = self.__GetEncapsulationSec(FfsFileObj)
2875             if not IsLeafSection and not IsEncapSection:
2876                 break
2877
2878     ## __GetLeafSection() method
2879     #
2880     #   Get leaf section for Obj
2881     #
2882     #   @param  self        The object pointer
2883     #   @param  Obj         for whom leaf section is got
2884     #   @param  MacroDict   dictionary used to replace macro
2885     #   @retval True        Successfully find section statement
2886     #   @retval False       Not able to find section statement
2887     #
2888     def __GetLeafSection(self, Obj, MacroDict = {}):
2889
2890         OldPos = self.GetFileBufferPos()
2891
2892         if not self.__IsKeyword( "SECTION"):
2893             if len(Obj.SectionList) == 0:
2894                 raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber)
2895             else:
2896                 return False
2897
2898         AlignValue = None
2899         if self.__GetAlignment():
2900             if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2901                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
2902             AlignValue = self.__Token
2903
2904         BuildNum = None
2905         if self.__IsKeyword( "BUILD_NUM"):
2906             if not self.__IsToken( "="):
2907                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
2908
2909             if not self.__GetNextToken():
2910                 raise Warning("expected Build number value", self.FileName, self.CurrentLineNumber)
2911
2912             BuildNum = self.__Token
2913
2914         if self.__IsKeyword( "VERSION"):
2915             if AlignValue == 'Auto':
2916                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2917             if not self.__IsToken( "="):
2918                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
2919             if not self.__GetNextToken():
2920                 raise Warning("expected version", self.FileName, self.CurrentLineNumber)
2921             VerSectionObj = VerSection.VerSection()
2922             VerSectionObj.Alignment = AlignValue
2923             VerSectionObj.BuildNum = BuildNum
2924             if self.__GetStringData():
2925                 VerSectionObj.StringData = self.__Token
2926             else:
2927                 VerSectionObj.FileName = self.__Token
2928             Obj.SectionList.append(VerSectionObj)
2929
2930         elif self.__IsKeyword( "UI"):
2931             if AlignValue == 'Auto':
2932                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2933             if not self.__IsToken( "="):
2934                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
2935             if not self.__GetNextToken():
2936                 raise Warning("expected UI", self.FileName, self.CurrentLineNumber)
2937             UiSectionObj = UiSection.UiSection()
2938             UiSectionObj.Alignment = AlignValue
2939             if self.__GetStringData():
2940                 UiSectionObj.StringData = self.__Token
2941             else:
2942                 UiSectionObj.FileName = self.__Token
2943             Obj.SectionList.append(UiSectionObj)
2944
2945         elif self.__IsKeyword( "FV_IMAGE"):
2946             if AlignValue == 'Auto':
2947                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2948             if not self.__IsToken( "="):
2949                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
2950             if not self.__GetNextToken():
2951                 raise Warning("expected FV name or FV file path", self.FileName, self.CurrentLineNumber)
2952
2953             FvName = self.__Token
2954             FvObj = None
2955
2956             if self.__IsToken( "{"):
2957                 FvObj = Fv.FV()
2958                 FvObj.UiFvName = FvName.upper()
2959                 self.__GetDefineStatements(FvObj)
2960                 MacroDict.update(FvObj.DefineVarDict)
2961                 self.__GetBlockStatement(FvObj)
2962                 self.__GetSetStatements(FvObj)
2963                 self.__GetFvAlignment(FvObj)
2964                 self.__GetFvAttributes(FvObj)
2965                 self.__GetAprioriSection(FvObj, MacroDict.copy())
2966                 self.__GetAprioriSection(FvObj, MacroDict.copy())
2967
2968                 while True:
2969                     IsInf = self.__GetInfStatement(FvObj, MacroDict.copy())
2970                     IsFile = self.__GetFileStatement(FvObj, MacroDict.copy())
2971                     if not IsInf and not IsFile:
2972                         break
2973
2974                 if not self.__IsToken( "}"):
2975                     raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)
2976
2977             FvImageSectionObj = FvImageSection.FvImageSection()
2978             FvImageSectionObj.Alignment = AlignValue
2979             if FvObj != None:
2980                 FvImageSectionObj.Fv = FvObj
2981                 FvImageSectionObj.FvName = None
2982             else:
2983                 FvImageSectionObj.FvName = FvName.upper()
2984                 FvImageSectionObj.FvFileName = FvName
2985
2986             Obj.SectionList.append(FvImageSectionObj)
2987
2988         elif self.__IsKeyword("PEI_DEPEX_EXP") or self.__IsKeyword("DXE_DEPEX_EXP") or self.__IsKeyword("SMM_DEPEX_EXP"):
2989             if AlignValue == 'Auto':
2990                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2991             DepexSectionObj = DepexSection.DepexSection()
2992             DepexSectionObj.Alignment = AlignValue
2993             DepexSectionObj.DepexType = self.__Token
2994
2995             if not self.__IsToken( "="):
2996                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
2997             if not self.__IsToken( "{"):
2998                 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)
2999             if not self.__SkipToToken( "}"):
3000                 raise Warning("expected Depex expression ending '}'", self.FileName, self.CurrentLineNumber)
3001
3002             DepexSectionObj.Expression = self.__SkippedChars.rstrip('}')
3003             Obj.SectionList.append(DepexSectionObj)
3004
3005         else:
3006             if not self.__GetNextWord():
3007                 raise Warning("expected section type", self.FileName, self.CurrentLineNumber)
3008
3009             # Encapsulation section appear, UndoToken and return
3010             if self.__Token == "COMPRESS" or self.__Token == "GUIDED":
3011                 self.SetFileBufferPos(OldPos)
3012                 return False
3013
3014             if self.__Token not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3015                                "UI", "VERSION", "PEI_DEPEX", "SUBTYPE_GUID", "SMM_DEPEX"):
3016                 raise Warning("Unknown section type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3017             if AlignValue == 'Auto'and (not self.__Token == 'PE32') and (not self.__Token == 'TE'):
3018                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
3019
3020             # DataSection
3021             DataSectionObj = DataSection.DataSection()
3022             DataSectionObj.Alignment = AlignValue
3023             DataSectionObj.SecType = self.__Token
3024
3025             if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):
3026                 if self.__FileCouldHaveRelocFlag(Obj.FvFileType) and self.__SectionCouldHaveRelocFlag(DataSectionObj.SecType):
3027                     if self.__Token == 'RELOCS_STRIPPED':
3028                         DataSectionObj.KeepReloc = False
3029                     else:
3030                         DataSectionObj.KeepReloc = True
3031                 else:
3032                     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)
3033
3034             if self.__IsToken("="):
3035                 if not self.__GetNextToken():
3036                     raise Warning("expected section file path", self.FileName, self.CurrentLineNumber)
3037                 DataSectionObj.SectFileName = self.__Token
3038                 self.__VerifyFile(DataSectionObj.SectFileName)
3039             else:
3040                 if not self.__GetCglSection(DataSectionObj):
3041                     return False
3042
3043             Obj.SectionList.append(DataSectionObj)
3044
3045         return True
3046
3047     ## __VerifyFile
3048     #
3049     #    Check if file exists or not:
3050     #      If current phase if GenFds, the file must exist;
3051     #      If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist
3052     #    @param FileName: File path to be verified.
3053     #
3054     def __VerifyFile(self, FileName):
3055         if FileName.replace('$(WORKSPACE)', '').find('$') != -1:
3056             return
3057         if not GlobalData.gAutoGenPhase or not self.__GetMacroValue("OUTPUT_DIRECTORY") in FileName:
3058             ErrorCode, ErrorInfo = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()
3059             if ErrorCode != 0:
3060                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
3061
3062     ## __GetCglSection() method
3063     #
3064     #   Get compressed or GUIDed section for Obj
3065     #
3066     #   @param  self        The object pointer
3067     #   @param  Obj         for whom leaf section is got
3068     #   @param  AlignValue  alignment value for complex section
3069     #   @retval True        Successfully find section statement
3070     #   @retval False       Not able to find section statement
3071     #
3072     def __GetCglSection(self, Obj, AlignValue = None):
3073
3074         if self.__IsKeyword( "COMPRESS"):
3075             type = "PI_STD"
3076             if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):
3077                 type = self.__Token
3078
3079             if not self.__IsToken("{"):
3080                 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)
3081
3082             CompressSectionObj = CompressSection.CompressSection()
3083             CompressSectionObj.Alignment = AlignValue
3084             CompressSectionObj.CompType = type
3085             # Recursive sections...
3086             while True:
3087                 IsLeafSection = self.__GetLeafSection(CompressSectionObj)
3088                 IsEncapSection = self.__GetEncapsulationSec(CompressSectionObj)
3089                 if not IsLeafSection and not IsEncapSection:
3090                     break
3091
3092
3093             if not self.__IsToken( "}"):
3094                 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)
3095             Obj.SectionList.append(CompressSectionObj)
3096
3097 #            else:
3098 #               raise Warning("Compress type not known")
3099
3100             return True
3101
3102         elif self.__IsKeyword( "GUIDED"):
3103             GuidValue = None
3104             if self.__GetNextGuid():
3105                 GuidValue = self.__Token
3106
3107             AttribDict = self.__GetGuidAttrib()
3108             if not self.__IsToken("{"):
3109                 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)
3110             GuidSectionObj = GuidSection.GuidSection()
3111             GuidSectionObj.Alignment = AlignValue
3112             GuidSectionObj.NameGuid = GuidValue
3113             GuidSectionObj.SectionType = "GUIDED"
3114             GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]
3115             GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]
3116             GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"]
3117             # Recursive sections...
3118             while True:
3119                 IsLeafSection = self.__GetLeafSection(GuidSectionObj)
3120                 IsEncapSection = self.__GetEncapsulationSec(GuidSectionObj)
3121                 if not IsLeafSection and not IsEncapSection:
3122                     break
3123
3124             if not self.__IsToken( "}"):
3125                 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)
3126             Obj.SectionList.append(GuidSectionObj)
3127
3128             return True
3129
3130         return False
3131
3132     ## __GetGuidAttri() method
3133     #
3134     #   Get attributes for GUID section
3135     #
3136     #   @param  self        The object pointer
3137     #   @retval AttribDict  Dictionary of key-value pair of section attributes
3138     #
3139     def __GetGuidAttrib(self):
3140
3141         AttribDict = {}
3142         AttribDict["PROCESSING_REQUIRED"] = "NONE"
3143         AttribDict["AUTH_STATUS_VALID"] = "NONE"
3144         AttribDict["EXTRA_HEADER_SIZE"] = -1
3145         while self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID") \
3146             or self.__IsKeyword("EXTRA_HEADER_SIZE"):
3147             AttribKey = self.__Token
3148
3149             if not self.__IsToken("="):
3150                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3151
3152             if not self.__GetNextToken():
3153                 raise Warning("expected TRUE(1)/FALSE(0)/Number", self.FileName, self.CurrentLineNumber)
3154             elif AttribKey == "EXTRA_HEADER_SIZE":
3155                 Base = 10
3156                 if self.__Token[0:2].upper() == "0X":
3157                     Base = 16
3158                 try:
3159                     AttribDict[AttribKey] = int(self.__Token, Base)
3160                     continue
3161                 except ValueError:
3162                     raise Warning("expected Number", self.FileName, self.CurrentLineNumber)
3163             elif self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):
3164                 raise Warning("expected TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber)
3165             AttribDict[AttribKey] = self.__Token
3166
3167         return AttribDict
3168
3169     ## __GetEncapsulationSec() method
3170     #
3171     #   Get encapsulation section for FILE
3172     #
3173     #   @param  self        The object pointer
3174     #   @param  FfsFile     for whom section is got
3175     #   @retval True        Successfully find section statement
3176     #   @retval False       Not able to find section statement
3177     #
3178     def __GetEncapsulationSec(self, FfsFileObj):
3179
3180         OldPos = self.GetFileBufferPos()
3181         if not self.__IsKeyword( "SECTION"):
3182             if len(FfsFileObj.SectionList) == 0:
3183                 raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber)
3184             else:
3185                 return False
3186
3187         AlignValue = None
3188         if self.__GetAlignment():
3189             if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3190                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3191             AlignValue = self.__Token
3192
3193         if not self.__GetCglSection(FfsFileObj, AlignValue):
3194             self.SetFileBufferPos(OldPos)
3195             return False
3196         else:
3197             return True
3198
3199     def __GetFmp(self):
3200         if not self.__GetNextToken():
3201             return False
3202         S = self.__Token.upper()
3203         if S.startswith("[") and not S.startswith("[FMPPAYLOAD."):
3204             self.SectionParser(S)
3205             self.__UndoToken()
3206             return False
3207
3208         self.__UndoToken()
3209         self.__SkipToToken("[FMPPAYLOAD.", True)
3210         FmpUiName = self.__GetUiName().upper()
3211         if FmpUiName in self.Profile.FmpPayloadDict:
3212             raise Warning("Duplicated FMP UI name found: %s" % FmpUiName, self.FileName, self.CurrentLineNumber)
3213
3214         FmpData = CapsuleData.CapsulePayload()
3215         FmpData.UiName = FmpUiName
3216
3217         if not self.__IsToken( "]"):
3218             raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)
3219
3220         if not self.__GetNextToken():
3221             raise Warning("The FMP payload section is empty!", self.FileName, self.CurrentLineNumber)
3222         FmpKeyList = ['IMAGE_HEADER_INIT_VERSION', 'IMAGE_TYPE_ID', 'IMAGE_INDEX', 'HARDWARE_INSTANCE', 'CERTIFICATE_GUID', 'MONOTONIC_COUNT']
3223         while self.__Token in FmpKeyList:
3224             Name = self.__Token
3225             FmpKeyList.remove(Name)
3226             if not self.__IsToken("="):
3227                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3228             if Name == 'IMAGE_TYPE_ID':
3229                 if not self.__GetNextGuid():
3230                     raise Warning("expected GUID value for IMAGE_TYPE_ID.", self.FileName, self.CurrentLineNumber)
3231                 FmpData.ImageTypeId = self.__Token
3232             elif Name == 'CERTIFICATE_GUID':
3233                 if not self.__GetNextGuid():
3234                     raise Warning("expected GUID value for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber)
3235                 FmpData.Certificate_Guid = self.__Token
3236                 if uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_RSA2048_SHA256_GUID and uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_PKCS7_GUID:
3237                     raise Warning("Only support EFI_CERT_TYPE_RSA2048_SHA256_GUID or EFI_CERT_TYPE_PKCS7_GUID for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber)
3238             else:
3239                 if not self.__GetNextToken():
3240                     raise Warning("expected value of %s" % Name, self.FileName, self.CurrentLineNumber)
3241                 Value = self.__Token
3242                 if Name == 'IMAGE_HEADER_INIT_VERSION':
3243                     if self.__Verify(Name, Value, 'UINT8'):
3244                         FmpData.Version = Value
3245                 elif Name == 'IMAGE_INDEX':
3246                     if self.__Verify(Name, Value, 'UINT8'):
3247                         FmpData.ImageIndex = Value
3248                 elif Name == 'HARDWARE_INSTANCE':
3249                     if self.__Verify(Name, Value, 'UINT8'):
3250                         FmpData.HardwareInstance = Value
3251                 elif Name == 'MONOTONIC_COUNT':
3252                     if self.__Verify(Name, Value, 'UINT64'):
3253                         FmpData.MonotonicCount = Value
3254                         if FmpData.MonotonicCount.upper().startswith('0X'):
3255                             FmpData.MonotonicCount = (long)(FmpData.MonotonicCount, 16)
3256                         else:
3257                             FmpData.MonotonicCount = (long)(FmpData.MonotonicCount)
3258             if not self.__GetNextToken():
3259                 break
3260         else:
3261             self.__UndoToken()
3262
3263         if (FmpData.MonotonicCount and not FmpData.Certificate_Guid) or (not FmpData.MonotonicCount and FmpData.Certificate_Guid):
3264             EdkLogger.error("FdfParser", FORMAT_INVALID, "CERTIFICATE_GUID and MONOTONIC_COUNT must be work as a pair.")
3265
3266         # Only the IMAGE_TYPE_ID is required item
3267         if FmpKeyList and 'IMAGE_TYPE_ID' in FmpKeyList:
3268             raise Warning("Missing keywords IMAGE_TYPE_ID in FMP payload section.", self.FileName, self.CurrentLineNumber)
3269         # get the Image file and Vendor code file
3270         self.__GetFMPCapsuleData(FmpData)
3271         if not FmpData.ImageFile:
3272             raise Warning("Missing image file in FMP payload section.", self.FileName, self.CurrentLineNumber)
3273         # check whether more than one Vendor code file
3274         if len(FmpData.VendorCodeFile) > 1:
3275             raise Warning("At most one Image file and one Vendor code file are allowed in FMP payload section.", self.FileName, self.CurrentLineNumber)
3276         self.Profile.FmpPayloadDict[FmpUiName] = FmpData
3277         return True
3278
3279     ## __GetCapsule() method
3280     #
3281     #   Get capsule section contents and store its data into capsule list of self.Profile
3282     #
3283     #   @param  self        The object pointer
3284     #   @retval True        Successfully find a capsule
3285     #   @retval False       Not able to find a capsule
3286     #
3287     def __GetCapsule(self):
3288
3289         if not self.__GetNextToken():
3290             return False
3291
3292         S = self.__Token.upper()
3293         if S.startswith("[") and not S.startswith("[CAPSULE."):
3294             self.SectionParser(S)
3295             self.__UndoToken()
3296             return False
3297
3298         self.__UndoToken()
3299         if not self.__IsToken("[CAPSULE.", True):
3300             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
3301             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
3302             #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
3303             raise Warning("expected [Capsule.]", self.FileName, self.CurrentLineNumber)
3304
3305         CapsuleObj = Capsule.Capsule()
3306
3307         CapsuleName = self.__GetUiName()
3308         if not CapsuleName:
3309             raise Warning("expected capsule name", self.FileName, self.CurrentLineNumber)
3310
3311         CapsuleObj.UiCapsuleName = CapsuleName.upper()
3312
3313         if not self.__IsToken( "]"):
3314             raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)
3315
3316         if self.__IsKeyword("CREATE_FILE"):
3317             if not self.__IsToken( "="):
3318                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3319
3320             if not self.__GetNextToken():
3321                 raise Warning("expected file name", self.FileName, self.CurrentLineNumber)
3322
3323             CapsuleObj.CreateFile = self.__Token
3324
3325         self.__GetCapsuleStatements(CapsuleObj)
3326         self.Profile.CapsuleDict[CapsuleObj.UiCapsuleName] = CapsuleObj
3327         return True
3328
3329     ## __GetCapsuleStatements() method
3330     #
3331     #   Get statements for capsule
3332     #
3333     #   @param  self        The object pointer
3334     #   @param  Obj         for whom statements are got
3335     #
3336     def __GetCapsuleStatements(self, Obj):
3337         self.__GetCapsuleTokens(Obj)
3338         self.__GetDefineStatements(Obj)
3339         self.__GetSetStatements(Obj)
3340         self.__GetCapsuleData(Obj)
3341
3342     ## __GetCapsuleTokens() method
3343     #
3344     #   Get token statements for capsule
3345     #
3346     #   @param  self        The object pointer
3347     #   @param  Obj         for whom token statements are got
3348     #
3349     def __GetCapsuleTokens(self, Obj):
3350         if not self.__GetNextToken():
3351             return False
3352         while self.__Token in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"):
3353             Name = self.__Token.strip()
3354             if not self.__IsToken("="):
3355                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3356             if not self.__GetNextToken():
3357                 raise Warning("expected value", self.FileName, self.CurrentLineNumber)
3358             if Name == 'CAPSULE_FLAGS':
3359                 if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):
3360                     raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)
3361                 Value = self.__Token.strip()
3362                 while self.__IsToken(","):
3363                     Value += ','
3364                     if not self.__GetNextToken():
3365                         raise Warning("expected value", self.FileName, self.CurrentLineNumber)
3366                     if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):
3367                         raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)
3368                     Value += self.__Token.strip()
3369             elif Name == 'OEM_CAPSULE_FLAGS':
3370                 Value = self.__Token.strip()
3371                 if not Value.upper().startswith('0X'):
3372                     raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)
3373                 try:
3374                     Value = int(Value, 0)
3375                 except ValueError:
3376                     raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)
3377                 if not 0x0000 <= Value <= 0xFFFF:
3378                     raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)
3379                 Value = self.__Token.strip()
3380             else:
3381                 Value = self.__Token.strip()
3382             Obj.TokensDict[Name] = Value
3383             if not self.__GetNextToken():
3384                 return False
3385         self.__UndoToken()
3386
3387     ## __GetCapsuleData() method
3388     #
3389     #   Get capsule data for capsule
3390     #
3391     #   @param  self        The object pointer
3392     #   @param  Obj         for whom capsule data are got
3393     #
3394     def __GetCapsuleData(self, Obj):
3395
3396         while True:
3397             IsInf = self.__GetInfStatement(Obj, True)
3398             IsFile = self.__GetFileStatement(Obj, True)
3399             IsFv = self.__GetFvStatement(Obj)
3400             IsFd = self.__GetFdStatement(Obj)
3401             IsAnyFile = self.__GetAnyFileStatement(Obj)
3402             IsAfile = self.__GetAfileStatement(Obj)
3403             IsFmp = self.__GetFmpStatement(Obj)
3404             if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile or IsAfile or IsFmp):
3405                 break
3406
3407     ## __GetFMPCapsuleData() method
3408     #
3409     #   Get capsule data for FMP capsule
3410     #
3411     #   @param  self        The object pointer
3412     #   @param  Obj         for whom capsule data are got
3413     #
3414     def __GetFMPCapsuleData(self, Obj):
3415
3416         while True:
3417             IsFv = self.__GetFvStatement(Obj, True)
3418             IsFd = self.__GetFdStatement(Obj, True)
3419             IsAnyFile = self.__GetAnyFileStatement(Obj, True)
3420             if not (IsFv or IsFd or IsAnyFile):
3421                 break
3422
3423     ## __GetFvStatement() method
3424     #
3425     #   Get FV for capsule
3426     #
3427     #   @param  self        The object pointer
3428     #   @param  CapsuleObj  for whom FV is got
3429     #   @retval True        Successfully find a FV statement
3430     #   @retval False       Not able to find a FV statement
3431     #
3432     def __GetFvStatement(self, CapsuleObj, FMPCapsule = False):
3433
3434         if not self.__IsKeyword("FV"):
3435             return False
3436
3437         if not self.__IsToken("="):
3438             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3439
3440         if not self.__GetNextToken():
3441             raise Warning("expected FV name", self.FileName, self.CurrentLineNumber)
3442
3443         if self.__Token.upper() not in self.Profile.FvDict.keys():
3444             raise Warning("FV name does not exist", self.FileName, self.CurrentLineNumber)
3445
3446         CapsuleFv = CapsuleData.CapsuleFv()
3447         CapsuleFv.FvName = self.__Token
3448         if FMPCapsule:
3449             if not CapsuleObj.ImageFile:
3450                 CapsuleObj.ImageFile.append(CapsuleFv)
3451             else:
3452                 CapsuleObj.VendorCodeFile.append(CapsuleFv)
3453         else:
3454             CapsuleObj.CapsuleDataList.append(CapsuleFv)
3455         return True
3456
3457     ## __GetFdStatement() method
3458     #
3459     #   Get FD for capsule
3460     #
3461     #   @param  self        The object pointer
3462     #   @param  CapsuleObj  for whom FD is got
3463     #   @retval True        Successfully find a FD statement
3464     #   @retval False       Not able to find a FD statement
3465     #
3466     def __GetFdStatement(self, CapsuleObj, FMPCapsule = False):
3467
3468         if not self.__IsKeyword("FD"):
3469             return False
3470
3471         if not self.__IsToken("="):
3472             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3473
3474         if not self.__GetNextToken():
3475             raise Warning("expected FD name", self.FileName, self.CurrentLineNumber)
3476
3477         if self.__Token.upper() not in self.Profile.FdDict.keys():
3478             raise Warning("FD name does not exist", self.FileName, self.CurrentLineNumber)
3479
3480         CapsuleFd = CapsuleData.CapsuleFd()
3481         CapsuleFd.FdName = self.__Token
3482         if FMPCapsule:
3483             if not CapsuleObj.ImageFile:
3484                 CapsuleObj.ImageFile.append(CapsuleFd)
3485             else:
3486                 CapsuleObj.VendorCodeFile.append(CapsuleFd)
3487         else:
3488             CapsuleObj.CapsuleDataList.append(CapsuleFd)
3489         return True
3490
3491     def __GetFmpStatement(self, CapsuleObj):
3492         if not self.__IsKeyword("FMP_PAYLOAD"):
3493             if not self.__IsKeyword("FMP"):
3494                 return False
3495
3496             if not self.__IsKeyword("PAYLOAD"):
3497                 self.__UndoToken()
3498                 return False
3499
3500         if not self.__IsToken("="):
3501             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3502
3503         if not self.__GetNextToken():
3504             raise Warning("expected payload name after FMP_PAYLOAD =", self.FileName, self.CurrentLineNumber)
3505         Payload = self.__Token.upper()
3506         if Payload not in self.Profile.FmpPayloadDict:
3507             raise Warning("This FMP Payload does not exist: %s" % self.__Token, self.FileName, self.CurrentLineNumber)
3508         CapsuleObj.FmpPayloadList.append(self.Profile.FmpPayloadDict[Payload])
3509         return True
3510
3511     def __ParseRawFileStatement(self):
3512         if not self.__IsKeyword("FILE"):
3513             return None
3514
3515         if not self.__IsKeyword("DATA"):
3516             self.__UndoToken()
3517             return None
3518
3519         if not self.__IsToken("="):
3520             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3521
3522         if not self.__GetNextToken():
3523             raise Warning("expected File name", self.FileName, self.CurrentLineNumber)
3524
3525         AnyFileName = self.__Token
3526         self.__VerifyFile(AnyFileName)
3527
3528         if not os.path.isabs(AnyFileName):
3529             AnyFileName = mws.join(GenFdsGlobalVariable.WorkSpaceDir, AnyFileName)
3530
3531         return AnyFileName
3532
3533     ## __GetAnyFileStatement() method
3534     #
3535     #   Get AnyFile for capsule
3536     #
3537     #   @param  self        The object pointer
3538     #   @param  CapsuleObj  for whom AnyFile is got
3539     #   @retval True        Successfully find a Anyfile statement
3540     #   @retval False       Not able to find a AnyFile statement
3541     #
3542     def __GetAnyFileStatement(self, CapsuleObj, FMPCapsule = False):
3543         AnyFileName = self.__ParseRawFileStatement()
3544         if not AnyFileName:
3545             return False
3546
3547         CapsuleAnyFile = CapsuleData.CapsuleAnyFile()
3548         CapsuleAnyFile.FileName = AnyFileName
3549         if FMPCapsule:
3550             if not CapsuleObj.ImageFile:
3551                 CapsuleObj.ImageFile.append(CapsuleAnyFile)
3552             else:
3553                 CapsuleObj.VendorCodeFile.append(CapsuleAnyFile)
3554         else:
3555             CapsuleObj.CapsuleDataList.append(CapsuleAnyFile)
3556         return True
3557
3558     ## __GetAfileStatement() method
3559     #
3560     #   Get Afile for capsule
3561     #
3562     #   @param  self        The object pointer
3563     #   @param  CapsuleObj  for whom Afile is got
3564     #   @retval True        Successfully find a Afile statement
3565     #   @retval False       Not able to find a Afile statement
3566     #
3567     def __GetAfileStatement(self, CapsuleObj):
3568
3569         if not self.__IsKeyword("APPEND"):
3570             return False
3571
3572         if not self.__IsToken("="):
3573             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3574
3575         if not self.__GetNextToken():
3576             raise Warning("expected Afile name", self.FileName, self.CurrentLineNumber)
3577
3578         AfileName = self.__Token
3579         AfileBaseName = os.path.basename(AfileName)
3580
3581         if os.path.splitext(AfileBaseName)[1]  not in [".bin",".BIN",".Bin",".dat",".DAT",".Dat",".data",".DATA",".Data"]:
3582             raise Warning('invalid binary file type, should be one of "bin","BIN","Bin","dat","DAT","Dat","data","DATA","Data"', \
3583                           self.FileName, self.CurrentLineNumber)
3584
3585         if not os.path.isabs(AfileName):
3586             AfileName = GenFdsGlobalVariable.ReplaceWorkspaceMacro(AfileName)
3587             self.__VerifyFile(AfileName)
3588         else:
3589             if not os.path.exists(AfileName):
3590                 raise Warning('%s does not exist' % AfileName, self.FileName, self.CurrentLineNumber)
3591             else:
3592                 pass
3593
3594         CapsuleAfile = CapsuleData.CapsuleAfile()
3595         CapsuleAfile.FileName = AfileName
3596         CapsuleObj.CapsuleDataList.append(CapsuleAfile)
3597         return True
3598
3599     ## __GetRule() method
3600     #
3601     #   Get Rule section contents and store its data into rule list of self.Profile
3602     #
3603     #   @param  self        The object pointer
3604     #   @retval True        Successfully find a Rule
3605     #   @retval False       Not able to find a Rule
3606     #
3607     def __GetRule(self):
3608
3609         if not self.__GetNextToken():
3610             return False
3611
3612         S = self.__Token.upper()
3613         if S.startswith("[") and not S.startswith("[RULE."):
3614             self.SectionParser(S)
3615             self.__UndoToken()
3616             return False
3617         self.__UndoToken()
3618         if not self.__IsToken("[Rule.", True):
3619             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
3620             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
3621             #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
3622             raise Warning("expected [Rule.]", self.FileName, self.CurrentLineNumber)
3623
3624         if not self.__SkipToToken("."):
3625             raise Warning("expected '.'", self.FileName, self.CurrentLineNumber)
3626
3627         Arch = self.__SkippedChars.rstrip(".")
3628         if Arch.upper() not in ("IA32", "X64", "IPF", "EBC", "ARM", "AARCH64", "COMMON"):
3629             raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber)
3630
3631         ModuleType = self.__GetModuleType()
3632
3633         TemplateName = ""
3634         if self.__IsToken("."):
3635             if not self.__GetNextWord():
3636                 raise Warning("expected template name", self.FileName, self.CurrentLineNumber)
3637             TemplateName = self.__Token
3638
3639         if not self.__IsToken( "]"):
3640             raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)
3641
3642         RuleObj = self.__GetRuleFileStatements()
3643         RuleObj.Arch = Arch.upper()
3644         RuleObj.ModuleType = ModuleType
3645         RuleObj.TemplateName = TemplateName
3646         if TemplateName == '' :
3647             self.Profile.RuleDict['RULE'             + \
3648                               '.'                    + \
3649                               Arch.upper()           + \
3650                               '.'                    + \
3651                               ModuleType.upper()     ] = RuleObj
3652         else :
3653             self.Profile.RuleDict['RULE'             + \
3654                               '.'                    + \
3655                               Arch.upper()           + \
3656                               '.'                    + \
3657                               ModuleType.upper()     + \
3658                               '.'                    + \
3659                               TemplateName.upper() ] = RuleObj
3660 #        self.Profile.RuleList.append(rule)
3661         return True
3662
3663     ## __GetModuleType() method
3664     #
3665     #   Return the module type
3666     #
3667     #   @param  self        The object pointer
3668     #   @retval string      module type
3669     #
3670     def __GetModuleType(self):
3671
3672         if not self.__GetNextWord():
3673             raise Warning("expected Module type", self.FileName, self.CurrentLineNumber)
3674         if self.__Token.upper() not in ("SEC", "PEI_CORE", "PEIM", "DXE_CORE", \
3675                              "DXE_DRIVER", "DXE_SAL_DRIVER", \
3676                              "DXE_SMM_DRIVER", "DXE_RUNTIME_DRIVER", \
3677                              "UEFI_DRIVER", "UEFI_APPLICATION", "USER_DEFINED", "DEFAULT", "BASE", \
3678                              "SECURITY_CORE", "COMBINED_PEIM_DRIVER", "PIC_PEIM", "RELOCATABLE_PEIM", \
3679                                         "PE32_PEIM", "BS_DRIVER", "RT_DRIVER", "SAL_RT_DRIVER", "APPLICATION", "ACPITABLE", "SMM_CORE", "MM_STANDALONE", "MM_CORE_STANDALONE"):
3680             raise Warning("Unknown Module type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3681         return self.__Token
3682
3683     ## __GetFileExtension() method
3684     #
3685     #   Return the file extension
3686     #
3687     #   @param  self        The object pointer
3688     #   @retval string      file name extension
3689     #
3690     def __GetFileExtension(self):
3691         if not self.__IsToken("."):
3692             raise Warning("expected '.'", self.FileName, self.CurrentLineNumber)
3693
3694         Ext = ""
3695         if self.__GetNextToken():
3696             Pattern = re.compile(r'([a-zA-Z][a-zA-Z0-9]*)')
3697             if Pattern.match(self.__Token):
3698                 Ext = self.__Token
3699                 return '.' + Ext
3700             else:
3701                 raise Warning("Unknown file extension '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3702
3703         else:
3704             raise Warning("expected file extension", self.FileName, self.CurrentLineNumber)
3705
3706     ## __GetRuleFileStatement() method
3707     #
3708     #   Get rule contents
3709     #
3710     #   @param  self        The object pointer
3711     #   @retval Rule        Rule object
3712     #
3713     def __GetRuleFileStatements(self):
3714
3715         if not self.__IsKeyword("FILE"):
3716             raise Warning("expected FILE", self.FileName, self.CurrentLineNumber)
3717
3718         if not self.__GetNextWord():
3719             raise Warning("expected FFS type", self.FileName, self.CurrentLineNumber)
3720
3721         Type = self.__Token.strip().upper()
3722         if Type not in ("RAW", "FREEFORM", "SEC", "PEI_CORE", "PEIM",\
3723                              "PEI_DXE_COMBO", "DRIVER", "DXE_CORE", "APPLICATION", "FV_IMAGE", "SMM", "SMM_CORE", "MM_STANDALONE", "MM_CORE_STANDALONE"):
3724             raise Warning("Unknown FV type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3725
3726         if not self.__IsToken("="):
3727             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3728
3729         if not self.__IsKeyword("$(NAMED_GUID)"):
3730             if not self.__GetNextWord():
3731                 raise Warning("expected $(NAMED_GUID)", self.FileName, self.CurrentLineNumber)
3732             if self.__Token == 'PCD':
3733                 if not self.__IsToken( "("):
3734                     raise Warning("expected '('", self.FileName, self.CurrentLineNumber)
3735                 PcdPair = self.__GetNextPcdName()
3736                 if not self.__IsToken( ")"):
3737                     raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)
3738                 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'
3739
3740         NameGuid = self.__Token
3741
3742         KeepReloc = None
3743         if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):
3744             if self.__FileCouldHaveRelocFlag(Type):
3745                 if self.__Token == 'RELOCS_STRIPPED':
3746                     KeepReloc = False
3747                 else:
3748                     KeepReloc = True
3749             else:
3750                 raise Warning("File type %s could not have reloc strip flag%d" % (Type, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3751
3752         KeyStringList = []
3753         if self.__GetNextToken():
3754             Pattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
3755             if Pattern.match(self.__Token):
3756                 KeyStringList.append(self.__Token)
3757                 if self.__IsToken(","):
3758                     while self.__GetNextToken():
3759                         if not Pattern.match(self.__Token):
3760                             raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)
3761                         KeyStringList.append(self.__Token)
3762
3763                         if not self.__IsToken(","):
3764                             break
3765
3766             else:
3767                 self.__UndoToken()
3768
3769
3770         Fixed = False
3771         if self.__IsKeyword("Fixed", True):
3772             Fixed = True
3773
3774         CheckSum = False
3775         if self.__IsKeyword("CheckSum", True):
3776             CheckSum = True
3777
3778         AlignValue = ""
3779         if self.__GetAlignment():
3780             if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3781                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3782             #For FFS, Auto is default option same to ""
3783             if not self.__Token == "Auto":
3784                 AlignValue = self.__Token
3785
3786         if self.__IsToken("{"):
3787             # Complex file rule expected
3788             Rule = RuleComplexFile.RuleComplexFile()
3789             Rule.FvFileType = Type
3790             Rule.NameGuid = NameGuid
3791             Rule.Alignment = AlignValue
3792             Rule.CheckSum = CheckSum
3793             Rule.Fixed = Fixed
3794             Rule.KeyStringList = KeyStringList
3795             if KeepReloc != None:
3796                 Rule.KeepReloc = KeepReloc
3797
3798             while True:
3799                 IsEncapsulate = self.__GetRuleEncapsulationSection(Rule)
3800                 IsLeaf = self.__GetEfiSection(Rule)
3801                 if not IsEncapsulate and not IsLeaf:
3802                     break
3803
3804             if not self.__IsToken("}"):
3805                 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)
3806
3807             return Rule
3808
3809         else:
3810             # Simple file rule expected
3811             if not self.__GetNextWord():
3812                 raise Warning("expected leaf section type", self.FileName, self.CurrentLineNumber)
3813
3814             SectionName = self.__Token
3815
3816             if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3817                                     "UI", "PEI_DEPEX", "VERSION", "SUBTYPE_GUID", "SMM_DEPEX"):
3818                 raise Warning("Unknown leaf section name '%s'" % SectionName, self.FileName, self.CurrentLineNumber)
3819
3820
3821             if self.__IsKeyword("Fixed", True):
3822                 Fixed = True
3823
3824             if self.__IsKeyword("CheckSum", True):
3825                 CheckSum = True
3826
3827             SectAlignment = ""
3828             if self.__GetAlignment():
3829                 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3830                     raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3831                 if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'):
3832                     raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
3833                 SectAlignment = self.__Token
3834
3835             Ext = None
3836             if self.__IsToken('|'):
3837                 Ext = self.__GetFileExtension()
3838             elif not self.__GetNextToken():
3839                 raise Warning("expected File name", self.FileName, self.CurrentLineNumber)
3840
3841             Rule = RuleSimpleFile.RuleSimpleFile()
3842             Rule.SectionType = SectionName
3843             Rule.FvFileType = Type
3844             Rule.NameGuid = NameGuid
3845             Rule.Alignment = AlignValue
3846             Rule.SectAlignment = SectAlignment
3847             Rule.CheckSum = CheckSum
3848             Rule.Fixed = Fixed
3849             Rule.KeyStringList = KeyStringList
3850             if KeepReloc != None:
3851                 Rule.KeepReloc = KeepReloc
3852             Rule.FileExtension = Ext
3853             Rule.FileName = self.__Token
3854             return Rule
3855
3856     ## __GetEfiSection() method
3857     #
3858     #   Get section list for Rule
3859     #
3860     #   @param  self        The object pointer
3861     #   @param  Obj         for whom section is got
3862     #   @retval True        Successfully find section statement
3863     #   @retval False       Not able to find section statement
3864     #
3865     def __GetEfiSection(self, Obj):
3866
3867         OldPos = self.GetFileBufferPos()
3868         if not self.__GetNextWord():
3869             return False
3870         SectionName = self.__Token
3871
3872         if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3873                                "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3874             self.__UndoToken()
3875             return False
3876
3877         if SectionName == "FV_IMAGE":
3878             FvImageSectionObj = FvImageSection.FvImageSection()
3879             if self.__IsKeyword("FV_IMAGE"):
3880                 pass
3881             if self.__IsToken( "{"):
3882                 FvObj = Fv.FV()
3883                 self.__GetDefineStatements(FvObj)
3884                 self.__GetBlockStatement(FvObj)
3885                 self.__GetSetStatements(FvObj)
3886                 self.__GetFvAlignment(FvObj)
3887                 self.__GetFvAttributes(FvObj)
3888                 self.__GetAprioriSection(FvObj)
3889                 self.__GetAprioriSection(FvObj)
3890
3891                 while True:
3892                     IsInf = self.__GetInfStatement(FvObj)
3893                     IsFile = self.__GetFileStatement(FvObj)
3894                     if not IsInf and not IsFile:
3895                         break
3896
3897                 if not self.__IsToken( "}"):
3898                     raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)
3899                 FvImageSectionObj.Fv = FvObj
3900                 FvImageSectionObj.FvName = None
3901
3902             else:
3903                 if not self.__IsKeyword("FV"):
3904                     raise Warning("expected 'FV'", self.FileName, self.CurrentLineNumber)
3905                 FvImageSectionObj.FvFileType = self.__Token
3906
3907                 if self.__GetAlignment():
3908                     if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3909                         raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3910                     FvImageSectionObj.Alignment = self.__Token
3911
3912                 if self.__IsToken('|'):
3913                     FvImageSectionObj.FvFileExtension = self.__GetFileExtension()
3914                 elif self.__GetNextToken():
3915                     if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3916                                "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3917                         FvImageSectionObj.FvFileName = self.__Token
3918                     else:
3919                         self.__UndoToken()
3920                 else:
3921                     raise Warning("expected FV file name", self.FileName, self.CurrentLineNumber)
3922
3923             Obj.SectionList.append(FvImageSectionObj)
3924             return True
3925
3926         EfiSectionObj = EfiSection.EfiSection()
3927         EfiSectionObj.SectionType = SectionName
3928
3929         if not self.__GetNextToken():
3930             raise Warning("expected file type", self.FileName, self.CurrentLineNumber)
3931
3932         if self.__Token == "STRING":
3933             if not self.__RuleSectionCouldHaveString(EfiSectionObj.SectionType):
3934                 raise Warning("%s section could NOT have string data%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3935
3936             if not self.__IsToken('='):
3937                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3938
3939             if not self.__GetNextToken():
3940                 raise Warning("expected Quoted String", self.FileName, self.CurrentLineNumber)
3941
3942             if self.__GetStringData():
3943                 EfiSectionObj.StringData = self.__Token
3944
3945             if self.__IsKeyword("BUILD_NUM"):
3946                 if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):
3947                     raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3948
3949                 if not self.__IsToken("="):
3950                     raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3951                 if not self.__GetNextToken():
3952                     raise Warning("expected Build number", self.FileName, self.CurrentLineNumber)
3953                 EfiSectionObj.BuildNum = self.__Token
3954
3955         else:
3956             EfiSectionObj.FileType = self.__Token
3957             self.__CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType)
3958
3959         if self.__IsKeyword("Optional"):
3960             if not self.__RuleSectionCouldBeOptional(EfiSectionObj.SectionType):
3961                 raise Warning("%s section could NOT be optional%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3962             EfiSectionObj.Optional = True
3963
3964             if self.__IsKeyword("BUILD_NUM"):
3965                 if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):
3966                     raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3967
3968                 if not self.__IsToken("="):
3969                     raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
3970                 if not self.__GetNextToken():
3971                     raise Warning("expected Build number", self.FileName, self.CurrentLineNumber)
3972                 EfiSectionObj.BuildNum = self.__Token
3973
3974         if self.__GetAlignment():
3975             if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3976                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3977             if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'):
3978                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
3979             EfiSectionObj.Alignment = self.__Token
3980
3981         if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):
3982             if self.__SectionCouldHaveRelocFlag(EfiSectionObj.SectionType):
3983                 if self.__Token == 'RELOCS_STRIPPED':
3984                     EfiSectionObj.KeepReloc = False
3985                 else:
3986                     EfiSectionObj.KeepReloc = True
3987                 if Obj.KeepReloc != None and Obj.KeepReloc != EfiSectionObj.KeepReloc:
3988                     raise Warning("Section type %s has reloc strip flag conflict with Rule" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber)
3989             else:
3990                 raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber)
3991
3992
3993         if self.__IsToken('|'):
3994             EfiSectionObj.FileExtension = self.__GetFileExtension()
3995         elif self.__GetNextToken():
3996             if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3997                        "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3998
3999                 if self.__Token.startswith('PCD'):
4000                     self.__UndoToken()
4001                     self.__GetNextWord()
4002
4003                     if self.__Token == 'PCD':
4004                         if not self.__IsToken( "("):
4005                             raise Warning("expected '('", self.FileName, self.CurrentLineNumber)
4006                         PcdPair = self.__GetNextPcdName()
4007                         if not self.__IsToken( ")"):
4008                             raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)
4009                         self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'
4010
4011                 EfiSectionObj.FileName = self.__Token
4012
4013             else:
4014                 self.__UndoToken()
4015         else:
4016             raise Warning("expected section file name", self.FileName, self.CurrentLineNumber)
4017
4018         Obj.SectionList.append(EfiSectionObj)
4019         return True
4020
4021     ## __RuleSectionCouldBeOptional() method
4022     #
4023     #   Get whether a section could be optional
4024     #
4025     #   @param  self        The object pointer
4026     #   @param  SectionType The section type to check
4027     #   @retval True        section could be optional
4028     #   @retval False       section never optional
4029     #
4030     def __RuleSectionCouldBeOptional(self, SectionType):
4031         if SectionType in ("DXE_DEPEX", "UI", "VERSION", "PEI_DEPEX", "RAW", "SMM_DEPEX"):
4032             return True
4033         else:
4034             return False
4035
4036     ## __RuleSectionCouldHaveBuildNum() method
4037     #
4038     #   Get whether a section could have build number information
4039     #
4040     #   @param  self        The object pointer
4041     #   @param  SectionType The section type to check
4042     #   @retval True        section could have build number information
4043     #   @retval False       section never have build number information
4044     #
4045     def __RuleSectionCouldHaveBuildNum(self, SectionType):
4046         if SectionType in ("VERSION"):
4047             return True
4048         else:
4049             return False
4050
4051     ## __RuleSectionCouldHaveString() method
4052     #
4053     #   Get whether a section could have string
4054     #
4055     #   @param  self        The object pointer
4056     #   @param  SectionType The section type to check
4057     #   @retval True        section could have string
4058     #   @retval False       section never have string
4059     #
4060     def __RuleSectionCouldHaveString(self, SectionType):
4061         if SectionType in ("UI", "VERSION"):
4062             return True
4063         else:
4064             return False
4065
4066     ## __CheckRuleSectionFileType() method
4067     #
4068     #   Get whether a section matches a file type
4069     #
4070     #   @param  self        The object pointer
4071     #   @param  SectionType The section type to check
4072     #   @param  FileType    The file type to check
4073     #
4074     def __CheckRuleSectionFileType(self, SectionType, FileType):
4075         if SectionType == "COMPAT16":
4076             if FileType not in ("COMPAT16", "SEC_COMPAT16"):
4077                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4078         elif SectionType == "PE32":
4079             if FileType not in ("PE32", "SEC_PE32"):
4080                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4081         elif SectionType == "PIC":
4082             if FileType not in ("PIC", "PIC"):
4083                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4084         elif SectionType == "TE":
4085             if FileType not in ("TE", "SEC_TE"):
4086                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4087         elif SectionType == "RAW":
4088             if FileType not in ("BIN", "SEC_BIN", "RAW", "ASL", "ACPI"):
4089                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4090         elif SectionType == "DXE_DEPEX" or SectionType == "SMM_DEPEX":
4091             if FileType not in ("DXE_DEPEX", "SEC_DXE_DEPEX", "SMM_DEPEX"):
4092                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4093         elif SectionType == "UI":
4094             if FileType not in ("UI", "SEC_UI"):
4095                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4096         elif SectionType == "VERSION":
4097             if FileType not in ("VERSION", "SEC_VERSION"):
4098                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4099         elif SectionType == "PEI_DEPEX":
4100             if FileType not in ("PEI_DEPEX", "SEC_PEI_DEPEX"):
4101                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4102         elif SectionType == "GUID":
4103             if FileType not in ("PE32", "SEC_GUID"):
4104                 raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)
4105
4106     ## __GetRuleEncapsulationSection() method
4107     #
4108     #   Get encapsulation section for Rule
4109     #
4110     #   @param  self        The object pointer
4111     #   @param  Rule        for whom section is got
4112     #   @retval True        Successfully find section statement
4113     #   @retval False       Not able to find section statement
4114     #
4115     def __GetRuleEncapsulationSection(self, Rule):
4116
4117         if self.__IsKeyword( "COMPRESS"):
4118             Type = "PI_STD"
4119             if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):
4120                 Type = self.__Token
4121
4122             if not self.__IsToken("{"):
4123                 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)
4124
4125             CompressSectionObj = CompressSection.CompressSection()
4126
4127             CompressSectionObj.CompType = Type
4128             # Recursive sections...
4129             while True:
4130                 IsEncapsulate = self.__GetRuleEncapsulationSection(CompressSectionObj)
4131                 IsLeaf = self.__GetEfiSection(CompressSectionObj)
4132                 if not IsEncapsulate and not IsLeaf:
4133                     break
4134
4135             if not self.__IsToken( "}"):
4136                 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)
4137             Rule.SectionList.append(CompressSectionObj)
4138
4139             return True
4140
4141         elif self.__IsKeyword( "GUIDED"):
4142             GuidValue = None
4143             if self.__GetNextGuid():
4144                 GuidValue = self.__Token
4145
4146             if self.__IsKeyword( "$(NAMED_GUID)"):
4147                 GuidValue = self.__Token
4148
4149             AttribDict = self.__GetGuidAttrib()
4150
4151             if not self.__IsToken("{"):
4152                 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)
4153             GuidSectionObj = GuidSection.GuidSection()
4154             GuidSectionObj.NameGuid = GuidValue
4155             GuidSectionObj.SectionType = "GUIDED"
4156             GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]
4157             GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]
4158             GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"]
4159
4160             # Efi sections...
4161             while True:
4162                 IsEncapsulate = self.__GetRuleEncapsulationSection(GuidSectionObj)
4163                 IsLeaf = self.__GetEfiSection(GuidSectionObj)
4164                 if not IsEncapsulate and not IsLeaf:
4165                     break
4166
4167             if not self.__IsToken( "}"):
4168                 raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)
4169             Rule.SectionList.append(GuidSectionObj)
4170
4171             return True
4172
4173         return False
4174
4175     ## __GetVtf() method
4176     #
4177     #   Get VTF section contents and store its data into VTF list of self.Profile
4178     #
4179     #   @param  self        The object pointer
4180     #   @retval True        Successfully find a VTF
4181     #   @retval False       Not able to find a VTF
4182     #
4183     def __GetVtf(self):
4184
4185         if not self.__GetNextToken():
4186             return False
4187
4188         S = self.__Token.upper()
4189         if S.startswith("[") and not S.startswith("[VTF."):
4190             self.SectionParser(S)
4191             self.__UndoToken()
4192             return False
4193
4194         self.__UndoToken()
4195         if not self.__IsToken("[VTF.", True):
4196             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
4197             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
4198             #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
4199             raise Warning("expected [VTF.]", self.FileName, self.CurrentLineNumber)
4200
4201         if not self.__SkipToToken("."):
4202             raise Warning("expected '.'", self.FileName, self.CurrentLineNumber)
4203
4204         Arch = self.__SkippedChars.rstrip(".").upper()
4205         if Arch not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):
4206             raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber)
4207
4208         if not self.__GetNextWord():
4209             raise Warning("expected VTF name", self.FileName, self.CurrentLineNumber)
4210         Name = self.__Token.upper()
4211
4212         VtfObj = Vtf.Vtf()
4213         VtfObj.UiName = Name
4214         VtfObj.KeyArch = Arch
4215
4216         if self.__IsToken(","):
4217             if not self.__GetNextWord():
4218                 raise Warning("expected Arch list", self.FileName, self.CurrentLineNumber)
4219             if self.__Token.upper() not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):
4220                 raise Warning("Unknown Arch '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
4221             VtfObj.ArchList = self.__Token.upper()
4222
4223         if not self.__IsToken( "]"):
4224             raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)
4225
4226         if self.__IsKeyword("IA32_RST_BIN"):
4227             if not self.__IsToken("="):
4228                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4229
4230             if not self.__GetNextToken():
4231                 raise Warning("expected Reset file", self.FileName, self.CurrentLineNumber)
4232
4233             VtfObj.ResetBin = self.__Token
4234             if VtfObj.ResetBin.replace('$(WORKSPACE)', '').find('$') == -1:
4235                 #check for file path
4236                 ErrorCode, ErrorInfo = PathClass(NormPath(VtfObj.ResetBin), GenFdsGlobalVariable.WorkSpaceDir).Validate()
4237                 if ErrorCode != 0:
4238                     EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
4239
4240         while self.__GetComponentStatement(VtfObj):
4241             pass
4242
4243         self.Profile.VtfList.append(VtfObj)
4244         return True
4245
4246     ## __GetComponentStatement() method
4247     #
4248     #   Get components in VTF
4249     #
4250     #   @param  self        The object pointer
4251     #   @param  VtfObj         for whom component is got
4252     #   @retval True        Successfully find a component
4253     #   @retval False       Not able to find a component
4254     #
4255     def __GetComponentStatement(self, VtfObj):
4256
4257         if not self.__IsKeyword("COMP_NAME"):
4258             return False
4259
4260         if not self.__IsToken("="):
4261             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4262
4263         if not self.__GetNextWord():
4264             raise Warning("expected Component Name", self.FileName, self.CurrentLineNumber)
4265
4266         CompStatementObj = ComponentStatement.ComponentStatement()
4267         CompStatementObj.CompName = self.__Token
4268
4269         if not self.__IsKeyword("COMP_LOC"):
4270             raise Warning("expected COMP_LOC", self.FileName, self.CurrentLineNumber)
4271
4272         if not self.__IsToken("="):
4273             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4274
4275         CompStatementObj.CompLoc = ""
4276         if self.__GetNextWord():
4277             CompStatementObj.CompLoc = self.__Token
4278             if self.__IsToken('|'):
4279                 if not self.__GetNextWord():
4280                     raise Warning("Expected Region Name", self.FileName, self.CurrentLineNumber)
4281
4282                 if self.__Token not in ("F", "N", "S"):    #, "H", "L", "PH", "PL"): not support
4283                     raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
4284
4285                 CompStatementObj.FilePos = self.__Token
4286         else:
4287             self.CurrentLineNumber += 1
4288             self.CurrentOffsetWithinLine = 0
4289
4290         if not self.__IsKeyword("COMP_TYPE"):
4291             raise Warning("expected COMP_TYPE", self.FileName, self.CurrentLineNumber)
4292
4293         if not self.__IsToken("="):
4294             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4295
4296         if not self.__GetNextToken():
4297             raise Warning("expected Component type", self.FileName, self.CurrentLineNumber)
4298         if self.__Token not in ("FIT", "PAL_B", "PAL_A", "OEM"):
4299             if not self.__Token.startswith("0x") or len(self.__Token) < 3 or len(self.__Token) > 4 or \
4300                 not self.__HexDigit(self.__Token[2]) or not self.__HexDigit(self.__Token[-1]):
4301                 raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
4302         CompStatementObj.CompType = self.__Token
4303
4304         if not self.__IsKeyword("COMP_VER"):
4305             raise Warning("expected COMP_VER", self.FileName, self.CurrentLineNumber)
4306
4307         if not self.__IsToken("="):
4308             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4309
4310         if not self.__GetNextToken():
4311             raise Warning("expected Component version", self.FileName, self.CurrentLineNumber)
4312
4313         Pattern = re.compile('-$|[0-9a-fA-F]{1,2}\.[0-9a-fA-F]{1,2}$', re.DOTALL)
4314         if Pattern.match(self.__Token) == None:
4315             raise Warning("Unknown version format '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
4316         CompStatementObj.CompVer = self.__Token
4317
4318         if not self.__IsKeyword("COMP_CS"):
4319             raise Warning("expected COMP_CS", self.FileName, self.CurrentLineNumber)
4320
4321         if not self.__IsToken("="):
4322             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4323
4324         if not self.__GetNextToken():
4325             raise Warning("expected Component CS", self.FileName, self.CurrentLineNumber)
4326         if self.__Token not in ("1", "0"):
4327             raise Warning("Unknown  Component CS '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
4328         CompStatementObj.CompCs = self.__Token
4329
4330
4331         if not self.__IsKeyword("COMP_BIN"):
4332             raise Warning("expected COMP_BIN", self.FileName, self.CurrentLineNumber)
4333
4334         if not self.__IsToken("="):
4335             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4336
4337         if not self.__GetNextToken():
4338             raise Warning("expected Component file", self.FileName, self.CurrentLineNumber)
4339
4340         CompStatementObj.CompBin = self.__Token
4341         if CompStatementObj.CompBin != '-' and CompStatementObj.CompBin.replace('$(WORKSPACE)', '').find('$') == -1:
4342             #check for file path
4343             ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompBin), GenFdsGlobalVariable.WorkSpaceDir).Validate()
4344             if ErrorCode != 0:
4345                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
4346
4347         if not self.__IsKeyword("COMP_SYM"):
4348             raise Warning("expected COMP_SYM", self.FileName, self.CurrentLineNumber)
4349
4350         if not self.__IsToken("="):
4351             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4352
4353         if not self.__GetNextToken():
4354             raise Warning("expected Component symbol file", self.FileName, self.CurrentLineNumber)
4355
4356         CompStatementObj.CompSym = self.__Token
4357         if CompStatementObj.CompSym != '-' and CompStatementObj.CompSym.replace('$(WORKSPACE)', '').find('$') == -1:
4358             #check for file path
4359             ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompSym), GenFdsGlobalVariable.WorkSpaceDir).Validate()
4360             if ErrorCode != 0:
4361                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
4362
4363         if not self.__IsKeyword("COMP_SIZE"):
4364             raise Warning("expected COMP_SIZE", self.FileName, self.CurrentLineNumber)
4365
4366         if not self.__IsToken("="):
4367             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4368
4369         if self.__IsToken("-"):
4370             CompStatementObj.CompSize = self.__Token
4371         elif self.__GetNextDecimalNumber():
4372             CompStatementObj.CompSize = self.__Token
4373         elif self.__GetNextHexNumber():
4374             CompStatementObj.CompSize = self.__Token
4375         else:
4376             raise Warning("Unknown size '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
4377
4378         VtfObj.ComponentStatementList.append(CompStatementObj)
4379         return True
4380
4381     ## __GetOptionRom() method
4382     #
4383     #   Get OptionROM section contents and store its data into OptionROM list of self.Profile
4384     #
4385     #   @param  self        The object pointer
4386     #   @retval True        Successfully find a OptionROM
4387     #   @retval False       Not able to find a OptionROM
4388     #
4389     def __GetOptionRom(self):
4390
4391         if not self.__GetNextToken():
4392             return False
4393
4394         S = self.__Token.upper()
4395         if S.startswith("[") and not S.startswith("[OPTIONROM."):
4396             self.SectionParser(S)
4397             self.__UndoToken()
4398             return False
4399
4400         self.__UndoToken()
4401         if not self.__IsToken("[OptionRom.", True):
4402             raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
4403
4404         OptRomName = self.__GetUiName()
4405
4406         if not self.__IsToken( "]"):
4407             raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)
4408
4409         OptRomObj = OptionRom.OPTIONROM()
4410         OptRomObj.DriverName = OptRomName
4411         self.Profile.OptRomDict[OptRomName] = OptRomObj
4412
4413         while True:
4414             isInf = self.__GetOptRomInfStatement(OptRomObj)
4415             isFile = self.__GetOptRomFileStatement(OptRomObj)
4416             if not isInf and not isFile:
4417                 break
4418
4419         return True
4420
4421     ## __GetOptRomInfStatement() method
4422     #
4423     #   Get INF statements
4424     #
4425     #   @param  self        The object pointer
4426     #   @param  Obj         for whom inf statement is got
4427     #   @retval True        Successfully find inf statement
4428     #   @retval False       Not able to find inf statement
4429     #
4430     def __GetOptRomInfStatement(self, Obj):
4431
4432         if not self.__IsKeyword( "INF"):
4433             return False
4434
4435         ffsInf = OptRomInfStatement.OptRomInfStatement()
4436         self.__GetInfOptions( ffsInf)
4437
4438         if not self.__GetNextToken():
4439             raise Warning("expected INF file path", self.FileName, self.CurrentLineNumber)
4440         ffsInf.InfFileName = self.__Token
4441         if ffsInf.InfFileName.replace('$(WORKSPACE)', '').find('$') == -1:
4442             #check for file path
4443             ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()
4444             if ErrorCode != 0:
4445                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
4446
4447         if not ffsInf.InfFileName in self.Profile.InfList:
4448             self.Profile.InfList.append(ffsInf.InfFileName)
4449             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
4450             self.Profile.InfFileLineList.append(FileLineTuple)
4451             if ffsInf.UseArch:
4452                 if ffsInf.UseArch not in self.Profile.InfDict:
4453                     self.Profile.InfDict[ffsInf.UseArch] = [ffsInf.InfFileName]
4454                 else:
4455                     self.Profile.InfDict[ffsInf.UseArch].append(ffsInf.InfFileName)
4456             else:
4457                 self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName)
4458
4459
4460         self.__GetOptRomOverrides (ffsInf)
4461
4462         Obj.FfsList.append(ffsInf)
4463         return True
4464
4465     ## __GetOptRomOverrides() method
4466     #
4467     #   Get overrides for OptROM INF & FILE
4468     #
4469     #   @param  self        The object pointer
4470     #   @param  FfsInfObj   for whom overrides is got
4471     #
4472     def __GetOptRomOverrides(self, Obj):
4473         if self.__IsToken('{'):
4474             Overrides = OptionRom.OverrideAttribs()
4475             while True:
4476                 if self.__IsKeyword( "PCI_VENDOR_ID"):
4477                     if not self.__IsToken( "="):
4478                         raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4479                     if not self.__GetNextHexNumber():
4480                         raise Warning("expected Hex vendor id", self.FileName, self.CurrentLineNumber)
4481                     Overrides.PciVendorId = self.__Token
4482                     continue
4483
4484                 if self.__IsKeyword( "PCI_CLASS_CODE"):
4485                     if not self.__IsToken( "="):
4486                         raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4487                     if not self.__GetNextHexNumber():
4488                         raise Warning("expected Hex class code", self.FileName, self.CurrentLineNumber)
4489                     Overrides.PciClassCode = self.__Token
4490                     continue
4491
4492                 if self.__IsKeyword( "PCI_DEVICE_ID"):
4493                     if not self.__IsToken( "="):
4494                         raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4495                     if not self.__GetNextHexNumber():
4496                         raise Warning("expected Hex device id", self.FileName, self.CurrentLineNumber)
4497
4498                     Overrides.PciDeviceId = self.__Token
4499                     continue
4500
4501                 if self.__IsKeyword( "PCI_REVISION"):
4502                     if not self.__IsToken( "="):
4503                         raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4504                     if not self.__GetNextHexNumber():
4505                         raise Warning("expected Hex revision", self.FileName, self.CurrentLineNumber)
4506                     Overrides.PciRevision = self.__Token
4507                     continue
4508
4509                 if self.__IsKeyword( "PCI_COMPRESS"):
4510                     if not self.__IsToken( "="):
4511                         raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
4512                     if not self.__GetNextToken():
4513                         raise Warning("expected TRUE/FALSE for compress", self.FileName, self.CurrentLineNumber)
4514                     Overrides.NeedCompress = self.__Token.upper() == 'TRUE'
4515                     continue
4516
4517                 if self.__IsToken( "}"):
4518                     break
4519                 else:
4520                     EdkLogger.error("FdfParser", FORMAT_INVALID, File=self.FileName, Line=self.CurrentLineNumber)
4521
4522             Obj.OverrideAttribs = Overrides
4523
4524     ## __GetOptRomFileStatement() method
4525     #
4526     #   Get FILE statements
4527     #
4528     #   @param  self        The object pointer
4529     #   @param  Obj         for whom FILE statement is got
4530     #   @retval True        Successfully find FILE statement
4531     #   @retval False       Not able to find FILE statement
4532     #
4533     def __GetOptRomFileStatement(self, Obj):
4534
4535         if not self.__IsKeyword( "FILE"):
4536             return False
4537
4538         FfsFileObj = OptRomFileStatement.OptRomFileStatement()
4539
4540         if not self.__IsKeyword("EFI") and not self.__IsKeyword("BIN"):
4541             raise Warning("expected Binary type (EFI/BIN)", self.FileName, self.CurrentLineNumber)
4542         FfsFileObj.FileType = self.__Token
4543
4544         if not self.__GetNextToken():
4545             raise Warning("expected File path", self.FileName, self.CurrentLineNumber)
4546         FfsFileObj.FileName = self.__Token
4547         if FfsFileObj.FileName.replace('$(WORKSPACE)', '').find('$') == -1:
4548             #check for file path
4549             ErrorCode, ErrorInfo = PathClass(NormPath(FfsFileObj.FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()
4550             if ErrorCode != 0:
4551                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
4552
4553         if FfsFileObj.FileType == 'EFI':
4554             self.__GetOptRomOverrides(FfsFileObj)
4555
4556         Obj.FfsList.append(FfsFileObj)
4557
4558         return True
4559
4560     ## __GetCapInFd() method
4561     #
4562     #   Get Cap list contained in FD
4563     #
4564     #   @param  self        The object pointer
4565     #   @param  FdName      FD name
4566     #   @retval CapList     List of Capsule in FD
4567     #
4568     def __GetCapInFd (self, FdName):
4569
4570         CapList = []
4571         if FdName.upper() in self.Profile.FdDict.keys():
4572             FdObj = self.Profile.FdDict[FdName.upper()]
4573             for elementRegion in FdObj.RegionList:
4574                 if elementRegion.RegionType == 'CAPSULE':
4575                     for elementRegionData in elementRegion.RegionDataList:
4576                         if elementRegionData.endswith(".cap"):
4577                             continue
4578                         if elementRegionData != None and elementRegionData.upper() not in CapList:
4579                             CapList.append(elementRegionData.upper())
4580         return CapList
4581
4582     ## __GetReferencedFdCapTuple() method
4583     #
4584     #   Get FV and FD list referenced by a capsule image
4585     #
4586     #   @param  self        The object pointer
4587     #   @param  CapObj      Capsule section to be searched
4588     #   @param  RefFdList   referenced FD by section
4589     #   @param  RefFvList   referenced FV by section
4590     #
4591     def __GetReferencedFdCapTuple(self, CapObj, RefFdList = [], RefFvList = []):
4592
4593         for CapsuleDataObj in CapObj.CapsuleDataList :
4594             if hasattr(CapsuleDataObj, 'FvName') and CapsuleDataObj.FvName != None and CapsuleDataObj.FvName.upper() not in RefFvList:
4595                 RefFvList.append (CapsuleDataObj.FvName.upper())
4596             elif hasattr(CapsuleDataObj, 'FdName') and CapsuleDataObj.FdName != None and CapsuleDataObj.FdName.upper() not in RefFdList:
4597                 RefFdList.append (CapsuleDataObj.FdName.upper())
4598             elif CapsuleDataObj.Ffs != None:
4599                 if isinstance(CapsuleDataObj.Ffs, FfsFileStatement.FileStatement):
4600                     if CapsuleDataObj.Ffs.FvName != None and CapsuleDataObj.Ffs.FvName.upper() not in RefFvList:
4601                         RefFvList.append(CapsuleDataObj.Ffs.FvName.upper())
4602                     elif CapsuleDataObj.Ffs.FdName != None and CapsuleDataObj.Ffs.FdName.upper() not in RefFdList:
4603                         RefFdList.append(CapsuleDataObj.Ffs.FdName.upper())
4604                     else:
4605                         self.__GetReferencedFdFvTupleFromSection(CapsuleDataObj.Ffs, RefFdList, RefFvList)
4606
4607     ## __GetFvInFd() method
4608     #
4609     #   Get FV list contained in FD
4610     #
4611     #   @param  self        The object pointer
4612     #   @param  FdName      FD name
4613     #   @retval FvList      list of FV in FD
4614     #
4615     def __GetFvInFd (self, FdName):
4616
4617         FvList = []
4618         if FdName.upper() in self.Profile.FdDict.keys():
4619             FdObj = self.Profile.FdDict[FdName.upper()]
4620             for elementRegion in FdObj.RegionList:
4621                 if elementRegion.RegionType == 'FV':
4622                     for elementRegionData in elementRegion.RegionDataList:
4623                         if elementRegionData.endswith(".fv"):
4624                             continue
4625                         if elementRegionData != None and elementRegionData.upper() not in FvList:
4626                             FvList.append(elementRegionData.upper())
4627         return FvList
4628
4629     ## __GetReferencedFdFvTuple() method
4630     #
4631     #   Get FD and FV list referenced by a FFS file
4632     #
4633     #   @param  self        The object pointer
4634     #   @param  FfsFile     contains sections to be searched
4635     #   @param  RefFdList   referenced FD by section
4636     #   @param  RefFvList   referenced FV by section
4637     #
4638     def __GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []):
4639
4640         for FfsObj in FvObj.FfsList:
4641             if isinstance(FfsObj, FfsFileStatement.FileStatement):
4642                 if FfsObj.FvName != None and FfsObj.FvName.upper() not in RefFvList:
4643                     RefFvList.append(FfsObj.FvName.upper())
4644                 elif FfsObj.FdName != None and FfsObj.FdName.upper() not in RefFdList:
4645                     RefFdList.append(FfsObj.FdName.upper())
4646                 else:
4647                     self.__GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList)
4648
4649     ## __GetReferencedFdFvTupleFromSection() method
4650     #
4651     #   Get FD and FV list referenced by a FFS section
4652     #
4653     #   @param  self        The object pointer
4654     #   @param  FfsFile     contains sections to be searched
4655     #   @param  FdList      referenced FD by section
4656     #   @param  FvList      referenced FV by section
4657     #
4658     def __GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []):
4659
4660         SectionStack = []
4661         SectionStack.extend(FfsFile.SectionList)
4662         while SectionStack != []:
4663             SectionObj = SectionStack.pop()
4664             if isinstance(SectionObj, FvImageSection.FvImageSection):
4665                 if SectionObj.FvName != None and SectionObj.FvName.upper() not in FvList:
4666                     FvList.append(SectionObj.FvName.upper())
4667                 if SectionObj.Fv != None and SectionObj.Fv.UiFvName != None and SectionObj.Fv.UiFvName.upper() not in FvList:
4668                     FvList.append(SectionObj.Fv.UiFvName.upper())
4669                     self.__GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList)
4670
4671             if isinstance(SectionObj, CompressSection.CompressSection) or isinstance(SectionObj, GuidSection.GuidSection):
4672                 SectionStack.extend(SectionObj.SectionList)
4673
4674     ## CycleReferenceCheck() method
4675     #
4676     #   Check whether cycle reference exists in FDF
4677     #
4678     #   @param  self        The object pointer
4679     #   @retval True        cycle reference exists
4680     #   @retval False       Not exists cycle reference
4681     #
4682     def CycleReferenceCheck(self):
4683         #
4684         # Check the cycle between FV and FD image
4685         #
4686         MaxLength = len (self.Profile.FvDict)
4687         for FvName in self.Profile.FvDict.keys():
4688             LogStr = "\nCycle Reference Checking for FV: %s\n" % FvName
4689             RefFvStack = []
4690             RefFvStack.append(FvName)
4691             FdAnalyzedList = []
4692
4693             Index = 0
4694             while RefFvStack != [] and Index < MaxLength:
4695                 Index = Index + 1
4696                 FvNameFromStack = RefFvStack.pop()
4697                 if FvNameFromStack.upper() in self.Profile.FvDict.keys():
4698                     FvObj = self.Profile.FvDict[FvNameFromStack.upper()]
4699                 else:
4700                     continue
4701
4702                 RefFdList = []
4703                 RefFvList = []
4704                 self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)
4705
4706                 for RefFdName in RefFdList:
4707                     if RefFdName in FdAnalyzedList:
4708                         continue
4709
4710                     LogStr += "FV %s contains FD %s\n" % (FvNameFromStack, RefFdName)
4711                     FvInFdList = self.__GetFvInFd(RefFdName)
4712                     if FvInFdList != []:
4713                         for FvNameInFd in FvInFdList:
4714                             LogStr += "FD %s contains FV %s\n" % (RefFdName,FvNameInFd)
4715                             if FvNameInFd not in RefFvStack:
4716                                 RefFvStack.append(FvNameInFd)
4717
4718                             if FvName in RefFvStack or FvNameFromStack in RefFvStack:
4719                                 EdkLogger.info(LogStr)
4720                                 return True
4721                     FdAnalyzedList.append(RefFdName)
4722
4723                 for RefFvName in RefFvList:
4724                     LogStr += "FV %s contains FV %s\n" % (FvNameFromStack, RefFvName)
4725                     if RefFvName not in RefFvStack:
4726                         RefFvStack.append(RefFvName)
4727
4728                     if FvName in RefFvStack or FvNameFromStack in RefFvStack:
4729                         EdkLogger.info(LogStr)
4730                         return True
4731
4732         #
4733         # Check the cycle between Capsule and FD image
4734         #
4735         MaxLength = len (self.Profile.CapsuleDict)
4736         for CapName in self.Profile.CapsuleDict.keys():
4737             #
4738             # Capsule image to be checked.
4739             #
4740             LogStr = "\n\n\nCycle Reference Checking for Capsule: %s\n" % CapName
4741             RefCapStack = []
4742             RefCapStack.append(CapName)
4743             FdAnalyzedList = []
4744             FvAnalyzedList = []
4745
4746             Index = 0
4747             while RefCapStack != [] and Index < MaxLength:
4748                 Index = Index + 1
4749                 CapNameFromStack = RefCapStack.pop()
4750                 if CapNameFromStack.upper() in self.Profile.CapsuleDict.keys():
4751                     CapObj = self.Profile.CapsuleDict[CapNameFromStack.upper()]
4752                 else:
4753                     continue
4754
4755                 RefFvList = []
4756                 RefFdList = []
4757                 self.__GetReferencedFdCapTuple(CapObj, RefFdList, RefFvList)
4758
4759                 FvListLength = 0
4760                 FdListLength = 0
4761                 while FvListLength < len (RefFvList) or FdListLength < len (RefFdList):
4762                     for RefFdName in RefFdList:
4763                         if RefFdName in FdAnalyzedList:
4764                             continue
4765
4766                         LogStr += "Capsule %s contains FD %s\n" % (CapNameFromStack, RefFdName)
4767                         CapInFdList = self.__GetCapInFd(RefFdName)
4768                         if CapInFdList != []:
4769                             for CapNameInFd in CapInFdList:
4770                                 LogStr += "FD %s contains Capsule %s\n" % (RefFdName,CapNameInFd)
4771                                 if CapNameInFd not in RefCapStack:
4772                                     RefCapStack.append(CapNameInFd)
4773
4774                                 if CapName in RefCapStack or CapNameFromStack in RefCapStack:
4775                                     EdkLogger.info(LogStr)
4776                                     return True
4777
4778                         FvInFdList = self.__GetFvInFd(RefFdName)
4779                         if FvInFdList != []:
4780                             for FvNameInFd in FvInFdList:
4781                                 LogStr += "FD %s contains FV %s\n" % (RefFdName,FvNameInFd)
4782                                 if FvNameInFd not in RefFvList:
4783                                     RefFvList.append(FvNameInFd)
4784
4785                         FdAnalyzedList.append(RefFdName)
4786                     #
4787                     # the number of the parsed FV and FD image
4788                     #
4789                     FvListLength = len (RefFvList)
4790                     FdListLength = len (RefFdList)
4791                     for RefFvName in RefFvList:
4792                         if RefFvName in FvAnalyzedList:
4793                             continue
4794                         LogStr += "Capsule %s contains FV %s\n" % (CapNameFromStack, RefFvName)
4795                         if RefFvName.upper() in self.Profile.FvDict.keys():
4796                             FvObj = self.Profile.FvDict[RefFvName.upper()]
4797                         else:
4798                             continue
4799                         self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)
4800                         FvAnalyzedList.append(RefFvName)
4801
4802         return False
4803
4804     def GetAllIncludedFile (self):
4805         global AllIncludeFileList
4806         return AllIncludeFileList
4807
4808 if __name__ == "__main__":
4809     import sys
4810     try:
4811         test_file = sys.argv[1]
4812     except IndexError, v:
4813         print "Usage: %s filename" % sys.argv[0]
4814         sys.exit(1)
4815
4816     parser = FdfParser(test_file)
4817     try:
4818         parser.ParseFile()
4819         parser.CycleReferenceCheck()
4820     except Warning, X:
4821         print str(X)
4822     else:
4823         print "Success!"
4824