BaseTools/Source/Python/GenFds/FdfParser.py

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