BaseTools/Source/Python/Common/FdfParserLite.py

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