BaseTools/Source/Python/GenFds/FdfParser.py

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