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             #set default block size is 1
1443             Obj.BlockSizeList.append((1, Obj.Size, None))
1444             return True
1445
1446         while self.__GetBlockStatement(Obj):
1447             pass
1448
1449         for Item in Obj.BlockSizeList:
1450             if Item[0] == None or Item[1] == None:
1451                 raise Warning("expected block statement for Fd Section", self.FileName, self.CurrentLineNumber)
1452
1453         return True
1454
1455     ## __GetBlockStatement() method
1456     #
1457     #   Get block statement
1458     #
1459     #   @param  self        The object pointer
1460     #   @param  Obj         for whom block statement is got
1461     #   @retval True        Successfully find
1462     #   @retval False       Not able to find
1463     #
1464     def __GetBlockStatement(self, Obj):
1465         if not self.__IsKeyword( "BlockSize"):
1466             return False
1467
1468         if not self.__IsToken( "="):
1469             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1470
1471         if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber():
1472             raise Warning("expected Hex block size At Line ", self.FileName, self.CurrentLineNumber)
1473
1474         BlockSize = long(self.__Token, 0)
1475         BlockSizePcd = None
1476         if self.__IsToken( "|"):
1477             PcdPair = self.__GetNextPcdName()
1478             BlockSizePcd = PcdPair
1479             self.Profile.PcdDict[PcdPair] = BlockSize
1480             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
1481             self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple
1482
1483         BlockNumber = None
1484         if self.__IsKeyword( "NumBlocks"):
1485             if not self.__IsToken( "="):
1486                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1487
1488             if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():
1489                 raise Warning("expected block numbers At Line ", self.FileName, self.CurrentLineNumber)
1490
1491             BlockNumber = long(self.__Token, 0)
1492
1493         Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd))
1494         return True
1495
1496     ## __GetDefineStatements() method
1497     #
1498     #   Get define statements
1499     #
1500     #   @param  self        The object pointer
1501     #   @param  Obj         for whom define statement is got
1502     #   @retval True        Successfully find
1503     #   @retval False       Not able to find
1504     #
1505     def __GetDefineStatements(self, Obj):
1506         while self.__GetDefineStatement( Obj):
1507             pass
1508
1509     ## __GetDefineStatement() method
1510     #
1511     #   Get define statement
1512     #
1513     #   @param  self        The object pointer
1514     #   @param  Obj         for whom define statement is got
1515     #   @retval True        Successfully find
1516     #   @retval False       Not able to find
1517     #
1518     def __GetDefineStatement(self, Obj):
1519         if self.__IsKeyword("DEFINE"):
1520             self.__GetNextToken()
1521             Macro = self.__Token
1522             if not self.__IsToken( "="):
1523                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1524
1525             if not self.__GetNextToken():
1526                 raise Warning("expected value At Line ", self.FileName, self.CurrentLineNumber)
1527
1528             Value = self.__Token
1529             Macro = '$(' + Macro + ')'
1530             Obj.DefineVarDict[Macro] = Value
1531             return True
1532
1533         return False
1534
1535     ## __GetSetStatements() method
1536     #
1537     #   Get set statements
1538     #
1539     #   @param  self        The object pointer
1540     #   @param  Obj         for whom set statement is got
1541     #   @retval True        Successfully find
1542     #   @retval False       Not able to find
1543     #
1544     def __GetSetStatements(self, Obj):
1545         while self.__GetSetStatement(Obj):
1546             pass
1547
1548     ## __GetSetStatement() method
1549     #
1550     #   Get set statement
1551     #
1552     #   @param  self        The object pointer
1553     #   @param  Obj         for whom set statement is got
1554     #   @retval True        Successfully find
1555     #   @retval False       Not able to find
1556     #
1557     def __GetSetStatement(self, Obj):
1558         if self.__IsKeyword("SET"):
1559             PcdPair = self.__GetNextPcdName()
1560
1561             if not self.__IsToken( "="):
1562                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1563
1564             if not self.__GetNextToken():
1565                 raise Warning("expected value At Line ", self.FileName, self.CurrentLineNumber)
1566
1567             Value = self.__Token
1568             if Value.startswith("{"):
1569                 # deal with value with {}
1570                 if not self.__SkipToToken( "}"):
1571                     raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
1572                 Value += self.__SkippedChars
1573
1574             Obj.SetVarDict[PcdPair] = Value
1575             self.Profile.PcdDict[PcdPair] = Value
1576             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
1577             self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple
1578             return True
1579
1580         return False
1581
1582     ## __GetRegionLayout() method
1583     #
1584     #   Get region layout for FD
1585     #
1586     #   @param  self        The object pointer
1587     #   @param  Fd          for whom region is got
1588     #   @retval True        Successfully find
1589     #   @retval False       Not able to find
1590     #
1591     def __GetRegionLayout(self, Fd):
1592         if not self.__GetNextHexNumber():
1593             return False
1594
1595         RegionObj = CommonDataClass.FdfClass.RegionClassObject()
1596         RegionObj.Offset = long(self.__Token, 0)
1597         Fd.RegionList.append(RegionObj)
1598
1599         if not self.__IsToken( "|"):
1600             raise Warning("expected '|' At Line ", self.FileName, self.CurrentLineNumber)
1601
1602         if not self.__GetNextHexNumber():
1603             raise Warning("expected Region Size At Line ", self.FileName, self.CurrentLineNumber)
1604         RegionObj.Size = long(self.__Token, 0)
1605
1606         if not self.__GetNextWord():
1607             return True
1608
1609         if not self.__Token in ("SET", "FV", "FILE", "DATA", "CAPSULE"):
1610             self.__UndoToken()
1611             RegionObj.PcdOffset = self.__GetNextPcdName()
1612             self.Profile.PcdDict[RegionObj.PcdOffset] = RegionObj.Offset + long(Fd.BaseAddress, 0)
1613             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
1614             self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple
1615             if self.__IsToken( "|"):
1616                 RegionObj.PcdSize = self.__GetNextPcdName()
1617                 self.Profile.PcdDict[RegionObj.PcdSize] = RegionObj.Size
1618                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
1619                 self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple
1620
1621             if not self.__GetNextWord():
1622                 return True
1623
1624         if self.__Token == "SET":
1625             self.__UndoToken()
1626             self.__GetSetStatements( RegionObj)
1627             if not self.__GetNextWord():
1628                 return True
1629
1630         elif self.__Token == "FV":
1631             self.__UndoToken()
1632             self.__GetRegionFvType( RegionObj)
1633
1634         elif self.__Token == "CAPSULE":
1635             self.__UndoToken()
1636             self.__GetRegionCapType( RegionObj)
1637
1638         elif self.__Token == "FILE":
1639             self.__UndoToken()
1640             self.__GetRegionFileType( RegionObj)
1641
1642         else:
1643             self.__UndoToken()
1644             self.__GetRegionDataType( RegionObj)
1645
1646         return True
1647
1648     ## __GetRegionFvType() method
1649     #
1650     #   Get region fv data for region
1651     #
1652     #   @param  self        The object pointer
1653     #   @param  RegionObj   for whom region data is got
1654     #
1655     def __GetRegionFvType(self, RegionObj):
1656
1657         if not self.__IsKeyword( "FV"):
1658             raise Warning("expected Keyword 'FV' At Line ", self.FileName, self.CurrentLineNumber)
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.RegionType = "FV"
1667         RegionObj.RegionDataList.append(self.__Token)
1668
1669         while self.__IsKeyword( "FV"):
1670
1671             if not self.__IsToken( "="):
1672                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1673
1674             if not self.__GetNextToken():
1675                 raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)
1676
1677             RegionObj.RegionDataList.append(self.__Token)
1678
1679     ## __GetRegionCapType() method
1680     #
1681     #   Get region capsule data for region
1682     #
1683     #   @param  self        The object pointer
1684     #   @param  RegionObj   for whom region data is got
1685     #
1686     def __GetRegionCapType(self, RegionObj):
1687
1688         if not self.__IsKeyword("CAPSULE"):
1689             raise Warning("expected Keyword 'CAPSULE' at line", self.FileName, self.CurrentLineNumber)
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 CAPSULE name at line", self.FileName, self.CurrentLineNumber)
1696
1697         RegionObj.RegionType = "CAPSULE"
1698         RegionObj.RegionDataList.append(self.__Token)
1699
1700         while self.__IsKeyword("CAPSULE"):
1701
1702             if not self.__IsToken("="):
1703                 raise Warning("expected '=' at line", self.FileName, self.CurrentLineNumber)
1704
1705             if not self.__GetNextToken():
1706                 raise Warning("expected CAPSULE name at line", self.FileName, self.CurrentLineNumber)
1707
1708             RegionObj.RegionDataList.append(self.__Token)
1709
1710     ## __GetRegionFileType() method
1711     #
1712     #   Get region file data for region
1713     #
1714     #   @param  self        The object pointer
1715     #   @param  RegionObj   for whom region data is got
1716     #
1717     def __GetRegionFileType(self, RegionObj):
1718
1719         if not self.__IsKeyword( "FILE"):
1720             raise Warning("expected Keyword 'FILE' At Line ", self.FileName, self.CurrentLineNumber)
1721
1722         if not self.__IsToken( "="):
1723             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1724
1725         if not self.__GetNextToken():
1726             raise Warning("expected File name At Line ", self.FileName, self.CurrentLineNumber)
1727
1728         RegionObj.RegionType = "FILE"
1729         RegionObj.RegionDataList.append( self.__Token)
1730
1731         while self.__IsKeyword( "FILE"):
1732
1733             if not self.__IsToken( "="):
1734                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1735
1736             if not self.__GetNextToken():
1737                 raise Warning("expected FILE name At Line ", self.FileName, self.CurrentLineNumber)
1738
1739             RegionObj.RegionDataList.append(self.__Token)
1740
1741     ## __GetRegionDataType() method
1742     #
1743     #   Get region array data for region
1744     #
1745     #   @param  self        The object pointer
1746     #   @param  RegionObj   for whom region data is got
1747     #
1748     def __GetRegionDataType(self, RegionObj):
1749
1750         if not self.__IsKeyword( "DATA"):
1751             raise Warning("expected Region Data type At Line ", self.FileName, self.CurrentLineNumber)
1752
1753         if not self.__IsToken( "="):
1754             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1755
1756         if not self.__IsToken( "{"):
1757             raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
1758
1759         if not self.__GetNextHexNumber():
1760             raise Warning("expected Hex byte At Line ", self.FileName, self.CurrentLineNumber)
1761
1762         if len(self.__Token) > 4:
1763             raise Warning("Hex byte(must be 2 digits) too long At Line ", self.FileName, self.CurrentLineNumber)
1764
1765         DataString = self.__Token
1766         DataString += ","
1767
1768         while self.__IsToken(","):
1769             if not self.__GetNextHexNumber():
1770                 raise Warning("Invalid Hex number At Line ", self.FileName, self.CurrentLineNumber)
1771             if len(self.__Token) > 4:
1772                 raise Warning("Hex byte(must be 2 digits) too long At Line ", self.FileName, self.CurrentLineNumber)
1773             DataString += self.__Token
1774             DataString += ","
1775
1776         if not self.__IsToken( "}"):
1777             raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
1778
1779         DataString = DataString.rstrip(",")
1780         RegionObj.RegionType = "DATA"
1781         RegionObj.RegionDataList.append( DataString)
1782
1783         while self.__IsKeyword( "DATA"):
1784
1785             if not self.__IsToken( "="):
1786                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1787
1788             if not self.__IsToken( "{"):
1789                 raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
1790
1791             if not self.__GetNextHexNumber():
1792                 raise Warning("expected Hex byte At Line ", self.FileName, self.CurrentLineNumber)
1793
1794             if len(self.__Token) > 4:
1795                 raise Warning("Hex byte(must be 2 digits) too long At Line ", self.FileName, self.CurrentLineNumber)
1796
1797             DataString = self.__Token
1798             DataString += ","
1799
1800             while self.__IsToken(","):
1801                 self.__GetNextHexNumber()
1802                 if len(self.__Token) > 4:
1803                     raise Warning("Hex byte(must be 2 digits) too long At Line ", self.FileName, self.CurrentLineNumber)
1804                 DataString += self.__Token
1805                 DataString += ","
1806
1807             if not self.__IsToken( "}"):
1808                 raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
1809
1810             DataString = DataString.rstrip(",")
1811             RegionObj.RegionDataList.append( DataString)
1812
1813     ## __GetFv() method
1814     #
1815     #   Get FV section contents and store its data into FV dictionary of self.Profile
1816     #
1817     #   @param  self        The object pointer
1818     #   @retval True        Successfully find a FV
1819     #   @retval False       Not able to find a FV
1820     #
1821     def __GetFv(self):
1822         if not self.__GetNextToken():
1823             return False
1824
1825         S = self.__Token.upper()
1826         if S.startswith("[") and not S.startswith("[FV."):
1827             if not S.startswith("[CAPSULE.") \
1828                 and not S.startswith("[VTF.") and not S.startswith("[RULE."):
1829                 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)
1830             self.__UndoToken()
1831             return False
1832
1833         self.__UndoToken()
1834         if not self.__IsToken("[FV.", True):
1835             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
1836             print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
1837                     % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
1838             raise Warning("Unknown Keyword At Line ", self.FileName, self.CurrentLineNumber)
1839
1840         FvName = self.__GetUiName()
1841         self.CurrentFvName = FvName.upper()
1842
1843         if not self.__IsToken( "]"):
1844             raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)
1845
1846         FvObj = CommonDataClass.FdfClass.FvClassObject()
1847         FvObj.UiFvName = self.CurrentFvName
1848         self.Profile.FvDict[self.CurrentFvName] = FvObj
1849
1850         Status = self.__GetCreateFile(FvObj)
1851         if not Status:
1852             raise Warning("FV name error At Line ", self.FileName, self.CurrentLineNumber)
1853
1854         self.__GetDefineStatements(FvObj)
1855
1856         self.__GetAddressStatements(FvObj)
1857
1858         self.__GetBlockStatement(FvObj)
1859
1860         self.__GetSetStatements(FvObj)
1861
1862         self.__GetFvAlignment(FvObj)
1863
1864         self.__GetFvAttributes(FvObj)
1865
1866         self.__GetFvNameGuid(FvObj)
1867
1868         self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())
1869         self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())
1870
1871         while True:
1872             isInf = self.__GetInfStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())
1873             isFile = self.__GetFileStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())
1874             if not isInf and not isFile:
1875                 break
1876
1877         return True
1878
1879     ## __GetFvAlignment() method
1880     #
1881     #   Get alignment for FV
1882     #
1883     #   @param  self        The object pointer
1884     #   @param  Obj         for whom alignment is got
1885     #   @retval True        Successfully find a alignment statement
1886     #   @retval False       Not able to find a alignment statement
1887     #
1888     def __GetFvAlignment(self, Obj):
1889
1890         if not self.__IsKeyword( "FvAlignment"):
1891             return False
1892
1893         if not self.__IsToken( "="):
1894             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1895
1896         if not self.__GetNextToken():
1897             raise Warning("expected alignment value At Line ", self.FileName, self.CurrentLineNumber)
1898
1899         if self.__Token.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \
1900                                         "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \
1901                                         "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \
1902                                         "1G", "2G"):
1903             raise Warning("Unknown alignment value At Line ", self.FileName, self.CurrentLineNumber)
1904         Obj.FvAlignment = self.__Token
1905         return True
1906
1907     ## __GetFvAttributes() method
1908     #
1909     #   Get attributes for FV
1910     #
1911     #   @param  self        The object pointer
1912     #   @param  Obj         for whom attribute is got
1913     #   @retval None
1914     #
1915     def __GetFvAttributes(self, FvObj):
1916
1917         while self.__GetNextWord():
1918             name = self.__Token
1919             if name not in ("ERASE_POLARITY", "MEMORY_MAPPED", \
1920                            "STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \
1921                            "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \
1922                            "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \
1923                            "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \
1924                            "WRITE_POLICY_RELIABLE"):
1925                 self.__UndoToken()
1926                 return
1927
1928             if not self.__IsToken( "="):
1929                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
1930
1931             if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):
1932                 raise Warning("expected TRUE/FALSE (1/0) At Line ", self.FileName, self.CurrentLineNumber)
1933
1934             FvObj.FvAttributeDict[name] = self.__Token
1935
1936         return
1937
1938     ## __GetFvNameGuid() method
1939     #
1940     #   Get FV GUID for FV
1941     #
1942     #   @param  self        The object pointer
1943     #   @param  Obj         for whom GUID is got
1944     #   @retval None
1945     #
1946     def __GetFvNameGuid(self, FvObj):
1947
1948         if not self.__IsKeyword( "FvNameGuid"):
1949             return
1950
1951         if not self.__IsToken( "="):
1952             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
1953
1954         if not self.__GetNextGuid():
1955             raise Warning("expected FV GUID value", self.FileName, self.CurrentLineNumber)
1956
1957         FvObj.FvNameGuid = self.__Token
1958
1959         return
1960
1961     ## __GetAprioriSection() method
1962     #
1963     #   Get token statements
1964     #
1965     #   @param  self        The object pointer
1966     #   @param  FvObj       for whom apriori is got
1967     #   @param  MacroDict   dictionary used to replace macro
1968     #   @retval True        Successfully find apriori statement
1969     #   @retval False       Not able to find apriori statement
1970     #
1971     def __GetAprioriSection(self, FvObj, MacroDict = {}):
1972
1973         if not self.__IsKeyword( "APRIORI"):
1974             return False
1975
1976         if not self.__IsKeyword("PEI") and not self.__IsKeyword("DXE"):
1977             raise Warning("expected Apriori file type At Line ", self.FileName, self.CurrentLineNumber)
1978         AprType = self.__Token
1979
1980         if not self.__IsToken( "{"):
1981             raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
1982
1983         AprSectionObj = CommonDataClass.FdfClass.AprioriSectionClassObject()
1984         AprSectionObj.AprioriType = AprType
1985
1986         self.__GetDefineStatements(AprSectionObj)
1987         MacroDict.update(AprSectionObj.DefineVarDict)
1988
1989         while True:
1990             IsInf = self.__GetInfStatement( AprSectionObj, MacroDict = MacroDict)
1991             IsFile = self.__GetFileStatement( AprSectionObj)
1992             if not IsInf and not IsFile:
1993                 break
1994
1995         if not self.__IsToken( "}"):
1996             raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
1997
1998         FvObj.AprioriSectionList.append(AprSectionObj)
1999         return True
2000
2001     ## __GetInfStatement() method
2002     #
2003     #   Get INF statements
2004     #
2005     #   @param  self        The object pointer
2006     #   @param  Obj         for whom inf statement is got
2007     #   @param  MacroDict   dictionary used to replace macro
2008     #   @retval True        Successfully find inf statement
2009     #   @retval False       Not able to find inf statement
2010     #
2011     def __GetInfStatement(self, Obj, ForCapsule = False, MacroDict = {}):
2012
2013         if not self.__IsKeyword( "INF"):
2014             return False
2015
2016         ffsInf = CommonDataClass.FdfClass.FfsInfStatementClassObject()
2017         self.__GetInfOptions( ffsInf)
2018
2019         if not self.__GetNextToken():
2020             raise Warning("expected INF file path At Line ", self.FileName, self.CurrentLineNumber)
2021         ffsInf.InfFileName = self.__Token
2022
2023 #        if ffsInf.InfFileName.find('$') >= 0:
2024 #            ffsInf.InfFileName = GenFdsGlobalVariable.GenFdsGlobalVariable.MacroExtend(ffsInf.InfFileName, MacroDict)
2025
2026         if not ffsInf.InfFileName in self.Profile.InfList:
2027             self.Profile.InfList.append(ffsInf.InfFileName)
2028             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
2029             self.Profile.InfFileLineList.append(FileLineTuple)
2030
2031         if self.__IsToken('|'):
2032             if self.__IsKeyword('RELOCS_STRIPPED'):
2033                 ffsInf.KeepReloc = False
2034             elif self.__IsKeyword('RELOCS_RETAINED'):
2035                 ffsInf.KeepReloc = True
2036             else:
2037                 raise Warning("Unknown reloc strip flag At Line ", self.FileName, self.CurrentLineNumber)
2038
2039         if ForCapsule:
2040             capsuleFfs = CapsuleData.CapsuleFfs()
2041             capsuleFfs.Ffs = ffsInf
2042             Obj.CapsuleDataList.append(capsuleFfs)
2043         else:
2044             Obj.FfsList.append(ffsInf)
2045         return True
2046
2047     ## __GetInfOptions() method
2048     #
2049     #   Get options for INF
2050     #
2051     #   @param  self        The object pointer
2052     #   @param  FfsInfObj   for whom option is got
2053     #
2054     def __GetInfOptions(self, FfsInfObj):
2055
2056         if self.__IsKeyword( "RuleOverride"):
2057             if not self.__IsToken( "="):
2058                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2059             if not self.__GetNextToken():
2060                 raise Warning("expected Rule name At Line ", self.FileName, self.CurrentLineNumber)
2061             FfsInfObj.Rule = self.__Token
2062
2063         if self.__IsKeyword( "VERSION"):
2064             if not self.__IsToken( "="):
2065                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2066             if not self.__GetNextToken():
2067                 raise Warning("expected Version At Line ", self.FileName, self.CurrentLineNumber)
2068
2069             if self.__GetStringData():
2070                 FfsInfObj.Version = self.__Token
2071
2072         if self.__IsKeyword( "UI"):
2073             if not self.__IsToken( "="):
2074                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2075             if not self.__GetNextToken():
2076                 raise Warning("expected UI name At Line ", self.FileName, self.CurrentLineNumber)
2077
2078             if self.__GetStringData():
2079                 FfsInfObj.Ui = self.__Token
2080
2081         if self.__IsKeyword( "USE"):
2082             if not self.__IsToken( "="):
2083                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)
2084             if not self.__GetNextToken():
2085                 raise Warning("expected ARCH name", self.FileName, self.CurrentLineNumber)
2086             FfsInfObj.UseArch = self.__Token
2087
2088
2089         if self.__GetNextToken():
2090             p = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
2091             if p.match(self.__Token):
2092                 FfsInfObj.KeyStringList.append(self.__Token)
2093                 if not self.__IsToken(","):
2094                     return
2095             else:
2096                 self.__UndoToken()
2097                 return
2098
2099             while self.__GetNextToken():
2100                 if not p.match(self.__Token):
2101                     raise Warning("expected KeyString \"Target_Tag_Arch\" At Line ", self.FileName, self.CurrentLineNumber)
2102                 FfsInfObj.KeyStringList.append(self.__Token)
2103
2104                 if not self.__IsToken(","):
2105                     break
2106
2107     ## __GetFileStatement() method
2108     #
2109     #   Get FILE statements
2110     #
2111     #   @param  self        The object pointer
2112     #   @param  Obj         for whom FILE statement is got
2113     #   @param  MacroDict   dictionary used to replace macro
2114     #   @retval True        Successfully find FILE statement
2115     #   @retval False       Not able to find FILE statement
2116     #
2117     def __GetFileStatement(self, Obj, ForCapsule = False, MacroDict = {}):
2118
2119         if not self.__IsKeyword( "FILE"):
2120             return False
2121
2122         FfsFileObj = CommonDataClass.FdfClass.FileStatementClassObject()
2123
2124         if not self.__GetNextWord():
2125             raise Warning("expected FFS type At Line ", self.FileName, self.CurrentLineNumber)
2126         FfsFileObj.FvFileType = self.__Token
2127
2128         if not self.__IsToken( "="):
2129             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2130
2131         if not self.__GetNextGuid():
2132             if not self.__GetNextWord():
2133                 raise Warning("expected File GUID", self.FileName, self.CurrentLineNumber)
2134             if self.__Token == 'PCD':
2135                 if not self.__IsToken( "("):
2136                     raise Warning("expected '('", self.FileName, self.CurrentLineNumber)
2137                 PcdPair = self.__GetNextPcdName()
2138                 if not self.__IsToken( ")"):
2139                     raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)
2140                 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'
2141
2142         FfsFileObj.NameGuid = self.__Token
2143
2144         self.__GetFilePart( FfsFileObj, MacroDict.copy())
2145
2146         if ForCapsule:
2147             capsuleFfs = CapsuleData.CapsuleFfs()
2148             capsuleFfs.Ffs = FfsFileObj
2149             Obj.CapsuleDataList.append(capsuleFfs)
2150         else:
2151             Obj.FfsList.append(FfsFileObj)
2152
2153         return True
2154
2155     ## __FileCouldHaveRelocFlag() method
2156     #
2157     #   Check whether reloc strip flag can be set for a file type.
2158     #
2159     #   @param  self        The object pointer
2160     #   @param  FileType    The file type to check with
2161     #   @retval True        This type could have relocation strip flag
2162     #   @retval False       No way to have it
2163     #
2164
2165     def __FileCouldHaveRelocFlag (self, FileType):
2166         if FileType in ('SEC', 'PEI_CORE', 'PEIM', 'PEI_DXE_COMBO'):
2167             return True
2168         else:
2169             return False
2170
2171     ## __SectionCouldHaveRelocFlag() method
2172     #
2173     #   Check whether reloc strip flag can be set for a section type.
2174     #
2175     #   @param  self        The object pointer
2176     #   @param  SectionType The section type to check with
2177     #   @retval True        This type could have relocation strip flag
2178     #   @retval False       No way to have it
2179     #
2180
2181     def __SectionCouldHaveRelocFlag (self, SectionType):
2182         if SectionType in ('TE', 'PE32'):
2183             return True
2184         else:
2185             return False
2186
2187     ## __GetFilePart() method
2188     #
2189     #   Get components for FILE statement
2190     #
2191     #   @param  self        The object pointer
2192     #   @param  FfsFileObj   for whom component is got
2193     #   @param  MacroDict   dictionary used to replace macro
2194     #
2195     def __GetFilePart(self, FfsFileObj, MacroDict = {}):
2196
2197         self.__GetFileOpts( FfsFileObj)
2198
2199         if not self.__IsToken("{"):
2200 #            if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):
2201 #                if self.__FileCouldHaveRelocFlag(FfsFileObj.FvFileType):
2202 #                    if self.__Token == 'RELOCS_STRIPPED':
2203 #                        FfsFileObj.KeepReloc = False
2204 #                    else:
2205 #                        FfsFileObj.KeepReloc = True
2206 #                else:
2207 #                    raise Warning("File type %s could not have reloc strip flag At Line %d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
2208 #
2209 #            if not self.__IsToken("{"):
2210             raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
2211
2212         if not self.__GetNextToken():
2213             raise Warning("expected File name or section data At Line ", self.FileName, self.CurrentLineNumber)
2214
2215         if self.__Token == "FV":
2216             if not self.__IsToken( "="):
2217                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2218             if not self.__GetNextToken():
2219                 raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)
2220             FfsFileObj.FvName = self.__Token
2221
2222         elif self.__Token == "FD":
2223             if not self.__IsToken( "="):
2224                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2225             if not self.__GetNextToken():
2226                 raise Warning("expected FD name At Line ", self.FileName, self.CurrentLineNumber)
2227             FfsFileObj.FdName = self.__Token
2228
2229         elif self.__Token in ("DEFINE", "APRIORI", "SECTION"):
2230             self.__UndoToken()
2231             self.__GetSectionData( FfsFileObj, MacroDict)
2232         else:
2233             FfsFileObj.FileName = self.__Token
2234
2235         if not self.__IsToken( "}"):
2236             raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
2237
2238     ## __GetFileOpts() method
2239     #
2240     #   Get options for FILE statement
2241     #
2242     #   @param  self        The object pointer
2243     #   @param  FfsFileObj   for whom options is got
2244     #
2245     def __GetFileOpts(self, FfsFileObj):
2246
2247         if self.__GetNextToken():
2248             Pattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
2249             if Pattern.match(self.__Token):
2250                 FfsFileObj.KeyStringList.append(self.__Token)
2251                 if self.__IsToken(","):
2252                     while self.__GetNextToken():
2253                         if not Pattern.match(self.__Token):
2254                             raise Warning("expected KeyString \"Target_Tag_Arch\" At Line ", self.FileName, self.CurrentLineNumber)
2255                         FfsFileObj.KeyStringList.append(self.__Token)
2256
2257                         if not self.__IsToken(","):
2258                             break
2259
2260             else:
2261                 self.__UndoToken()
2262
2263         if self.__IsKeyword( "FIXED", True):
2264             FfsFileObj.Fixed = True
2265
2266         if self.__IsKeyword( "CHECKSUM", True):
2267             FfsFileObj.CheckSum = True
2268
2269         if self.__GetAlignment():
2270             FfsFileObj.Alignment = self.__Token
2271
2272
2273
2274     ## __GetAlignment() method
2275     #
2276     #   Return the alignment value
2277     #
2278     #   @param  self        The object pointer
2279     #   @retval True        Successfully find alignment
2280     #   @retval False       Not able to find alignment
2281     #
2282     def __GetAlignment(self):
2283         if self.__IsKeyword( "Align", True):
2284             if not self.__IsToken( "="):
2285                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2286
2287             if not self.__GetNextToken():
2288                 raise Warning("expected alignment value At Line ", self.FileName, self.CurrentLineNumber)
2289             return True
2290
2291         return False
2292
2293     ## __GetFilePart() method
2294     #
2295     #   Get section data for FILE statement
2296     #
2297     #   @param  self        The object pointer
2298     #   @param  FfsFileObj   for whom section is got
2299     #   @param  MacroDict   dictionary used to replace macro
2300     #
2301     def __GetSectionData(self, FfsFileObj, MacroDict = {}):
2302         Dict = {}
2303         Dict.update(MacroDict)
2304
2305         self.__GetDefineStatements(FfsFileObj)
2306
2307         Dict.update(FfsFileObj.DefineVarDict)
2308         self.__GetAprioriSection(FfsFileObj, Dict.copy())
2309         self.__GetAprioriSection(FfsFileObj, Dict.copy())
2310
2311         while True:
2312             IsLeafSection = self.__GetLeafSection(FfsFileObj, Dict)
2313             IsEncapSection = self.__GetEncapsulationSec(FfsFileObj)
2314             if not IsLeafSection and not IsEncapSection:
2315                 break
2316
2317     ## __GetLeafSection() method
2318     #
2319     #   Get leaf section for Obj
2320     #
2321     #   @param  self        The object pointer
2322     #   @param  Obj         for whom leaf section is got
2323     #   @param  MacroDict   dictionary used to replace macro
2324     #   @retval True        Successfully find section statement
2325     #   @retval False       Not able to find section statement
2326     #
2327     def __GetLeafSection(self, Obj, MacroDict = {}):
2328
2329         OldPos = self.GetFileBufferPos()
2330
2331         if not self.__IsKeyword( "SECTION"):
2332             if len(Obj.SectionList) == 0:
2333                 raise Warning("expected SECTION At Line ", self.FileName, self.CurrentLineNumber)
2334             else:
2335                 return False
2336
2337         AlignValue = None
2338         if self.__GetAlignment():
2339             if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2340                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
2341             AlignValue = self.__Token
2342
2343         BuildNum = None
2344         if self.__IsKeyword( "BUILD_NUM"):
2345             if not self.__IsToken( "="):
2346                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2347
2348             if not self.__GetNextToken():
2349                 raise Warning("expected Build number value At Line ", self.FileName, self.CurrentLineNumber)
2350
2351             BuildNum = self.__Token
2352
2353         if self.__IsKeyword( "VERSION"):
2354             if AlignValue == 'Auto':
2355                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2356             if not self.__IsToken( "="):
2357                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2358             if not self.__GetNextToken():
2359                 raise Warning("expected version At Line ", self.FileName, self.CurrentLineNumber)
2360             VerSectionObj = CommonDataClass.FdfClass.VerSectionClassObject()
2361             VerSectionObj.Alignment = AlignValue
2362             VerSectionObj.BuildNum = BuildNum
2363             if self.__GetStringData():
2364                 VerSectionObj.StringData = self.__Token
2365             else:
2366                 VerSectionObj.FileName = self.__Token
2367             Obj.SectionList.append(VerSectionObj)
2368
2369         elif self.__IsKeyword( "UI"):
2370             if AlignValue == 'Auto':
2371                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2372             if not self.__IsToken( "="):
2373                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2374             if not self.__GetNextToken():
2375                 raise Warning("expected UI At Line ", self.FileName, self.CurrentLineNumber)
2376             UiSectionObj = CommonDataClass.FdfClass.UiSectionClassObject()
2377             UiSectionObj.Alignment = AlignValue
2378             if self.__GetStringData():
2379                 UiSectionObj.StringData = self.__Token
2380             else:
2381                 UiSectionObj.FileName = self.__Token
2382             Obj.SectionList.append(UiSectionObj)
2383
2384         elif self.__IsKeyword( "FV_IMAGE"):
2385             if AlignValue == 'Auto':
2386                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2387             if not self.__IsToken( "="):
2388                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2389             if not self.__GetNextWord():
2390                 raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)
2391
2392             FvName = self.__Token.upper()
2393             FvObj = None
2394
2395             if self.__IsToken( "{"):
2396                 FvObj = Fv.FV()
2397                 FvObj.UiFvName = FvName
2398                 self.__GetDefineStatements(FvObj)
2399                 MacroDict.update(FvObj.DefineVarDict)
2400                 self.__GetBlockStatement(FvObj)
2401                 self.__GetSetStatements(FvObj)
2402                 self.__GetFvAlignment(FvObj)
2403                 self.__GetFvAttributes(FvObj)
2404                 self.__GetAprioriSection(FvObj, MacroDict.copy())
2405                 self.__GetAprioriSection(FvObj, MacroDict.copy())
2406
2407                 while True:
2408                     IsInf = self.__GetInfStatement(FvObj, MacroDict.copy())
2409                     IsFile = self.__GetFileStatement(FvObj, MacroDict.copy())
2410                     if not IsInf and not IsFile:
2411                         break
2412
2413                 if not self.__IsToken( "}"):
2414                     raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
2415
2416             FvImageSectionObj = CommonDataClass.FdfClass.FvImageSectionClassObject()
2417             FvImageSectionObj.Alignment = AlignValue
2418             if FvObj != None:
2419                 FvImageSectionObj.Fv = FvObj
2420                 FvImageSectionObj.FvName = None
2421             else:
2422                 FvImageSectionObj.FvName = FvName
2423
2424             Obj.SectionList.append(FvImageSectionObj)
2425
2426         elif self.__IsKeyword("PEI_DEPEX_EXP") or self.__IsKeyword("DXE_DEPEX_EXP") or self.__IsKeyword("SMM_DEPEX_EXP"):
2427             if AlignValue == 'Auto':
2428                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2429             DepexSectionObj = CommonDataClass.FdfClass.DepexSectionClassObject()
2430             DepexSectionObj.Alignment = AlignValue
2431             DepexSectionObj.DepexType = self.__Token
2432
2433             if not self.__IsToken( "="):
2434                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2435             if not self.__IsToken( "{"):
2436                 raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
2437             if not self.__SkipToToken( "}"):
2438                 raise Warning("expected Depex expression ending '}' At Line ", self.FileName, self.CurrentLineNumber)
2439
2440             DepexSectionObj.Expression = self.__SkippedChars.rstrip('}')
2441             Obj.SectionList.append(DepexSectionObj)
2442
2443         else:
2444
2445             if not self.__GetNextWord():
2446                 raise Warning("expected section type At Line ", self.FileName, self.CurrentLineNumber)
2447
2448             # Encapsulation section appear, UndoToken and return
2449             if self.__Token == "COMPRESS" or self.__Token == "GUIDED":
2450                 self.SetFileBufferPos(OldPos)
2451                 return False
2452
2453             if self.__Token not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
2454                                "UI", "VERSION", "PEI_DEPEX", "SUBTYPE_GUID", "SMM_DEPEX"):
2455                 raise Warning("Unknown section type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
2456             if AlignValue == 'Auto'and (not self.__Token == 'PE32') and (not self.__Token == 'TE'):
2457                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2458             # DataSection
2459             DataSectionObj = CommonDataClass.FdfClass.DataSectionClassObject()
2460             DataSectionObj.Alignment = AlignValue
2461             DataSectionObj.SecType = self.__Token
2462
2463             if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):
2464                 if self.__FileCouldHaveRelocFlag(Obj.FvFileType) and self.__SectionCouldHaveRelocFlag(DataSectionObj.SecType):
2465                     if self.__Token == 'RELOCS_STRIPPED':
2466                         DataSectionObj.KeepReloc = False
2467                     else:
2468                         DataSectionObj.KeepReloc = True
2469                 else:
2470                     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)
2471
2472             if self.__IsToken("="):
2473                 if not self.__GetNextToken():
2474                     raise Warning("expected section file path At Line ", self.FileName, self.CurrentLineNumber)
2475                 DataSectionObj.SectFileName = self.__Token
2476             else:
2477                 if not self.__GetCglSection(DataSectionObj):
2478                     return False
2479
2480             Obj.SectionList.append(DataSectionObj)
2481
2482         return True
2483
2484     ## __GetCglSection() method
2485     #
2486     #   Get compressed or GUIDed section for Obj
2487     #
2488     #   @param  self        The object pointer
2489     #   @param  Obj         for whom leaf section is got
2490     #   @param  AlignValue  alignment value for complex section
2491     #   @retval True        Successfully find section statement
2492     #   @retval False       Not able to find section statement
2493     #
2494     def __GetCglSection(self, Obj, AlignValue = None):
2495
2496         if self.__IsKeyword( "COMPRESS"):
2497             type = "PI_STD"
2498             if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):
2499                 type = self.__Token
2500
2501             if not self.__IsToken("{"):
2502                 raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
2503
2504             CompressSectionObj = CommonDataClass.FdfClass.CompressSectionClassObject()
2505             CompressSectionObj.Alignment = AlignValue
2506             CompressSectionObj.CompType = type
2507             # Recursive sections...
2508             while True:
2509                 IsLeafSection = self.__GetLeafSection(CompressSectionObj)
2510                 IsEncapSection = self.__GetEncapsulationSec(CompressSectionObj)
2511                 if not IsLeafSection and not IsEncapSection:
2512                     break
2513
2514
2515             if not self.__IsToken( "}"):
2516                 raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
2517             Obj.SectionList.append(CompressSectionObj)
2518
2519 #            else:
2520 #               raise Warning("Compress type not known At Line ")
2521
2522             return True
2523
2524         elif self.__IsKeyword( "GUIDED"):
2525             GuidValue = None
2526             if self.__GetNextGuid():
2527                 GuidValue = self.__Token
2528
2529             AttribDict = self.__GetGuidAttrib()
2530             if not self.__IsToken("{"):
2531                 raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
2532             GuidSectionObj = CommonDataClass.FdfClass.GuidSectionClassObject()
2533             GuidSectionObj.Alignment = AlignValue
2534             GuidSectionObj.NameGuid = GuidValue
2535             GuidSectionObj.SectionType = "GUIDED"
2536             GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]
2537             GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]
2538             # Recursive sections...
2539             while True:
2540                 IsLeafSection = self.__GetLeafSection(GuidSectionObj)
2541                 IsEncapSection = self.__GetEncapsulationSec(GuidSectionObj)
2542                 if not IsLeafSection and not IsEncapSection:
2543                     break
2544
2545             if not self.__IsToken( "}"):
2546                 raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
2547             Obj.SectionList.append(GuidSectionObj)
2548
2549             return True
2550
2551         return False
2552
2553     ## __GetGuidAttri() method
2554     #
2555     #   Get attributes for GUID section
2556     #
2557     #   @param  self        The object pointer
2558     #   @retval AttribDict  Dictionary of key-value pair of section attributes
2559     #
2560     def __GetGuidAttrib(self):
2561
2562         AttribDict = {}
2563         AttribDict["PROCESSING_REQUIRED"] = False
2564         AttribDict["AUTH_STATUS_VALID"] = False
2565         if self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID"):
2566             AttribKey = self.__Token
2567
2568             if not self.__IsToken("="):
2569                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2570
2571             if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):
2572                 raise Warning("expected TRUE/FALSE (1/0) At Line ", self.FileName, self.CurrentLineNumber)
2573             AttribDict[AttribKey] = self.__Token
2574
2575         if self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID"):
2576             AttribKey = self.__Token
2577
2578             if not self.__IsToken("="):
2579                 raise Warning("expected '=' At Line ")
2580
2581             if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):
2582                 raise Warning("expected TRUE/FALSE (1/0) At Line ", self.FileName, self.CurrentLineNumber)
2583             AttribDict[AttribKey] = self.__Token
2584
2585         return AttribDict
2586
2587     ## __GetEncapsulationSec() method
2588     #
2589     #   Get encapsulation section for FILE
2590     #
2591     #   @param  self        The object pointer
2592     #   @param  FfsFile     for whom section is got
2593     #   @retval True        Successfully find section statement
2594     #   @retval False       Not able to find section statement
2595     #
2596     def __GetEncapsulationSec(self, FfsFileObj):
2597
2598         OldPos = self.GetFileBufferPos()
2599         if not self.__IsKeyword( "SECTION"):
2600             if len(FfsFileObj.SectionList) == 0:
2601                 raise Warning("expected SECTION At Line ", self.FileName, self.CurrentLineNumber)
2602             else:
2603                 return False
2604
2605         AlignValue = None
2606         if self.__GetAlignment():
2607             if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2608                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
2609             AlignValue = self.__Token
2610
2611         if not self.__GetCglSection(FfsFileObj, AlignValue):
2612             self.SetFileBufferPos(OldPos)
2613             return False
2614         else:
2615             return True
2616
2617     ## __GetCapsule() method
2618     #
2619     #   Get capsule section contents and store its data into capsule list of self.Profile
2620     #
2621     #   @param  self        The object pointer
2622     #   @retval True        Successfully find a capsule
2623     #   @retval False       Not able to find a capsule
2624     #
2625     def __GetCapsule(self):
2626
2627         if not self.__GetNextToken():
2628             return False
2629
2630         S = self.__Token.upper()
2631         if S.startswith("[") and not S.startswith("[CAPSULE."):
2632             if not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):
2633                 raise Warning("Unknown section or section appear sequence error (The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)
2634             self.__UndoToken()
2635             return False
2636
2637         self.__UndoToken()
2638         if not self.__IsToken("[CAPSULE.", True):
2639             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
2640             print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
2641                     % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
2642             raise Warning("expected [Capsule.] At Line ", self.FileName, self.CurrentLineNumber)
2643
2644         CapsuleObj = CommonDataClass.FdfClass.CapsuleClassObject()
2645
2646         CapsuleName = self.__GetUiName()
2647         if not CapsuleName:
2648             raise Warning("expected capsule name At line ", self.FileName, self.CurrentLineNumber)
2649
2650         CapsuleObj.UiCapsuleName = CapsuleName.upper()
2651
2652         if not self.__IsToken( "]"):
2653             raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)
2654
2655         if self.__IsKeyword("CREATE_FILE"):
2656             if not self.__IsToken( "="):
2657                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2658
2659             if not self.__GetNextToken():
2660                 raise Warning("expected file name At Line ", self.FileName, self.CurrentLineNumber)
2661
2662             CapsuleObj.CreateFile = self.__Token
2663
2664         self.__GetCapsuleStatements(CapsuleObj)
2665         self.Profile.CapsuleList.append(CapsuleObj)
2666         return True
2667
2668     ## __GetCapsuleStatements() method
2669     #
2670     #   Get statements for capsule
2671     #
2672     #   @param  self        The object pointer
2673     #   @param  Obj         for whom statements are got
2674     #
2675     def __GetCapsuleStatements(self, Obj):
2676         self.__GetCapsuleTokens(Obj)
2677         self.__GetDefineStatements(Obj)
2678         self.__GetSetStatements(Obj)
2679
2680         self.__GetCapsuleData(Obj)
2681
2682     ## __GetCapsuleStatements() method
2683     #
2684     #   Get token statements for capsule
2685     #
2686     #   @param  self        The object pointer
2687     #   @param  Obj         for whom token statements are got
2688     #
2689     def __GetCapsuleTokens(self, Obj):
2690
2691         if not self.__IsKeyword("CAPSULE_GUID"):
2692             raise Warning("expected 'CAPSULE_GUID' At Line ", self.FileName, self.CurrentLineNumber)
2693
2694         while self.__CurrentLine().find("=") != -1:
2695             NameValue = self.__CurrentLine().split("=")
2696             Obj.TokensDict[NameValue[0].strip()] = NameValue[1].strip()
2697             self.CurrentLineNumber += 1
2698             self.CurrentOffsetWithinLine = 0
2699
2700     ## __GetCapsuleData() method
2701     #
2702     #   Get capsule data for capsule
2703     #
2704     #   @param  self        The object pointer
2705     #   @param  Obj         for whom capsule data are got
2706     #
2707     def __GetCapsuleData(self, Obj):
2708
2709         while True:
2710             IsInf = self.__GetInfStatement(Obj, True)
2711             IsFile = self.__GetFileStatement(Obj, True)
2712             IsFv = self.__GetFvStatement(Obj)
2713             if not IsInf and not IsFile and not IsFv:
2714                 break
2715
2716     ## __GetFvStatement() method
2717     #
2718     #   Get FV for capsule
2719     #
2720     #   @param  self        The object pointer
2721     #   @param  CapsuleObj  for whom FV is got
2722     #   @retval True        Successfully find a FV statement
2723     #   @retval False       Not able to find a FV statement
2724     #
2725     def __GetFvStatement(self, CapsuleObj):
2726
2727         if not self.__IsKeyword("FV"):
2728             return False
2729
2730         if not self.__IsToken("="):
2731             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2732
2733         if not self.__GetNextToken():
2734             raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)
2735
2736 #        CapsuleFv = CapsuleData.CapsuleFv()
2737 #        CapsuleFv.FvName = self.__Token
2738 #        CapsuleObj.CapsuleDataList.append(CapsuleFv)
2739         return True
2740
2741     ## __GetRule() method
2742     #
2743     #   Get Rule section contents and store its data into rule list of self.Profile
2744     #
2745     #   @param  self        The object pointer
2746     #   @retval True        Successfully find a Rule
2747     #   @retval False       Not able to find a Rule
2748     #
2749     def __GetRule(self):
2750
2751         if not self.__GetNextToken():
2752             return False
2753
2754         S = self.__Token.upper()
2755         if S.startswith("[") and not S.startswith("[RULE."):
2756             if not S.startswith("[OPTIONROM."):
2757                 raise Warning("Unknown section or section appear sequence error (The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)
2758             self.__UndoToken()
2759             return False
2760         self.__UndoToken()
2761         if not self.__IsToken("[Rule.", True):
2762             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
2763             print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
2764                     % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
2765             raise Warning("expected [Rule.] At Line ", self.FileName, self.CurrentLineNumber)
2766
2767         if not self.__SkipToToken("."):
2768             raise Warning("expected '.' At Line ", self.FileName, self.CurrentLineNumber)
2769
2770         Arch = self.__SkippedChars.rstrip(".")
2771         if Arch.upper() not in ("IA32", "X64", "IPF", "EBC", "ARM", "COMMON"):
2772             raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber)
2773
2774         ModuleType = self.__GetModuleType()
2775
2776         TemplateName = ""
2777         if self.__IsToken("."):
2778             if not self.__GetNextWord():
2779                 raise Warning("expected template name At Line ", self.FileName, self.CurrentLineNumber)
2780             TemplateName = self.__Token
2781
2782         if not self.__IsToken( "]"):
2783             raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)
2784
2785         RuleObj = self.__GetRuleFileStatements()
2786         RuleObj.Arch = Arch.upper()
2787         RuleObj.ModuleType = ModuleType
2788         RuleObj.TemplateName = TemplateName
2789         if TemplateName == '' :
2790             self.Profile.RuleDict['RULE'             + \
2791                               '.'                    + \
2792                               Arch.upper()           + \
2793                               '.'                    + \
2794                               ModuleType.upper()     ] = RuleObj
2795         else :
2796             self.Profile.RuleDict['RULE'             + \
2797                               '.'                    + \
2798                               Arch.upper()           + \
2799                               '.'                    + \
2800                               ModuleType.upper()     + \
2801                               '.'                    + \
2802                               TemplateName.upper() ] = RuleObj
2803 #        self.Profile.RuleList.append(rule)
2804         return True
2805
2806     ## __GetModuleType() method
2807     #
2808     #   Return the module type
2809     #
2810     #   @param  self        The object pointer
2811     #   @retval string      module type
2812     #
2813     def __GetModuleType(self):
2814
2815         if not self.__GetNextWord():
2816             raise Warning("expected Module type At Line ", self.FileName, self.CurrentLineNumber)
2817         if self.__Token.upper() not in ("SEC", "PEI_CORE", "PEIM", "DXE_CORE", \
2818                              "DXE_DRIVER", "DXE_SAL_DRIVER", \
2819                              "DXE_SMM_DRIVER", "DXE_RUNTIME_DRIVER", \
2820                              "UEFI_DRIVER", "UEFI_APPLICATION", "USER_DEFINED", "DEFAULT", "BASE", \
2821                              "SECURITY_CORE", "COMBINED_PEIM_DRIVER", "PIC_PEIM", "RELOCATABLE_PEIM", \
2822                              "PE32_PEIM", "BS_DRIVER", "RT_DRIVER", "SAL_RT_DRIVER", "APPLICATION", "ACPITABLE", "SMM_CORE"):
2823             raise Warning("Unknown Module type At line ", self.FileName, self.CurrentLineNumber)
2824         return self.__Token
2825
2826     ## __GetFileExtension() method
2827     #
2828     #   Return the file extension
2829     #
2830     #   @param  self        The object pointer
2831     #   @retval string      file name extension
2832     #
2833     def __GetFileExtension(self):
2834         if not self.__IsToken("."):
2835                 raise Warning("expected '.' At Line ", self.FileName, self.CurrentLineNumber)
2836
2837         Ext = ""
2838         if self.__GetNextToken():
2839             Pattern = re.compile(r'([a-zA-Z][a-zA-Z0-9]*)')
2840             if Pattern.match(self.__Token):
2841                 Ext = self.__Token
2842                 return '.' + Ext
2843             else:
2844                 raise Warning("Unknown file extension At Line ", self.FileName, self.CurrentLineNumber)
2845
2846         else:
2847             raise Warning("expected file extension At Line ", self.FileName, self.CurrentLineNumber)
2848
2849     ## __GetRuleFileStatement() method
2850     #
2851     #   Get rule contents
2852     #
2853     #   @param  self        The object pointer
2854     #   @retval Rule        Rule object
2855     #
2856     def __GetRuleFileStatements(self):
2857
2858         if not self.__IsKeyword("FILE"):
2859             raise Warning("expected FILE At Line ", self.FileName, self.CurrentLineNumber)
2860
2861         if not self.__GetNextWord():
2862             raise Warning("expected FFS type At Line ", self.FileName, self.CurrentLineNumber)
2863
2864         Type = self.__Token.strip().upper()
2865         if Type not in ("RAW", "FREEFORM", "SEC", "PEI_CORE", "PEIM",\
2866                              "PEI_DXE_COMBO", "DRIVER", "DXE_CORE", "APPLICATION", "FV_IMAGE", "SMM", "SMM_CORE"):
2867             raise Warning("Unknown FV type At line ", self.FileName, self.CurrentLineNumber)
2868
2869         if not self.__IsToken("="):
2870             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
2871
2872         if not self.__IsKeyword("$(NAMED_GUID)"):
2873             if not self.__GetNextWord():
2874                 raise Warning("expected $(NAMED_GUID)", self.FileName, self.CurrentLineNumber)
2875             if self.__Token == 'PCD':
2876                 if not self.__IsToken( "("):
2877                     raise Warning("expected '('", self.FileName, self.CurrentLineNumber)
2878                 PcdPair = self.__GetNextPcdName()
2879                 if not self.__IsToken( ")"):
2880                     raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)
2881                 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'
2882
2883         NameGuid = self.__Token
2884
2885         KeepReloc = None
2886         if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):
2887             if self.__FileCouldHaveRelocFlag(Type):
2888                 if self.__Token == 'RELOCS_STRIPPED':
2889                     KeepReloc = False
2890                 else:
2891                     KeepReloc = True
2892             else:
2893                 raise Warning("File type %s could not have reloc strip flag At Line %d" % (Type, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
2894
2895         KeyStringList = []
2896         if self.__GetNextToken():
2897             Pattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
2898             if Pattern.match(self.__Token):
2899                 KeyStringList.append(self.__Token)
2900                 if self.__IsToken(","):
2901                     while self.__GetNextToken():
2902                         if not Pattern.match(self.__Token):
2903                             raise Warning("expected KeyString \"Target_Tag_Arch\" At Line ", self.FileName, self.CurrentLineNumber)
2904                         KeyStringList.append(self.__Token)
2905
2906                         if not self.__IsToken(","):
2907                             break
2908
2909             else:
2910                 self.__UndoToken()
2911
2912
2913         Fixed = False
2914         if self.__IsKeyword("Fixed", True):
2915             Fixed = True
2916
2917         CheckSum = False
2918         if self.__IsKeyword("CheckSum", True):
2919             CheckSum = True
2920
2921         AlignValue = ""
2922         if self.__GetAlignment():
2923             if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2924                 raise Warning("Incorrect alignment At Line ", self.FileName, self.CurrentLineNumber)
2925             AlignValue = self.__Token
2926
2927         if self.__IsToken("{"):
2928             # Complex file rule expected
2929             Rule = RuleComplexFile.RuleComplexFile()
2930             Rule.FvFileType = Type
2931             Rule.NameGuid = NameGuid
2932             Rule.Alignment = AlignValue
2933             Rule.CheckSum = CheckSum
2934             Rule.Fixed = Fixed
2935             Rule.KeyStringList = KeyStringList
2936             if KeepReloc != None:
2937                 Rule.KeepReloc = KeepReloc
2938
2939             while True:
2940                 IsEncapsulate = self.__GetRuleEncapsulationSection(Rule)
2941                 IsLeaf = self.__GetEfiSection(Rule)
2942                 if not IsEncapsulate and not IsLeaf:
2943                     break
2944
2945             if not self.__IsToken("}"):
2946                 raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
2947
2948             return Rule
2949
2950         elif self.__IsToken("|"):
2951             # Ext rule expected
2952             Ext = self.__GetFileExtension()
2953
2954             Rule = RuleSimpleFile.RuleSimpleFile()
2955
2956             Rule.FvFileType = Type
2957             Rule.NameGuid = NameGuid
2958             Rule.Alignment = AlignValue
2959             Rule.CheckSum = CheckSum
2960             Rule.Fixed = Fixed
2961             Rule.FileExtension = Ext
2962             Rule.KeyStringList = KeyStringList
2963             if KeepReloc != None:
2964                 Rule.KeepReloc = KeepReloc
2965
2966             return Rule
2967
2968         else:
2969             # Simple file rule expected
2970             if not self.__GetNextWord():
2971                 raise Warning("expected leaf section type At Line ", self.FileName, self.CurrentLineNumber)
2972
2973             SectionName = self.__Token
2974
2975             if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
2976                                     "UI", "PEI_DEPEX", "VERSION", "SUBTYPE_GUID", "SMM_DEPEX"):
2977                 raise Warning("Unknown leaf section name '%s'" % SectionName, self.FileName, self.CurrentLineNumber)
2978
2979
2980             if self.__IsKeyword("Fixed", True):
2981                 Fixed = True
2982
2983             if self.__IsKeyword("CheckSum", True):
2984                 CheckSum = True
2985
2986             if self.__GetAlignment():
2987                 if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2988                     raise Warning("Incorrect alignment At Line ", self.FileName, self.CurrentLineNumber)
2989                 if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'):
2990                     raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
2991                 AlignValue = self.__Token
2992
2993             if not self.__GetNextToken():
2994                 raise Warning("expected File name At Line ", self.FileName, self.CurrentLineNumber)
2995
2996             Rule = RuleSimpleFile.RuleSimpleFile()
2997             Rule.SectionType = SectionName
2998             Rule.FvFileType = Type
2999             Rule.NameGuid = NameGuid
3000             Rule.Alignment = AlignValue
3001             Rule.CheckSum = CheckSum
3002             Rule.Fixed = Fixed
3003             Rule.FileName = self.__Token
3004             Rule.KeyStringList = KeyStringList
3005             if KeepReloc != None:
3006                 Rule.KeepReloc = KeepReloc
3007             return Rule
3008
3009     ## __GetEfiSection() method
3010     #
3011     #   Get section list for Rule
3012     #
3013     #   @param  self        The object pointer
3014     #   @param  Obj         for whom section is got
3015     #   @retval True        Successfully find section statement
3016     #   @retval False       Not able to find section statement
3017     #
3018     def __GetEfiSection(self, Obj):
3019
3020         OldPos = self.GetFileBufferPos()
3021         if not self.__GetNextWord():
3022             return False
3023         SectionName = self.__Token
3024
3025         if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3026                                "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3027             self.__UndoToken()
3028             return False
3029
3030         if SectionName == "FV_IMAGE":
3031             FvImageSectionObj = FvImageSection.FvImageSection()
3032             if self.__IsKeyword("FV_IMAGE"):
3033                 pass
3034             if self.__IsToken( "{"):
3035                 FvObj = Fv.FV()
3036                 self.__GetDefineStatements(FvObj)
3037                 self.__GetBlockStatement(FvObj)
3038                 self.__GetSetStatements(FvObj)
3039                 self.__GetFvAlignment(FvObj)
3040                 self.__GetFvAttributes(FvObj)
3041                 self.__GetAprioriSection(FvObj)
3042                 self.__GetAprioriSection(FvObj)
3043
3044                 while True:
3045                     IsInf = self.__GetInfStatement(FvObj)
3046                     IsFile = self.__GetFileStatement(FvObj)
3047                     if not IsInf and not IsFile:
3048                         break
3049
3050                 if not self.__IsToken( "}"):
3051                     raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
3052                 FvImageSectionObj.Fv = FvObj
3053                 FvImageSectionObj.FvName = None
3054
3055             else:
3056                 if not self.__IsKeyword("FV"):
3057                     raise Warning("expected 'FV' At Line ", self.FileName, self.CurrentLineNumber)
3058                 FvImageSectionObj.FvFileType = self.__Token
3059
3060                 if self.__GetAlignment():
3061                     if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3062                         raise Warning("Incorrect alignment At Line ", self.FileName, self.CurrentLineNumber)
3063                     FvImageSectionObj.Alignment = self.__Token
3064
3065                 if self.__IsToken('|'):
3066                     FvImageSectionObj.FvFileExtension = self.__GetFileExtension()
3067                 elif self.__GetNextToken():
3068                     if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3069                                "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3070                         FvImageSectionObj.FvFileName = self.__Token
3071                     else:
3072                         self.__UndoToken()
3073                 else:
3074                     raise Warning("expected FV file name At Line ", self.FileName, self.CurrentLineNumber)
3075
3076             Obj.SectionList.append(FvImageSectionObj)
3077             return True
3078
3079         EfiSectionObj = EfiSection.EfiSection()
3080         EfiSectionObj.SectionType = SectionName
3081
3082         if not self.__GetNextToken():
3083             raise Warning("expected file type At Line ", self.FileName, self.CurrentLineNumber)
3084
3085         if self.__Token == "STRING":
3086             if not self.__RuleSectionCouldHaveString(EfiSectionObj.SectionType):
3087                 raise Warning("%s section could NOT have string data At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3088
3089             if not self.__IsToken('='):
3090                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3091
3092             if not self.__GetNextToken():
3093                 raise Warning("expected Quoted String At Line ", self.FileName, self.CurrentLineNumber)
3094
3095             if self.__GetStringData():
3096                 EfiSectionObj.StringData = self.__Token
3097
3098             if self.__IsKeyword("BUILD_NUM"):
3099                 if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):
3100                     raise Warning("%s section could NOT have BUILD_NUM At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3101
3102                 if not self.__IsToken("="):
3103                     raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3104                 if not self.__GetNextToken():
3105                     raise Warning("expected Build number At Line ", self.FileName, self.CurrentLineNumber)
3106                 EfiSectionObj.BuildNum = self.__Token
3107
3108         else:
3109             EfiSectionObj.FileType = self.__Token
3110             self.__CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType)
3111
3112         if self.__IsKeyword("Optional"):
3113             if not self.__RuleSectionCouldBeOptional(EfiSectionObj.SectionType):
3114                 raise Warning("%s section could NOT be optional At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3115             EfiSectionObj.Optional = True
3116
3117             if self.__IsKeyword("BUILD_NUM"):
3118                 if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):
3119                     raise Warning("%s section could NOT have BUILD_NUM At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3120
3121                 if not self.__IsToken("="):
3122                     raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3123                 if not self.__GetNextToken():
3124                     raise Warning("expected Build number At Line ", self.FileName, self.CurrentLineNumber)
3125                 EfiSectionObj.BuildNum = self.__Token
3126
3127         if self.__GetAlignment():
3128             if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3129                 raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)
3130             if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'):
3131                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
3132             EfiSectionObj.Alignment = self.__Token
3133
3134         if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):
3135             if self.__SectionCouldHaveRelocFlag(EfiSectionObj.SectionType):
3136                 if self.__Token == 'RELOCS_STRIPPED':
3137                     EfiSectionObj.KeepReloc = False
3138                 else:
3139                     EfiSectionObj.KeepReloc = True
3140                 if Obj.KeepReloc != None and Obj.KeepReloc != EfiSectionObj.KeepReloc:
3141                     raise Warning("Section type %s has reloc strip flag conflict with Rule At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3142             else:
3143                 raise Warning("Section type %s could not have reloc strip flag At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
3144
3145
3146         if self.__IsToken('|'):
3147             EfiSectionObj.FileExtension = self.__GetFileExtension()
3148         elif self.__GetNextToken():
3149             if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3150                        "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3151
3152                 if self.__Token.startswith('PCD'):
3153                     self.__UndoToken()
3154                     self.__GetNextWord()
3155
3156                     if self.__Token == 'PCD':
3157                         if not self.__IsToken( "("):
3158                             raise Warning("expected '('", self.FileName, self.CurrentLineNumber)
3159                         PcdPair = self.__GetNextPcdName()
3160                         if not self.__IsToken( ")"):
3161                             raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)
3162                         self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'
3163
3164                 EfiSectionObj.FileName = self.__Token
3165
3166             else:
3167                 self.__UndoToken()
3168         else:
3169             raise Warning("expected section file name At Line ", self.FileName, self.CurrentLineNumber)
3170
3171         Obj.SectionList.append(EfiSectionObj)
3172         return True
3173
3174     ## __RuleSectionCouldBeOptional() method
3175     #
3176     #   Get whether a section could be optional
3177     #
3178     #   @param  self        The object pointer
3179     #   @param  SectionType The section type to check
3180     #   @retval True        section could be optional
3181     #   @retval False       section never optional
3182     #
3183     def __RuleSectionCouldBeOptional(self, SectionType):
3184         if SectionType in ("DXE_DEPEX", "UI", "VERSION", "PEI_DEPEX", "RAW", "SMM_DEPEX"):
3185             return True
3186         else:
3187             return False
3188
3189     ## __RuleSectionCouldHaveBuildNum() method
3190     #
3191     #   Get whether a section could have build number information
3192     #
3193     #   @param  self        The object pointer
3194     #   @param  SectionType The section type to check
3195     #   @retval True        section could have build number information
3196     #   @retval False       section never have build number information
3197     #
3198     def __RuleSectionCouldHaveBuildNum(self, SectionType):
3199         if SectionType in ("VERSION"):
3200             return True
3201         else:
3202             return False
3203
3204     ## __RuleSectionCouldHaveString() method
3205     #
3206     #   Get whether a section could have string
3207     #
3208     #   @param  self        The object pointer
3209     #   @param  SectionType The section type to check
3210     #   @retval True        section could have string
3211     #   @retval False       section never have string
3212     #
3213     def __RuleSectionCouldHaveString(self, SectionType):
3214         if SectionType in ("UI", "VERSION"):
3215             return True
3216         else:
3217             return False
3218
3219     ## __CheckRuleSectionFileType() method
3220     #
3221     #   Get whether a section matches a file type
3222     #
3223     #   @param  self        The object pointer
3224     #   @param  SectionType The section type to check
3225     #   @param  FileType    The file type to check
3226     #
3227     def __CheckRuleSectionFileType(self, SectionType, FileType):
3228         if SectionType == "COMPAT16":
3229             if FileType not in ("COMPAT16", "SEC_COMPAT16"):
3230                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3231         elif SectionType == "PE32":
3232             if FileType not in ("PE32", "SEC_PE32"):
3233                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3234         elif SectionType == "PIC":
3235             if FileType not in ("PIC", "PIC"):
3236                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3237         elif SectionType == "TE":
3238             if FileType not in ("TE", "SEC_TE"):
3239                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3240         elif SectionType == "RAW":
3241             if FileType not in ("BIN", "SEC_BIN", "RAW", "ASL", "ACPI"):
3242                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3243         elif SectionType == "DXE_DEPEX" or SectionType == "SMM_DEPEX":
3244             if FileType not in ("DXE_DEPEX", "SEC_DXE_DEPEX", "SMM_DEPEX"):
3245                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3246         elif SectionType == "UI":
3247             if FileType not in ("UI", "SEC_UI"):
3248                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3249         elif SectionType == "VERSION":
3250             if FileType not in ("VERSION", "SEC_VERSION"):
3251                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3252         elif SectionType == "PEI_DEPEX":
3253             if FileType not in ("PEI_DEPEX", "SEC_PEI_DEPEX"):
3254                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3255         elif SectionType == "GUID":
3256             if FileType not in ("PE32", "SEC_GUID"):
3257                 raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)
3258
3259     ## __GetRuleEncapsulationSection() method
3260     #
3261     #   Get encapsulation section for Rule
3262     #
3263     #   @param  self        The object pointer
3264     #   @param  Rule        for whom section is got
3265     #   @retval True        Successfully find section statement
3266     #   @retval False       Not able to find section statement
3267     #
3268     def __GetRuleEncapsulationSection(self, Rule):
3269
3270         if self.__IsKeyword( "COMPRESS"):
3271             Type = "PI_STD"
3272             if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):
3273                 Type = self.__Token
3274
3275             if not self.__IsToken("{"):
3276                 raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
3277
3278             CompressSectionObj = CompressSection.CompressSection()
3279
3280             CompressSectionObj.CompType = Type
3281             # Recursive sections...
3282             while True:
3283                 IsEncapsulate = self.__GetRuleEncapsulationSection(CompressSectionObj)
3284                 IsLeaf = self.__GetEfiSection(CompressSectionObj)
3285                 if not IsEncapsulate and not IsLeaf:
3286                     break
3287
3288             if not self.__IsToken( "}"):
3289                 raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
3290             Rule.SectionList.append(CompressSectionObj)
3291
3292             return True
3293
3294         elif self.__IsKeyword( "GUIDED"):
3295             GuidValue = None
3296             if self.__GetNextGuid():
3297                 GuidValue = self.__Token
3298
3299             if self.__IsKeyword( "$(NAMED_GUID)"):
3300                 GuidValue = self.__Token
3301
3302             AttribDict = self.__GetGuidAttrib()
3303
3304             if not self.__IsToken("{"):
3305                 raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)
3306             GuidSectionObj = GuidSection.GuidSection()
3307             GuidSectionObj.NameGuid = GuidValue
3308             GuidSectionObj.SectionType = "GUIDED"
3309             GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]
3310             GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]
3311
3312             # Efi sections...
3313             while True:
3314                 IsEncapsulate = self.__GetRuleEncapsulationSection(GuidSectionObj)
3315                 IsLeaf = self.__GetEfiSection(GuidSectionObj)
3316                 if not IsEncapsulate and not IsLeaf:
3317                     break
3318
3319             if not self.__IsToken( "}"):
3320                 raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)
3321             Rule.SectionList.append(GuidSectionObj)
3322
3323             return True
3324
3325         return False
3326
3327     ## __GetVtf() method
3328     #
3329     #   Get VTF section contents and store its data into VTF list of self.Profile
3330     #
3331     #   @param  self        The object pointer
3332     #   @retval True        Successfully find a VTF
3333     #   @retval False       Not able to find a VTF
3334     #
3335     def __GetVtf(self):
3336
3337         if not self.__GetNextToken():
3338             return False
3339
3340         S = self.__Token.upper()
3341         if S.startswith("[") and not S.startswith("[VTF."):
3342             if not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):
3343                 raise Warning("Unknown section or section appear sequence error (The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)
3344             self.__UndoToken()
3345             return False
3346
3347         self.__UndoToken()
3348         if not self.__IsToken("[VTF.", True):
3349             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
3350             print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
3351                     % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
3352             raise Warning("expected [VTF.] At Line ", self.FileName, self.CurrentLineNumber)
3353
3354         if not self.__SkipToToken("."):
3355             raise Warning("expected '.' At Line ", self.FileName, self.CurrentLineNumber)
3356
3357         Arch = self.__SkippedChars.rstrip(".").upper()
3358         if Arch not in ("IA32", "X64", "IPF", "ARM"):
3359             raise Warning("Unknown Arch At line ", self.FileName, self.CurrentLineNumber)
3360
3361         if not self.__GetNextWord():
3362             raise Warning("expected VTF name At Line ", self.FileName, self.CurrentLineNumber)
3363         Name = self.__Token.upper()
3364
3365         VtfObj = Vtf.Vtf()
3366         VtfObj.UiName = Name
3367         VtfObj.KeyArch = Arch
3368
3369         if self.__IsToken(","):
3370             if not self.__GetNextWord():
3371                 raise Warning("expected Arch list At Line ", self.FileName, self.CurrentLineNumber)
3372             if self.__Token.upper() not in ("IA32", "X64", "IPF", "ARM"):
3373                 raise Warning("Unknown Arch At line ", self.FileName, self.CurrentLineNumber)
3374             VtfObj.ArchList = self.__Token.upper()
3375
3376         if not self.__IsToken( "]"):
3377             raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)
3378
3379         if self.__IsKeyword("IA32_RST_BIN"):
3380             if not self.__IsToken("="):
3381                 raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3382
3383             if not self.__GetNextToken():
3384                 raise Warning("expected Reset file At Line ", self.FileName, self.CurrentLineNumber)
3385
3386             VtfObj.ResetBin = self.__Token
3387
3388         while self.__GetComponentStatement(VtfObj):
3389             pass
3390
3391         self.Profile.VtfList.append(VtfObj)
3392         return True
3393
3394     ## __GetComponentStatement() method
3395     #
3396     #   Get components in VTF
3397     #
3398     #   @param  self        The object pointer
3399     #   @param  VtfObj         for whom component is got
3400     #   @retval True        Successfully find a component
3401     #   @retval False       Not able to find a component
3402     #
3403     def __GetComponentStatement(self, VtfObj):
3404
3405         if not self.__IsKeyword("COMP_NAME"):
3406             return False
3407
3408         if not self.__IsToken("="):
3409             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3410
3411         if not self.__GetNextWord():
3412             raise Warning("expected Component Name At Line ", self.FileName, self.CurrentLineNumber)
3413
3414         CompStatementObj = ComponentStatement.ComponentStatement()
3415         CompStatementObj.CompName = self.__Token
3416
3417         if not self.__IsKeyword("COMP_LOC"):
3418             raise Warning("expected COMP_LOC At Line ", self.FileName, self.CurrentLineNumber)
3419
3420         if not self.__IsToken("="):
3421             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3422
3423         CompStatementObj.CompLoc = ""
3424         if self.__GetNextWord():
3425             CompStatementObj.CompLoc = self.__Token
3426             if self.__IsToken('|'):
3427                 if not self.__GetNextWord():
3428                     raise Warning("Expected Region Name At Line ", self.FileName, self.CurrentLineNumber)
3429
3430                 if self.__Token not in ("F", "N", "S"):    #, "H", "L", "PH", "PL"): not support
3431                     raise Warning("Unknown location type At line ", self.FileName, self.CurrentLineNumber)
3432
3433                 CompStatementObj.FilePos = self.__Token
3434         else:
3435             self.CurrentLineNumber += 1
3436             self.CurrentOffsetWithinLine = 0
3437
3438         if not self.__IsKeyword("COMP_TYPE"):
3439             raise Warning("expected COMP_TYPE At Line ", self.FileName, self.CurrentLineNumber)
3440
3441         if not self.__IsToken("="):
3442             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3443
3444         if not self.__GetNextToken():
3445             raise Warning("expected Component type At Line ", self.FileName, self.CurrentLineNumber)
3446         if self.__Token not in ("FIT", "PAL_B", "PAL_A", "OEM"):
3447             if not self.__Token.startswith("0x") or len(self.__Token) < 3 or len(self.__Token) > 4 or \
3448                 not self.__HexDigit(self.__Token[2]) or not self.__HexDigit(self.__Token[-1]):
3449                 raise Warning("Unknown location type At line ", self.FileName, self.CurrentLineNumber)
3450         CompStatementObj.CompType = self.__Token
3451
3452         if not self.__IsKeyword("COMP_VER"):
3453             raise Warning("expected COMP_VER At Line ", self.FileName, self.CurrentLineNumber)
3454
3455         if not self.__IsToken("="):
3456             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3457
3458         if not self.__GetNextToken():
3459             raise Warning("expected Component version At Line ", self.FileName, self.CurrentLineNumber)
3460
3461         Pattern = re.compile('-$|[0-9]{0,1}[0-9]{1}\.[0-9]{0,1}[0-9]{1}')
3462         if Pattern.match(self.__Token) == None:
3463             raise Warning("Unknown version format At line ", self.FileName, self.CurrentLineNumber)
3464         CompStatementObj.CompVer = self.__Token
3465
3466         if not self.__IsKeyword("COMP_CS"):
3467             raise Warning("expected COMP_CS At Line ", self.FileName, self.CurrentLineNumber)
3468
3469         if not self.__IsToken("="):
3470             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3471
3472         if not self.__GetNextToken():
3473             raise Warning("expected Component CS At Line ", self.FileName, self.CurrentLineNumber)
3474         if self.__Token not in ("1", "0"):
3475             raise Warning("Unknown  Component CS At line ", self.FileName, self.CurrentLineNumber)
3476         CompStatementObj.CompCs = self.__Token
3477
3478
3479         if not self.__IsKeyword("COMP_BIN"):
3480             raise Warning("expected COMP_BIN At Line ", self.FileName, self.CurrentLineNumber)
3481
3482         if not self.__IsToken("="):
3483             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3484
3485         if not self.__GetNextToken():
3486             raise Warning("expected Component file At Line ", self.FileName, self.CurrentLineNumber)
3487
3488         CompStatementObj.CompBin = self.__Token
3489
3490         if not self.__IsKeyword("COMP_SYM"):
3491             raise Warning("expected COMP_SYM At Line ", self.FileName, self.CurrentLineNumber)
3492
3493         if not self.__IsToken("="):
3494             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3495
3496         if not self.__GetNextToken():
3497             raise Warning("expected Component symbol file At Line ", self.FileName, self.CurrentLineNumber)
3498
3499         CompStatementObj.CompSym = self.__Token
3500
3501         if not self.__IsKeyword("COMP_SIZE"):
3502             raise Warning("expected COMP_SIZE At Line ", self.FileName, self.CurrentLineNumber)
3503
3504         if not self.__IsToken("="):
3505             raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)
3506
3507         if self.__IsToken("-"):
3508             CompStatementObj.CompSize = self.__Token
3509         elif self.__GetNextDecimalNumber():
3510             CompStatementObj.CompSize = self.__Token
3511         elif self.__GetNextHexNumber():
3512             CompStatementObj.CompSize = self.__Token
3513         else:
3514             raise Warning("Unknown size At line ", self.FileName, self.CurrentLineNumber)
3515
3516         VtfObj.ComponentStatementList.append(CompStatementObj)
3517         return True
3518
3519     ## __GetFvInFd() method
3520     #
3521     #   Get FV list contained in FD
3522     #
3523     #   @param  self        The object pointer
3524     #   @param  FdName      FD name
3525     #   @retval FvList      list of FV in FD
3526     #
3527     def __GetFvInFd (self, FdName):
3528
3529         FvList = []
3530         if FdName.upper() in self.Profile.FdDict.keys():
3531             FdObj = self.Profile.FdDict[FdName.upper()]
3532             for elementRegion in FdObj.RegionList:
3533                 if elementRegion.RegionType == 'FV':
3534                     for elementRegionData in elementRegion.RegionDataList:
3535                         if elementRegionData != None and elementRegionData.upper() not in FvList:
3536                             FvList.append(elementRegionData.upper())
3537         return FvList
3538
3539     ## __GetReferencedFdFvTuple() method
3540     #
3541     #   Get FD and FV list referenced by a FFS file
3542     #
3543     #   @param  self        The object pointer
3544     #   @param  FfsFile     contains sections to be searched
3545     #   @param  RefFdList   referenced FD by section
3546     #   @param  RefFvList   referenced FV by section
3547     #
3548     def __GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []):
3549
3550         for FfsObj in FvObj.FfsList:
3551             if isinstance(FfsObj, FfsFileStatement.FileStatement):
3552                 if FfsObj.FvName != None and FfsObj.FvName.upper() not in RefFvList:
3553                     RefFvList.append(FfsObj.FvName.upper())
3554                 elif FfsObj.FdName != None and FfsObj.FdName.upper() not in RefFdList:
3555                     RefFdList.append(FfsObj.FdName.upper())
3556                 else:
3557                     self.__GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList)
3558
3559     ## __GetReferencedFdFvTupleFromSection() method
3560     #
3561     #   Get FD and FV list referenced by a FFS section
3562     #
3563     #   @param  self        The object pointer
3564     #   @param  FfsFile     contains sections to be searched
3565     #   @param  FdList      referenced FD by section
3566     #   @param  FvList      referenced FV by section
3567     #
3568     def __GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []):
3569
3570         SectionStack = []
3571         SectionStack.extend(FfsFile.SectionList)
3572         while SectionStack != []:
3573             SectionObj = SectionStack.pop()
3574             if isinstance(SectionObj, FvImageSection.FvImageSection):
3575                 if SectionObj.FvName != None and SectionObj.FvName.upper() not in FvList:
3576                     FvList.append(SectionObj.FvName.upper())
3577                 if SectionObj.Fv != None and SectionObj.Fv.UiFvName != None and SectionObj.Fv.UiFvName.upper() not in FvList:
3578                     FvList.append(SectionObj.Fv.UiFvName.upper())
3579                     self.__GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList)
3580
3581             if isinstance(SectionObj, CompressSection.CompressSection) or isinstance(SectionObj, GuidSection.GuidSection):
3582                 SectionStack.extend(SectionObj.SectionList)
3583
3584     ## CycleReferenceCheck() method
3585     #
3586     #   Check whether cycle reference exists in FDF
3587     #
3588     #   @param  self        The object pointer
3589     #   @retval True        cycle reference exists
3590     #   @retval False       Not exists cycle reference
3591     #
3592     def CycleReferenceCheck(self):
3593
3594         CycleRefExists = False
3595
3596         try:
3597             for FvName in self.Profile.FvDict.keys():
3598                 LogStr = "Cycle Reference Checking for FV: %s\n" % FvName
3599                 RefFvStack = []
3600                 RefFvStack.append(FvName)
3601                 FdAnalyzedList = []
3602
3603                 while RefFvStack != []:
3604                     FvNameFromStack = RefFvStack.pop()
3605                     if FvNameFromStack.upper() in self.Profile.FvDict.keys():
3606                         FvObj = self.Profile.FvDict[FvNameFromStack.upper()]
3607                     else:
3608                         continue
3609
3610                     RefFdList = []
3611                     RefFvList = []
3612                     self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)
3613
3614                     for RefFdName in RefFdList:
3615                         if RefFdName in FdAnalyzedList:
3616                             continue
3617
3618                         LogStr += "FD %s is referenced by FV %s\n" % (RefFdName, FvNameFromStack)
3619                         FvInFdList = self.__GetFvInFd(RefFdName)
3620                         if FvInFdList != []:
3621                             LogStr += "FD %s contains FV: " % RefFdName
3622                             for FvObj in FvInFdList:
3623                                 LogStr += FvObj
3624                                 LogStr += ' \n'
3625                                 if FvObj not in RefFvStack:
3626                                     RefFvStack.append(FvObj)
3627
3628                                 if FvName in RefFvStack:
3629                                     CycleRefExists = True
3630                                     raise Warning(LogStr)
3631                         FdAnalyzedList.append(RefFdName)
3632
3633                     for RefFvName in RefFvList:
3634                         LogStr += "FV %s is referenced by FV %s\n" % (RefFvName, FvNameFromStack)
3635                         if RefFvName not in RefFvStack:
3636                             RefFvStack.append(RefFvName)
3637
3638                         if FvName in RefFvStack:
3639                             CycleRefExists = True
3640                             raise Warning(LogStr)
3641
3642         except Warning:
3643             print LogStr
3644
3645         finally:
3646             return CycleRefExists
3647
3648 if __name__ == "__main__":
3649     parser = FdfParser("..\LakeportX64Pkg.fdf")
3650     try:
3651         parser.ParseFile()
3652         parser.CycleReferenceCheck()
3653     except Warning, X:
3654         print X.message
3655     else:
3656         print "Success!"
3657