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