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