import re

import Fd

import Region

import Fv

import AprioriSection

import FfsInfStatement

import FfsFileStatement

import VerSection

import UiSection

import FvImageSection

import DataSection

import DepexSection

import CompressSection

import GuidSection

import Capsule

import CapsuleData

import Rule

import RuleComplexFile

import RuleSimpleFile

import EfiSection

import Vtf

import ComponentStatement

import OptionRom

import OptRomInfStatement

import OptRomFileStatement

from GenFdsGlobalVariable import GenFdsGlobalVariable

from Common.BuildToolError import *

from Common import EdkLogger

from Common.Misc import PathClass

from Common.String import NormPath

import Common.GlobalData as GlobalData

from Common.Expression import *

from Common import GlobalData

from Common.String import ReplaceMacro

from Common.Misc import tdict

import re

import os

(T_CHAR_SPACE, T_CHAR_NULL, T_CHAR_CR, T_CHAR_TAB, T_CHAR_LF, T_CHAR_SLASH, \

T_CHAR_BACKSLASH, T_CHAR_DOUBLE_QUOTE, T_CHAR_SINGLE_QUOTE, T_CHAR_STAR, T_CHAR_HASH) = \

(' ', '\0', '\r', '\t', '\n', '/', '\\', '\"', '\'', '*', '#')

SEPERATOR_TUPLE = ('=', '|', ',', '{', '}')

RegionSizePattern = re.compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*")

RegionSizeGuidPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*\|\s*(?P<size>\w+\.\w+)\s*")

ShortcutPcdPattern = re.compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\w+\.\w+)\s*")

IncludeFileList = []

def GetRealFileLine (File, Line):

InsertedLines = 0

for Profile in IncludeFileList:

if Line >= Profile.InsertStartLineNumber and Line < Profile.InsertStartLineNumber + Profile.InsertAdjust + len(Profile.FileLinesList):

return (Profile.FileName, Line - Profile.InsertStartLineNumber + 1)

if Line >= Profile.InsertStartLineNumber + Profile.InsertAdjust + len(Profile.FileLinesList):

InsertedLines += Profile.InsertAdjust + len(Profile.FileLinesList)

return (File, Line - InsertedLines)

class Warning (Exception):

## The constructor

#

# @param self The object pointer

# @param Str The message to record

# @param File The FDF name

# @param Line The Line number that error occurs

#

def __init__(self, Str, File = None, Line = None):

FileLineTuple = GetRealFileLine(File, Line)

self.FileName = FileLineTuple[0]

self.LineNumber = FileLineTuple[1]

self.Message = Str

self.ToolName = 'FdfParser'

def __str__(self):

return self.Message

class MacroProfile :

## The constructor

#

# @param self The object pointer

# @param FileName The file that to be parsed

#

def __init__(self, FileName, Line):

self.FileName = FileName

self.DefinedAtLine = Line

self.MacroName = None

self.MacroValue = None

class IncludeFileProfile :

## The constructor

#

# @param self The object pointer

# @param FileName The file that to be parsed

#

def __init__(self, FileName):

self.FileName = FileName

self.FileLinesList = []

try:

fsock = open(FileName, "rb", 0)

try:

self.FileLinesList = fsock.readlines()

finally:

fsock.close()

except:

EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)

self.InsertStartLineNumber = None

self.InsertAdjust = 0

class FileProfile :

## The constructor

#

# @param self The object pointer

# @param FileName The file that to be parsed

#

def __init__(self, FileName):

self.FileLinesList = []

try:

fsock = open(FileName, "rb", 0)

try:

self.FileLinesList = fsock.readlines()

finally:

fsock.close()

except:

EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)

self.PcdDict = {}

self.InfList = []

# ECC will use this Dict and List information

self.PcdFileLineDict = {}

self.InfFileLineList = []

self.FdDict = {}

self.FdNameNotSet = False

self.FvDict = {}

self.CapsuleDict = {}

self.VtfList = []

self.RuleDict = {}

self.OptRomDict = {}

class FdfParser:

## The constructor

#

# @param self The object pointer

# @param FileName The file that to be parsed

#

def __init__(self, FileName):

self.Profile = FileProfile(FileName)

self.FileName = FileName

self.CurrentLineNumber = 1

self.CurrentOffsetWithinLine = 0

self.CurrentFdName = None

self.CurrentFvName = None

self.__Token = ""

self.__SkippedChars = ""

# Used to section info

self.__CurSection = []

# Key: [section name, UI name, arch]

# Value: {MACRO_NAME : MACRO_VALUE}

self.__MacroDict = tdict(True, 3)

self.__PcdDict = {}

self.__WipeOffArea = []

if GenFdsGlobalVariable.WorkSpaceDir == '':

GenFdsGlobalVariable.WorkSpaceDir = os.getenv("WORKSPACE")

## __IsWhiteSpace() method

#

# Whether char at current FileBufferPos is whitespace

#

# @param self The object pointer

# @param Char The char to test

# @retval True The char is a kind of white space

# @retval False The char is NOT a kind of white space

#

def __IsWhiteSpace(self, Char):

if Char in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_SPACE, T_CHAR_TAB, T_CHAR_LF):

return True

else:

return False

## __SkipWhiteSpace() method

#

# Skip white spaces from current char, return number of chars skipped

#

# @param self The object pointer

# @retval Count The number of chars skipped

#

def __SkipWhiteSpace(self):

Count = 0

while not self.__EndOfFile():

Count += 1

if self.__CurrentChar() in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_LF, T_CHAR_SPACE, T_CHAR_TAB):

self.__SkippedChars += str(self.__CurrentChar())

self.__GetOneChar()

else:

Count = Count - 1

return Count

## __EndOfFile() method

#

# Judge current buffer pos is at file end

#

# @param self The object pointer

# @retval True Current File buffer position is at file end

# @retval False Current File buffer position is NOT at file end

#

def __EndOfFile(self):

NumberOfLines = len(self.Profile.FileLinesList)

SizeOfLastLine = len(self.Profile.FileLinesList[-1])

if self.CurrentLineNumber == NumberOfLines and self.CurrentOffsetWithinLine >= SizeOfLastLine - 1:

return True

elif self.CurrentLineNumber > NumberOfLines:

return True

else:

return False

## __EndOfLine() method

#

# Judge current buffer pos is at line end

#

# @param self The object pointer

# @retval True Current File buffer position is at line end

# @retval False Current File buffer position is NOT at line end

#

def __EndOfLine(self):

if self.CurrentLineNumber > len(self.Profile.FileLinesList):

return True

SizeOfCurrentLine = len(self.Profile.FileLinesList[self.CurrentLineNumber - 1])

if self.CurrentOffsetWithinLine >= SizeOfCurrentLine:

return True

else:

return False

## Rewind() method

#

# Reset file data buffer to the initial state

#

# @param self The object pointer

#

def Rewind(self):

self.CurrentLineNumber = 1

self.CurrentOffsetWithinLine = 0

## __UndoOneChar() method

#

# Go back one char in the file buffer

#

# @param self The object pointer

# @retval True Successfully go back one char

# @retval False Not able to go back one char as file beginning reached

#

def __UndoOneChar(self):

if self.CurrentLineNumber == 1 and self.CurrentOffsetWithinLine == 0:

return False

elif self.CurrentOffsetWithinLine == 0:

self.CurrentLineNumber -= 1

self.CurrentOffsetWithinLine = len(self.__CurrentLine()) - 1

else:

self.CurrentOffsetWithinLine -= 1

return True

## __GetOneChar() method

#

# Move forward one char in the file buffer

#

# @param self The object pointer

#

def __GetOneChar(self):

if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1:

self.CurrentLineNumber += 1

self.CurrentOffsetWithinLine = 0

else:

self.CurrentOffsetWithinLine += 1

## __CurrentChar() method

#

# Get the char pointed to by the file buffer pointer

#

# @param self The object pointer

# @retval Char Current char

#

def __CurrentChar(self):

return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine]

## __NextChar() method

#

# Get the one char pass the char pointed to by the file buffer pointer

#

# @param self The object pointer

# @retval Char Next char

#

def __NextChar(self):

if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1:

return self.Profile.FileLinesList[self.CurrentLineNumber][0]

else:

return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1]

## __SetCurrentCharValue() method

#

# Modify the value of current char

#

# @param self The object pointer

# @param Value The new value of current char

#

def __SetCurrentCharValue(self, Value):

self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value

## __CurrentLine() method

#

# Get the list that contains current line contents

#

# @param self The object pointer

# @retval List current line contents

#

def __CurrentLine(self):

return self.Profile.FileLinesList[self.CurrentLineNumber - 1]

def __StringToList(self):

self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesList]

self.Profile.FileLinesList[-1].append(' ')

def __ReplaceFragment(self, StartPos, EndPos, Value = ' '):

if StartPos[0] == EndPos[0]:

Offset = StartPos[1]

while Offset <= EndPos[1]:

self.Profile.FileLinesList[StartPos[0]][Offset] = Value

Offset += 1

return

Offset = StartPos[1]

while self.Profile.FileLinesList[StartPos[0]][Offset] not in ('\r', '\n'):

self.Profile.FileLinesList[StartPos[0]][Offset] = Value

Offset += 1

Line = StartPos[0]

while Line < EndPos[0]:

Offset = 0

while self.Profile.FileLinesList[Line][Offset] not in ('\r', '\n'):

self.Profile.FileLinesList[Line][Offset] = Value

Offset += 1

Line += 1

Offset = 0

while Offset <= EndPos[1]:

self.Profile.FileLinesList[EndPos[0]][Offset] = Value

Offset += 1

def __GetMacroName(self):

if not self.__GetNextToken():

raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber)

MacroName = self.__Token

NotFlag = False

if MacroName.startswith('!'):

NotFlag = True

MacroName = MacroName[1:].strip()

if not MacroName.startswith('$(') or not MacroName.endswith(')'):

raise Warning("Macro name expected(Please use '$(%(Token)s)' if '%(Token)s' is a macro.)" % {"Token" : MacroName},

self.FileName, self.CurrentLineNumber)

MacroName = MacroName[2:-1]

return MacroName, NotFlag

def __SetMacroValue(self, Macro, Value):

if not self.__CurSection:

return

MacroDict = {}

if not self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]]:

self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]] = MacroDict

else:

MacroDict = self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]]

MacroDict[Macro] = Value

def __GetMacroValue(self, Macro):

# Highest priority

if Macro in GlobalData.gCommandLineDefines:

return GlobalData.gCommandLineDefines[Macro]

if Macro in GlobalData.gGlobalDefines:

return GlobalData.gGlobalDefines[Macro]

if self.__CurSection:

MacroDict = self.__MacroDict[

self.__CurSection[0],

self.__CurSection[1],

self.__CurSection[2]

]

if MacroDict and Macro in MacroDict:

return MacroDict[Macro]

# Lowest priority

if Macro in GlobalData.gPlatformDefines:

return GlobalData.gPlatformDefines[Macro]

return None

def __SectionHeaderParser(self, Section):

# [Defines]

# [FD.UiName]: use dummy instead if UI name is optional

# [FV.UiName]

# [Capsule.UiName]

# [Rule]: don't take rule section into account, macro is not allowed in this section

# [VTF.arch.UiName, arch]

# [OptionRom.DriverName]

self.__CurSection = []

Section = Section.strip()[1:-1].upper().replace(' ', '').strip('.')

ItemList = Section.split('.')

Item = ItemList[0]

if Item == '' or Item == 'RULE':

return

if Item == 'DEFINES':

self.__CurSection = ['COMMON', 'COMMON', 'COMMON']

elif Item == 'VTF' and len(ItemList) == 3:

UiName = ItemList[2]

Pos = UiName.find(',')

if Pos != -1:

UiName = UiName[:Pos]

self.__CurSection = ['VTF', UiName, ItemList[1]]

elif len(ItemList) > 1:

self.__CurSection = [ItemList[0], ItemList[1], 'COMMON']

elif len(ItemList) > 0:

self.__CurSection = [ItemList[0], 'DUMMY', 'COMMON']

## PreprocessFile() method

#

# Preprocess file contents, replace comments with spaces.

# In the end, rewind the file buffer pointer to the beginning

# BUGBUG: No !include statement processing contained in this procedure

# !include statement should be expanded at the same FileLinesList[CurrentLineNumber - 1]

#

# @param self The object pointer

#

def PreprocessFile(self):

self.Rewind()

InComment = False

DoubleSlashComment = False

HashComment = False

# HashComment in quoted string " " is ignored.

InString = False

while not self.__EndOfFile():

if self.__CurrentChar() == T_CHAR_DOUBLE_QUOTE and not InComment:

InString = not InString

# meet new line, then no longer in a comment for // and '#'

if self.__CurrentChar() == T_CHAR_LF:

self.CurrentLineNumber += 1

self.CurrentOffsetWithinLine = 0

if InComment and DoubleSlashComment:

InComment = False

DoubleSlashComment = False

if InComment and HashComment:

InComment = False

HashComment = False

# check for */ comment end

elif InComment and not DoubleSlashComment and not HashComment and self.__CurrentChar() == T_CHAR_STAR and self.__NextChar() == T_CHAR_SLASH:

self.__SetCurrentCharValue(T_CHAR_SPACE)

self.__GetOneChar()

self.__SetCurrentCharValue(T_CHAR_SPACE)

self.__GetOneChar()

InComment = False

# set comments to spaces

elif InComment:

self.__SetCurrentCharValue(T_CHAR_SPACE)

self.__GetOneChar()

# check for // comment

elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH and not self.__EndOfLine():

InComment = True

DoubleSlashComment = True

# check for '#' comment

elif self.__CurrentChar() == T_CHAR_HASH and not self.__EndOfLine() and not InString:

InComment = True

HashComment = True

# check for /* comment start

elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_STAR:

self.__SetCurrentCharValue( T_CHAR_SPACE)

self.__GetOneChar()

self.__SetCurrentCharValue( T_CHAR_SPACE)

self.__GetOneChar()

InComment = True

else:

self.__GetOneChar()

# restore from ListOfList to ListOfString

self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]

self.Rewind()

## PreprocessIncludeFile() method

#

# Preprocess file contents, replace !include statements with file contents.

# In the end, rewind the file buffer pointer to the beginning

#

# @param self The object pointer

#

def PreprocessIncludeFile(self):

while self.__GetNextToken():

if self.__Token == '!include':

IncludeLine = self.CurrentLineNumber

IncludeOffset = self.CurrentOffsetWithinLine - len('!include')

if not self.__GetNextToken():

raise Warning("expected include file name", self.FileName, self.CurrentLineNumber)

IncFileName = self.__Token

__IncludeMacros = {}

for Macro in ['WORKSPACE', 'ECP_SOURCE', 'EFI_SOURCE', 'EDK_SOURCE']:

MacroVal = self.__GetMacroValue(Macro)

if MacroVal:

__IncludeMacros[Macro] = MacroVal

try:

IncludedFile = NormPath(ReplaceMacro(IncFileName, __IncludeMacros, RaiseError=True))

except:

raise Warning("only these system environment variables are permitted to start the path of the included file: "

"$(WORKSPACE), $(ECP_SOURCE), $(EFI_SOURCE), $(EDK_SOURCE)",

self.FileName, self.CurrentLineNumber)

#

# First search the include file under the same directory as FDF file

#

IncludedFile1 = PathClass(IncludedFile, os.path.dirname(self.FileName))

ErrorCode = IncludedFile1.Validate()[0]

if ErrorCode != 0:

#

# Then search the include file under the same directory as DSC file

#

PlatformDir = ''

if GenFdsGlobalVariable.ActivePlatform:

PlatformDir = GenFdsGlobalVariable.ActivePlatform.Dir

elif GlobalData.gActivePlatform:

PlatformDir = GlobalData.gActivePlatform.MetaFile.Dir

IncludedFile1 = PathClass(IncludedFile, PlatformDir)

ErrorCode = IncludedFile1.Validate()[0]

if ErrorCode != 0:

#

# Also search file under the WORKSPACE directory

#

IncludedFile1 = PathClass(IncludedFile, GlobalData.gWorkspace)

ErrorCode = IncludedFile1.Validate()[0]

if ErrorCode != 0:

raise Warning("The include file does not exist under below directories: \n%s\n%s\n%s\n"%(os.path.dirname(self.FileName), PlatformDir, GlobalData.gWorkspace),

self.FileName, self.CurrentLineNumber)

IncFileProfile = IncludeFileProfile(IncludedFile1.Path)

CurrentLine = self.CurrentLineNumber

CurrentOffset = self.CurrentOffsetWithinLine

# list index of the insertion, note that line number is 'CurrentLine + 1'

InsertAtLine = CurrentLine

IncFileProfile.InsertStartLineNumber = InsertAtLine + 1

# deal with remaining portions after "!include filename", if exists.

if self.__GetNextToken():

if self.CurrentLineNumber == CurrentLine:

RemainingLine = self.__CurrentLine()[CurrentOffset:]

self.Profile.FileLinesList.insert(self.CurrentLineNumber, RemainingLine)

IncFileProfile.InsertAdjust += 1

self.CurrentLineNumber += 1

self.CurrentOffsetWithinLine = 0

for Line in IncFileProfile.FileLinesList:

self.Profile.FileLinesList.insert(InsertAtLine, Line)

self.CurrentLineNumber += 1

InsertAtLine += 1

IncludeFileList.append(IncFileProfile)

# comment out the processed include file statement

TempList = list(self.Profile.FileLinesList[IncludeLine - 1])

TempList.insert(IncludeOffset, '#')

self.Profile.FileLinesList[IncludeLine - 1] = ''.join(TempList)

self.Rewind()

def __GetIfListCurrentItemStat(self, IfList):

if len(IfList) == 0:

return True

for Item in IfList:

if Item[1] == False:

return False

return True

## PreprocessConditionalStatement() method

#

# Preprocess conditional statement.

# In the end, rewind the file buffer pointer to the beginning

#

# @param self The object pointer

#

def PreprocessConditionalStatement(self):

# IfList is a stack of if branches with elements of list [Pos, CondSatisfied, BranchDetermined]

IfList = []

RegionLayoutLine = 0

ReplacedLine = -1

while self.__GetNextToken():

# Determine section name and the location dependent macro

if self.__GetIfListCurrentItemStat(IfList):

if self.__Token.startswith('['):

Header = self.__Token

if not self.__Token.endswith(']'):

self.__SkipToToken(']')

Header += self.__SkippedChars

if Header.find('$(') != -1:

raise Warning("macro cannot be used in section header", self.FileName, self.CurrentLineNumber)

self.__SectionHeaderParser(Header)

continue

# Replace macros except in RULE section or out of section

elif self.__CurSection and ReplacedLine != self.CurrentLineNumber:

ReplacedLine = self.CurrentLineNumber

self.__UndoToken()

CurLine = self.Profile.FileLinesList[ReplacedLine - 1]

PreIndex = 0

StartPos = CurLine.find('$(', PreIndex)

EndPos = CurLine.find(')', StartPos+2)

while StartPos != -1 and EndPos != -1 and self.__Token not in ['!ifdef', '!ifndef', '!if', '!elseif']:

MacroName = CurLine[StartPos+2 : EndPos]

MacorValue = self.__GetMacroValue(MacroName)

if MacorValue != None:

CurLine = CurLine.replace('$(' + MacroName + ')', MacorValue, 1)

if MacorValue.find('$(') != -1:

PreIndex = StartPos

else:

PreIndex = StartPos + len(MacorValue)

else:

PreIndex = EndPos + 1

StartPos = CurLine.find('$(', PreIndex)

EndPos = CurLine.find(')', StartPos+2)

self.Profile.FileLinesList[ReplacedLine - 1] = CurLine

continue

if self.__Token == 'DEFINE':

if self.__GetIfListCurrentItemStat(IfList):

if not self.__CurSection:

raise Warning("macro cannot be defined in Rule section or out of section", self.FileName, self.CurrentLineNumber)

DefineLine = self.CurrentLineNumber - 1

DefineOffset = self.CurrentOffsetWithinLine - len('DEFINE')

if not self.__GetNextToken():

raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber)

Macro = self.__Token

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

Value = self.__GetExpression()

self.__SetMacroValue(Macro, Value)

self.__WipeOffArea.append(((DefineLine, DefineOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))

elif self.__Token == 'SET':

SetLine = self.CurrentLineNumber - 1

SetOffset = self.CurrentOffsetWithinLine - len('SET')

PcdPair = self.__GetNextPcdName()

PcdName = "%s.%s" % (PcdPair[1], PcdPair[0])

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

Value = self.__GetExpression()

Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)

self.__PcdDict[PcdName] = Value

self.Profile.PcdDict[PcdPair] = Value

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple

self.__WipeOffArea.append(((SetLine, SetOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))

elif self.__Token in ('!ifdef', '!ifndef', '!if'):

IfStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token))

IfList.append([IfStartPos, None, None])

CondLabel = self.__Token

Expression = self.__GetExpression()

if CondLabel == '!if':

ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval')

else:

ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'in')

if CondLabel == '!ifndef':

ConditionSatisfied = not ConditionSatisfied

BranchDetermined = ConditionSatisfied

IfList[-1] = [IfList[-1][0], ConditionSatisfied, BranchDetermined]

if ConditionSatisfied:

self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))

elif self.__Token in ('!elseif', '!else'):

ElseStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token))

if len(IfList) <= 0:

raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber)

if IfList[-1][1]:

IfList[-1] = [ElseStartPos, False, True]

self.__WipeOffArea.append((ElseStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))

else:

self.__WipeOffArea.append((IfList[-1][0], ElseStartPos))

IfList[-1] = [ElseStartPos, True, IfList[-1][2]]

if self.__Token == '!elseif':

Expression = self.__GetExpression()

ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval')

IfList[-1] = [IfList[-1][0], ConditionSatisfied, IfList[-1][2]]

if IfList[-1][1]:

if IfList[-1][2]:

IfList[-1][1] = False

else:

IfList[-1][2] = True

self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))

elif self.__Token == '!endif':

if len(IfList) <= 0:

raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber)

if IfList[-1][1]:

self.__WipeOffArea.append(((self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len('!endif')), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))

else:

self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))

IfList.pop()

elif not IfList: # Don't use PCDs inside conditional directive

if self.CurrentLineNumber <= RegionLayoutLine:

# Don't try the same line twice

continue

SetPcd = ShortcutPcdPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])

if SetPcd:

self.__PcdDict[SetPcd.group('name')] = SetPcd.group('value')

RegionLayoutLine = self.CurrentLineNumber

continue

RegionSize = RegionSizePattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])

if not RegionSize:

RegionLayoutLine = self.CurrentLineNumber

continue

RegionSizeGuid = RegionSizeGuidPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber])

if not RegionSizeGuid:

RegionLayoutLine = self.CurrentLineNumber + 1

continue

self.__PcdDict[RegionSizeGuid.group('base')] = RegionSize.group('base')

self.__PcdDict[RegionSizeGuid.group('size')] = RegionSize.group('size')

RegionLayoutLine = self.CurrentLineNumber + 1

if IfList:

raise Warning("Missing !endif", self.FileName, self.CurrentLineNumber)

self.Rewind()

def __CollectMacroPcd(self):

MacroDict = {}

# PCD macro

MacroDict.update(GlobalData.gPlatformPcds)

MacroDict.update(self.__PcdDict)

# Lowest priority

MacroDict.update(GlobalData.gPlatformDefines)

if self.__CurSection:

# Defines macro

ScopeMacro = self.__MacroDict['COMMON', 'COMMON', 'COMMON']

if ScopeMacro:

MacroDict.update(ScopeMacro)

# Section macro

ScopeMacro = self.__MacroDict[

self.__CurSection[0],

self.__CurSection[1],

self.__CurSection[2]

]

if ScopeMacro:

MacroDict.update(ScopeMacro)

MacroDict.update(GlobalData.gGlobalDefines)

MacroDict.update(GlobalData.gCommandLineDefines)

# Highest priority

return MacroDict

def __EvaluateConditional(self, Expression, Line, Op = None, Value = None):

FileLineTuple = GetRealFileLine(self.FileName, Line)

MacroPcdDict = self.__CollectMacroPcd()

if Op == 'eval':

try:

if Value:

return ValueExpression(Expression, MacroPcdDict)(True)

else:

return ValueExpression(Expression, MacroPcdDict)()

except WrnExpression, Excpt:

#

# Catch expression evaluation warning here. We need to report

# the precise number of line and return the evaluation result

#

EdkLogger.warn('Parser', "Suspicious expression: %s" % str(Excpt),

File=self.FileName, ExtraData=self.__CurrentLine(),

Line=Line)

return Excpt.result

except Exception, Excpt:

if hasattr(Excpt, 'Pcd'):

if Excpt.Pcd in GlobalData.gPlatformOtherPcds:

Info = GlobalData.gPlatformOtherPcds[Excpt.Pcd]

raise Warning("Cannot use this PCD (%s) in an expression as"

" it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"

" of the DSC file (%s), and it is currently defined in this section:"

" %s, line #: %d." % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE'], Info[0], Info[1]),

*FileLineTuple)

else:

raise Warning("PCD (%s) is not defined in DSC file (%s)" % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE']),

*FileLineTuple)

else:

raise Warning(str(Excpt), *FileLineTuple)

else:

if Expression.startswith('$(') and Expression[-1] == ')':

Expression = Expression[2:-1]

return Expression in MacroPcdDict

## __IsToken() method

#

# Check whether input string is found from current char position along

# If found, the string value is put into self.__Token

#

# @param self The object pointer

# @param String The string to search

# @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive

# @retval True Successfully find string, file buffer pointer moved forward

# @retval False Not able to find string, file buffer pointer not changed

#

def __IsToken(self, String, IgnoreCase = False):

self.__SkipWhiteSpace()

# Only consider the same line, no multi-line token allowed

StartPos = self.CurrentOffsetWithinLine

index = -1

if IgnoreCase:

index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper())

else:

index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String)

if index == 0:

self.CurrentOffsetWithinLine += len(String)

self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]

return True

return False

## __IsKeyword() method

#

# Check whether input keyword is found from current char position along, whole word only!

# If found, the string value is put into self.__Token

#

# @param self The object pointer

# @param Keyword The string to search

# @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive

# @retval True Successfully find string, file buffer pointer moved forward

# @retval False Not able to find string, file buffer pointer not changed

#

def __IsKeyword(self, KeyWord, IgnoreCase = False):

self.__SkipWhiteSpace()

# Only consider the same line, no multi-line token allowed

StartPos = self.CurrentOffsetWithinLine

index = -1

if IgnoreCase:

index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(KeyWord.upper())

else:

index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(KeyWord)

if index == 0:

followingChar = self.__CurrentLine()[self.CurrentOffsetWithinLine + len(KeyWord)]

if not str(followingChar).isspace() and followingChar not in SEPERATOR_TUPLE:

return False

self.CurrentOffsetWithinLine += len(KeyWord)

self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]

return True

return False

def __GetExpression(self):

Line = self.Profile.FileLinesList[self.CurrentLineNumber - 1]

Index = len(Line) - 1

while Line[Index] in ['\r', '\n']:

Index -= 1

ExpressionString = self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:Index+1]

self.CurrentOffsetWithinLine += len(ExpressionString)

ExpressionString = ExpressionString.strip()

return ExpressionString

## __GetNextWord() method

#

# Get next C name from file lines

# If found, the string value is put into self.__Token

#

# @param self The object pointer

# @retval True Successfully find a C name string, file buffer pointer moved forward

# @retval False Not able to find a C name string, file buffer pointer not changed

#

def __GetNextWord(self):

self.__SkipWhiteSpace()

if self.__EndOfFile():

return False

TempChar = self.__CurrentChar()

StartPos = self.CurrentOffsetWithinLine

if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_':

self.__GetOneChar()

while not self.__EndOfLine():

TempChar = self.__CurrentChar()

if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \

or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-':

self.__GetOneChar()

else:

break

self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]

return True

return False

## __GetNextToken() method

#

# Get next token unit before a seperator

# If found, the string value is put into self.__Token

#

# @param self The object pointer

# @retval True Successfully find a token unit, file buffer pointer moved forward

# @retval False Not able to find a token unit, file buffer pointer not changed

#

def __GetNextToken(self):

# Skip leading spaces, if exist.

self.__SkipWhiteSpace()

if self.__EndOfFile():

return False

# Record the token start position, the position of the first non-space char.

StartPos = self.CurrentOffsetWithinLine

StartLine = self.CurrentLineNumber

while StartLine == self.CurrentLineNumber:

TempChar = self.__CurrentChar()

# Try to find the end char that is not a space and not in seperator tuple.

# That is, when we got a space or any char in the tuple, we got the end of token.

if not str(TempChar).isspace() and TempChar not in SEPERATOR_TUPLE:

self.__GetOneChar()

# if we happen to meet a seperator as the first char, we must proceed to get it.

# That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.

elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE:

self.__GetOneChar()

break

else:

break

EndPos = self.CurrentOffsetWithinLine

if self.CurrentLineNumber != StartLine:

EndPos = len(self.Profile.FileLinesList[StartLine-1])

self.__Token = self.Profile.FileLinesList[StartLine-1][StartPos : EndPos]

if StartPos != self.CurrentOffsetWithinLine:

return True

else:

return False

def __GetNextOp(self):

# Skip leading spaces, if exist.

self.__SkipWhiteSpace()

if self.__EndOfFile():

return False

# Record the token start position, the position of the first non-space char.

StartPos = self.CurrentOffsetWithinLine

while not self.__EndOfLine():

TempChar = self.__CurrentChar()

# Try to find the end char that is not a space

if not str(TempChar).isspace():

self.__GetOneChar()

else:

break

else:

return False

if StartPos != self.CurrentOffsetWithinLine:

self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]

return True

else:

return False

## __GetNextGuid() method

#

# Get next token unit before a seperator

# If found, the GUID string is put into self.__Token

#

# @param self The object pointer

# @retval True Successfully find a registry format GUID, file buffer pointer moved forward

# @retval False Not able to find a registry format GUID, file buffer pointer not changed

#

def __GetNextGuid(self):

if not self.__GetNextToken():

return False

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}')

if p.match(self.__Token) != None:

return True

else:

self.__UndoToken()

return False

## __UndoToken() method

#

# Go back one token unit in file buffer

#

# @param self The object pointer

#

def __UndoToken(self):

self.__UndoOneChar()

while self.__CurrentChar().isspace():

if not self.__UndoOneChar():

self.__GetOneChar()

return

StartPos = self.CurrentOffsetWithinLine

CurrentLine = self.CurrentLineNumber

while CurrentLine == self.CurrentLineNumber:

TempChar = self.__CurrentChar()

# Try to find the end char that is not a space and not in seperator tuple.

# That is, when we got a space or any char in the tuple, we got the end of token.

if not str(TempChar).isspace() and not TempChar in SEPERATOR_TUPLE:

if not self.__UndoOneChar():

return

# if we happen to meet a seperator as the first char, we must proceed to get it.

# That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.

elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE:

return

else:

break

self.__GetOneChar()

## __HexDigit() method

#

# Whether char input is a Hex data bit

#

# @param self The object pointer

# @param TempChar The char to test

# @retval True The char is a Hex data bit

# @retval False The char is NOT a Hex data bit

#

def __HexDigit(self, TempChar):

if (TempChar >= 'a' and TempChar <= 'f') or (TempChar >= 'A' and TempChar <= 'F') \

or (TempChar >= '0' and TempChar <= '9'):

return True

else:

return False

def __IsHex(self, HexStr):

if not HexStr.upper().startswith("0X"):

return False

if len(self.__Token) <= 2:

return False

charList = [c for c in HexStr[2 : ] if not self.__HexDigit( c)]

if len(charList) == 0:

return True

else:

return False

## __GetNextHexNumber() method

#

# Get next HEX data before a seperator

# If found, the HEX data is put into self.__Token

#

# @param self The object pointer

# @retval True Successfully find a HEX data, file buffer pointer moved forward

# @retval False Not able to find a HEX data, file buffer pointer not changed

#

def __GetNextHexNumber(self):

if not self.__GetNextToken():

return False

if self.__IsHex(self.__Token):

return True

else:

self.__UndoToken()

return False

## __GetNextDecimalNumber() method

#

# Get next decimal data before a seperator

# If found, the decimal data is put into self.__Token

#

# @param self The object pointer

# @retval True Successfully find a decimal data, file buffer pointer moved forward

# @retval False Not able to find a decimal data, file buffer pointer not changed

#

def __GetNextDecimalNumber(self):

if not self.__GetNextToken():

return False

if self.__Token.isdigit():

return True

else:

self.__UndoToken()

return False

## __GetNextPcdName() method

#

# Get next PCD token space C name and PCD C name pair before a seperator

# If found, the decimal data is put into self.__Token

#

# @param self The object pointer

# @retval Tuple PCD C name and PCD token space C name pair

#

def __GetNextPcdName(self):

if not self.__GetNextWord():

raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)

pcdTokenSpaceCName = self.__Token

if not self.__IsToken( "."):

raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)

if not self.__GetNextWord():

raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)

pcdCName = self.__Token

return (pcdCName, pcdTokenSpaceCName)

## __GetStringData() method

#

# Get string contents quoted in ""

# If found, the decimal data is put into self.__Token

#

# @param self The object pointer

# @retval True Successfully find a string data, file buffer pointer moved forward

# @retval False Not able to find a string data, file buffer pointer not changed

#

def __GetStringData(self):

if self.__Token.startswith("\"") or self.__Token.startswith("L\""):

self.__UndoToken()

self.__SkipToToken("\"")

currentLineNumber = self.CurrentLineNumber

if not self.__SkipToToken("\""):

raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber)

if currentLineNumber != self.CurrentLineNumber:

raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber)

self.__Token = self.__SkippedChars.rstrip('\"')

return True

elif self.__Token.startswith("\'") or self.__Token.startswith("L\'"):

self.__UndoToken()

self.__SkipToToken("\'")

currentLineNumber = self.CurrentLineNumber

if not self.__SkipToToken("\'"):

raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber)

if currentLineNumber != self.CurrentLineNumber:

raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber)

self.__Token = self.__SkippedChars.rstrip('\'')

return True

else:

return False

## __SkipToToken() method

#

# Search forward in file buffer for the string

# The skipped chars are put into self.__SkippedChars

#

# @param self The object pointer

# @param String The string to search

# @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive

# @retval True Successfully find the string, file buffer pointer moved forward

# @retval False Not able to find the string, file buffer pointer not changed

#

def __SkipToToken(self, String, IgnoreCase = False):

StartPos = self.GetFileBufferPos()

self.__SkippedChars = ""

while not self.__EndOfFile():

index = -1

if IgnoreCase:

index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper())

else:

index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String)

if index == 0:

self.CurrentOffsetWithinLine += len(String)

self.__SkippedChars += String

return True

self.__SkippedChars += str(self.__CurrentChar())

self.__GetOneChar()

self.SetFileBufferPos( StartPos)

self.__SkippedChars = ""

return False

## GetFileBufferPos() method

#

# Return the tuple of current line and offset within the line

#

# @param self The object pointer

# @retval Tuple Line number and offset pair

#

def GetFileBufferPos(self):

return (self.CurrentLineNumber, self.CurrentOffsetWithinLine)

## SetFileBufferPos() method

#

# Restore the file buffer position

#

# @param self The object pointer

# @param Pos The new file buffer position

#

def SetFileBufferPos(self, Pos):

(self.CurrentLineNumber, self.CurrentOffsetWithinLine) = Pos

## Preprocess() method

#

# Preprocess comment, conditional directive, include directive, replace macro.

# Exception will be raised if syntax error found

#

# @param self The object pointer

#

def Preprocess(self):

self.__StringToList()

self.PreprocessFile()

self.PreprocessIncludeFile()

self.__StringToList()

self.PreprocessFile()

self.PreprocessConditionalStatement()

self.__StringToList()

for Pos in self.__WipeOffArea:

self.__ReplaceFragment(Pos[0], Pos[1])

self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]

while self.__GetDefines():

pass

## ParseFile() method

#

# Parse the file profile buffer to extract fd, fv ... information

# Exception will be raised if syntax error found

#

# @param self The object pointer

#

def ParseFile(self):

try:

self.Preprocess()

while self.__GetFd():

pass

while self.__GetFv():

pass

while self.__GetCapsule():

pass

while self.__GetVtf():

pass

while self.__GetRule():

pass

while self.__GetOptionRom():

pass

except Warning, X:

self.__UndoToken()

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

#'\n\tGot Token: \"%s\" from File %s\n' % (self.__Token, FileLineTuple[0]) + \

X.Message += ' near line %d, column %d: %s' \

% (FileLineTuple[1], self.CurrentOffsetWithinLine + 1, self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :].rstrip('\n').rstrip('\r'))

raise

## __GetDefines() method

#

# Get Defines section contents and store its data into AllMacrosList

#

# @param self The object pointer

# @retval True Successfully find a Defines

# @retval False Not able to find a Defines

#

def __GetDefines(self):

if not self.__GetNextToken():

return False

S = self.__Token.upper()

if S.startswith("[") and not S.startswith("[DEFINES"):

if not S.startswith("[FD.") and not S.startswith("[FV.") and not S.startswith("[CAPSULE.") \

and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):

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)

self.__UndoToken()

return False

self.__UndoToken()

if not self.__IsToken("[DEFINES", True):

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

#print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \

# % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)

raise Warning("expected [DEFINES", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "]"):

raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)

while self.__GetNextWord():

# handle the SET statement

if self.__Token == 'SET':

self.__UndoToken()

self.__GetSetStatement(None)

continue

Macro = self.__Token

if not self.__IsToken("="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken() or self.__Token.startswith('['):

raise Warning("expected MACRO value", self.FileName, self.CurrentLineNumber)

Value = self.__Token

return False

## __GetFd() method

#

# Get FD section contents and store its data into FD dictionary of self.Profile

#

# @param self The object pointer

# @retval True Successfully find a FD

# @retval False Not able to find a FD

#

def __GetFd(self):

if not self.__GetNextToken():

return False

S = self.__Token.upper()

if S.startswith("[") and not S.startswith("[FD."):

if not S.startswith("[FV.") and not S.startswith("[CAPSULE.") \

and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):

raise Warning("Unknown section", self.FileName, self.CurrentLineNumber)

self.__UndoToken()

return False

self.__UndoToken()

if not self.__IsToken("[FD.", True):

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

#print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \

# % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)

raise Warning("expected [FD.]", self.FileName, self.CurrentLineNumber)

FdName = self.__GetUiName()

if FdName == "":

if len (self.Profile.FdDict) == 0:

FdName = GenFdsGlobalVariable.PlatformName

if FdName == "" and GlobalData.gActivePlatform:

FdName = GlobalData.gActivePlatform.PlatformName

self.Profile.FdNameNotSet = True

else:

raise Warning("expected FdName in [FD.] section", self.FileName, self.CurrentLineNumber)

self.CurrentFdName = FdName.upper()

if self.CurrentFdName in self.Profile.FdDict:

raise Warning("Unexpected the same FD name", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "]"):

raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)

FdObj = Fd.FD()

FdObj.FdUiName = self.CurrentFdName

self.Profile.FdDict[self.CurrentFdName] = FdObj

if len (self.Profile.FdDict) > 1 and self.Profile.FdNameNotSet:

raise Warning("expected all FDs have their name", self.FileName, self.CurrentLineNumber)

Status = self.__GetCreateFile(FdObj)

if not Status:

raise Warning("FD name error", self.FileName, self.CurrentLineNumber)

self.__GetTokenStatements(FdObj)

self.__GetDefineStatements(FdObj)

self.__GetSetStatements(FdObj)

if not self.__GetRegionLayout(FdObj):

raise Warning("expected region layout", self.FileName, self.CurrentLineNumber)

while self.__GetRegionLayout(FdObj):

pass

return True

## __GetUiName() method

#

# Return the UI name of a section

#

# @param self The object pointer

# @retval FdName UI name

#

def __GetUiName(self):

Name = ""

if self.__GetNextWord():

Name = self.__Token

return Name

## __GetCreateFile() method

#

# Return the output file name of object

#

# @param self The object pointer

# @param Obj object whose data will be stored in file

# @retval FdName UI name

#

def __GetCreateFile(self, Obj):

if self.__IsKeyword( "CREATE_FILE"):

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected file name", self.FileName, self.CurrentLineNumber)

FileName = self.__Token

Obj.CreateFileName = FileName

return True

## __GetTokenStatements() method

#

# Get token statements

#

# @param self The object pointer

# @param Obj for whom token statement is got

#

def __GetTokenStatements(self, Obj):

if not self.__IsKeyword( "BaseAddress"):

raise Warning("BaseAddress missing", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextHexNumber():

raise Warning("expected Hex base address", self.FileName, self.CurrentLineNumber)

Obj.BaseAddress = self.__Token

if self.__IsToken( "|"):

pcdPair = self.__GetNextPcdName()

Obj.BaseAddressPcd = pcdPair

self.Profile.PcdDict[pcdPair] = Obj.BaseAddress

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple

if not self.__IsKeyword( "Size"):

raise Warning("Size missing", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextHexNumber():

raise Warning("expected Hex size", self.FileName, self.CurrentLineNumber)

Size = self.__Token

if self.__IsToken( "|"):

pcdPair = self.__GetNextPcdName()

Obj.SizePcd = pcdPair

self.Profile.PcdDict[pcdPair] = Size

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple

Obj.Size = long(Size, 0)

if not self.__IsKeyword( "ErasePolarity"):

raise Warning("ErasePolarity missing", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected Erase Polarity", self.FileName, self.CurrentLineNumber)

if self.__Token != "1" and self.__Token != "0":

raise Warning("expected 1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber)

Obj.ErasePolarity = self.__Token

self.__GetBlockStatements(Obj)

## __GetAddressStatements() method

#

# Get address statements

#

# @param self The object pointer

# @param Obj for whom address statement is got

# @retval True Successfully find

# @retval False Not able to find

#

def __GetAddressStatements(self, Obj):

if self.__IsKeyword("BsBaseAddress"):

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():

raise Warning("expected address", self.FileName, self.CurrentLineNumber)

BsAddress = long(self.__Token, 0)

Obj.BsBaseAddress = BsAddress

if self.__IsKeyword("RtBaseAddress"):

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():

raise Warning("expected address", self.FileName, self.CurrentLineNumber)

RtAddress = long(self.__Token, 0)

Obj.RtBaseAddress = RtAddress

## __GetBlockStatements() method

#

# Get block statements

#

# @param self The object pointer

# @param Obj for whom block statement is got

#

def __GetBlockStatements(self, Obj):

if not self.__GetBlockStatement(Obj):

#set default block size is 1

Obj.BlockSizeList.append((1, Obj.Size, None))

return

while self.__GetBlockStatement(Obj):

pass

for Item in Obj.BlockSizeList:

if Item[0] == None or Item[1] == None:

raise Warning("expected block statement", self.FileName, self.CurrentLineNumber)

## __GetBlockStatement() method

#

# Get block statement

#

# @param self The object pointer

# @param Obj for whom block statement is got

# @retval True Successfully find

# @retval False Not able to find

#

def __GetBlockStatement(self, Obj):

if not self.__IsKeyword( "BlockSize"):

return False

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber():

raise Warning("expected Hex or Integer block size", self.FileName, self.CurrentLineNumber)

BlockSize = self.__Token

BlockSizePcd = None

if self.__IsToken( "|"):

PcdPair = self.__GetNextPcdName()

BlockSizePcd = PcdPair

self.Profile.PcdDict[PcdPair] = BlockSize

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple

BlockSize = long(BlockSize, 0)

BlockNumber = None

if self.__IsKeyword( "NumBlocks"):

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():

raise Warning("expected block numbers", self.FileName, self.CurrentLineNumber)

BlockNumber = long(self.__Token, 0)

Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd))

return True

## __GetDefineStatements() method

#

# Get define statements

#

# @param self The object pointer

# @param Obj for whom define statement is got

# @retval True Successfully find

# @retval False Not able to find

#

def __GetDefineStatements(self, Obj):

while self.__GetDefineStatement( Obj):

pass

## __GetDefineStatement() method

#

# Get define statement

#

# @param self The object pointer

# @param Obj for whom define statement is got

# @retval True Successfully find

# @retval False Not able to find

#

def __GetDefineStatement(self, Obj):

if self.__IsKeyword("DEFINE"):

self.__GetNextToken()

Macro = self.__Token

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected value", self.FileName, self.CurrentLineNumber)

Value = self.__Token

Macro = '$(' + Macro + ')'

Obj.DefineVarDict[Macro] = Value

return True

return False

## __GetSetStatements() method

#

# Get set statements

#

# @param self The object pointer

# @param Obj for whom set statement is got

# @retval True Successfully find

# @retval False Not able to find

#

def __GetSetStatements(self, Obj):

while self.__GetSetStatement(Obj):

pass

## __GetSetStatement() method

#

# Get set statement

#

# @param self The object pointer

# @param Obj for whom set statement is got

# @retval True Successfully find

# @retval False Not able to find

#

def __GetSetStatement(self, Obj):

if self.__IsKeyword("SET"):

PcdPair = self.__GetNextPcdName()

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

Value = self.__GetExpression()

Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)

if Obj:

Obj.SetVarDict[PcdPair] = Value

self.Profile.PcdDict[PcdPair] = Value

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple

return True

return False

## __GetRegionLayout() method

#

# Get region layout for FD

#

# @param self The object pointer

# @param Fd for whom region is got

# @retval True Successfully find

# @retval False Not able to find

#

def __GetRegionLayout(self, Fd):

if not self.__GetNextHexNumber():

return False

RegionObj = Region.Region()

RegionObj.Offset = long(self.__Token, 0)

Fd.RegionList.append(RegionObj)

if not self.__IsToken( "|"):

raise Warning("expected '|'", self.FileName, self.CurrentLineNumber)

if not self.__GetNextHexNumber():

raise Warning("expected Region Size", self.FileName, self.CurrentLineNumber)

RegionObj.Size = long(self.__Token, 0)

if not self.__GetNextWord():

return True

if not self.__Token in ("SET", "FV", "FILE", "DATA", "CAPSULE"):

self.__UndoToken()

RegionObj.PcdOffset = self.__GetNextPcdName()

self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(Fd.BaseAddress, 0))

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple

if self.__IsToken( "|"):

RegionObj.PcdSize = self.__GetNextPcdName()

self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple

if not self.__GetNextWord():

return True

if self.__Token == "SET":

self.__UndoToken()

self.__GetSetStatements( RegionObj)

if not self.__GetNextWord():

return True

elif self.__Token == "FV":

self.__UndoToken()

self.__GetRegionFvType( RegionObj)

elif self.__Token == "CAPSULE":

self.__UndoToken()

self.__GetRegionCapType( RegionObj)

elif self.__Token == "FILE":

self.__UndoToken()

self.__GetRegionFileType( RegionObj)

elif self.__Token == "DATA":

self.__UndoToken()

self.__GetRegionDataType( RegionObj)

else:

raise Warning("A valid region type was not found. "

"Valid types are [SET, FV, CAPSULE, FILE, DATA]. This error occurred",

self.FileName, self.CurrentLineNumber)

return True

## __GetRegionFvType() method

#

# Get region fv data for region

#

# @param self The object pointer

# @param RegionObj for whom region data is got

#

def __GetRegionFvType(self, RegionObj):

if not self.__IsKeyword( "FV"):

raise Warning("expected Keyword 'FV'", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected FV name", self.FileName, self.CurrentLineNumber)

RegionObj.RegionType = "FV"

RegionObj.RegionDataList.append(self.__Token)

while self.__IsKeyword( "FV"):

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected FV name", self.FileName, self.CurrentLineNumber)

RegionObj.RegionDataList.append(self.__Token)

## __GetRegionCapType() method

#

# Get region capsule data for region

#

# @param self The object pointer

# @param RegionObj for whom region data is got

#

def __GetRegionCapType(self, RegionObj):

if not self.__IsKeyword("CAPSULE"):

raise Warning("expected Keyword 'CAPSULE'", self.FileName, self.CurrentLineNumber)

if not self.__IsToken("="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber)

RegionObj.RegionType = "CAPSULE"

RegionObj.RegionDataList.append(self.__Token)

while self.__IsKeyword("CAPSULE"):

if not self.__IsToken("="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber)

RegionObj.RegionDataList.append(self.__Token)

## __GetRegionFileType() method

#

# Get region file data for region

#

# @param self The object pointer

# @param RegionObj for whom region data is got

#

def __GetRegionFileType(self, RegionObj):

if not self.__IsKeyword( "FILE"):

raise Warning("expected Keyword 'FILE'", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected File name", self.FileName, self.CurrentLineNumber)

RegionObj.RegionType = "FILE"

RegionObj.RegionDataList.append( self.__Token)

while self.__IsKeyword( "FILE"):

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected FILE name", self.FileName, self.CurrentLineNumber)

RegionObj.RegionDataList.append(self.__Token)

## __GetRegionDataType() method

#

# Get region array data for region

#

# @param self The object pointer

# @param RegionObj for whom region data is got

#

def __GetRegionDataType(self, RegionObj):

if not self.__IsKeyword( "DATA"):

raise Warning("expected Region Data type", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "{"):

raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)

if not self.__GetNextHexNumber():

raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber)

if len(self.__Token) > 18:

raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber)

# convert hex string value to byte hex string array

AllString = self.__Token

AllStrLen = len (AllString)

DataString = ""

while AllStrLen > 4:

DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + ","

AllStrLen = AllStrLen - 2

DataString = DataString + AllString[:AllStrLen] + ","

# byte value array

if len (self.__Token) <= 4:

while self.__IsToken(","):

if not self.__GetNextHexNumber():

raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)

if len(self.__Token) > 4:

raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)

DataString += self.__Token

DataString += ","

if not self.__IsToken( "}"):

raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)

DataString = DataString.rstrip(",")

RegionObj.RegionType = "DATA"

RegionObj.RegionDataList.append( DataString)

while self.__IsKeyword( "DATA"):

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__IsToken( "{"):

raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)

if not self.__GetNextHexNumber():

raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber)

if len(self.__Token) > 18:

raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber)

# convert hex string value to byte hex string array

AllString = self.__Token

AllStrLen = len (AllString)

DataString = ""

while AllStrLen > 4:

DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + ","

AllStrLen = AllStrLen - 2

DataString = DataString + AllString[:AllStrLen] + ","

# byte value array

if len (self.__Token) <= 4:

while self.__IsToken(","):

if not self.__GetNextHexNumber():

raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)

if len(self.__Token) > 4:

raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)

DataString += self.__Token

DataString += ","

if not self.__IsToken( "}"):

raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)

DataString = DataString.rstrip(",")

RegionObj.RegionDataList.append( DataString)

## __GetFv() method

#

# Get FV section contents and store its data into FV dictionary of self.Profile

#

# @param self The object pointer

# @retval True Successfully find a FV

# @retval False Not able to find a FV

#

def __GetFv(self):

if not self.__GetNextToken():

return False

S = self.__Token.upper()

if S.startswith("[") and not S.startswith("[FV."):

if not S.startswith("[CAPSULE.") \

and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):

raise Warning("Unknown section or section appear sequence error (The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)

self.__UndoToken()

return False

self.__UndoToken()

if not self.__IsToken("[FV.", True):

FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

#print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \

# % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)

raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)

FvName = self.__GetUiName()

self.CurrentFvName = FvName.upper()

if not self.__IsToken( "]"):

raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)

FvObj = Fv.FV()

FvObj.UiFvName = self.CurrentFvName

self.Profile.FvDict[self.CurrentFvName] = FvObj

Status = self.__GetCreateFile(FvObj)

if not Status:

raise Warning("FV name error", self.FileName, self.CurrentLineNumber)

self.__GetDefineStatements(FvObj)

self.__GetAddressStatements(FvObj)

while self.__GetBlockStatement(FvObj):

pass

self.__GetSetStatements(FvObj)

self.__GetFvBaseAddress(FvObj)

self.__GetFvForceRebase(FvObj)

self.__GetFvAlignment(FvObj)

self.__GetFvAttributes(FvObj)

self.__GetFvNameGuid(FvObj)

FvObj.FvExtEntryTypeValue = []

FvObj.FvExtEntryType = []

FvObj.FvExtEntryData = []

while True:

isFvExtEntry = self.__GetFvExtEntryStatement(FvObj)

if not isFvExtEntry:

break

self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())

self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())

while True:

isInf = self.__GetInfStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())

isFile = self.__GetFileStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())

if not isInf and not isFile:

break

return True

## __GetFvAlignment() method

#

# Get alignment for FV

#

# @param self The object pointer

# @param Obj for whom alignment is got

# @retval True Successfully find a alignment statement

# @retval False Not able to find a alignment statement

#

def __GetFvAlignment(self, Obj):

if not self.__IsKeyword( "FvAlignment"):

return False

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber)

if self.__Token.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \

"1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \

"1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \

"1G", "2G"):

raise Warning("Unknown alignment value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)

Obj.FvAlignment = self.__Token

return True

## __GetFvBaseAddress() method

#

# Get BaseAddress for FV

#

# @param self The object pointer

# @param Obj for whom FvBaseAddress is got

# @retval True Successfully find a FvBaseAddress statement

# @retval False Not able to find a FvBaseAddress statement

#

def __GetFvBaseAddress(self, Obj):

if not self.__IsKeyword("FvBaseAddress"):

return False

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected FV base address value", self.FileName, self.CurrentLineNumber)

IsValidBaseAddrValue = re.compile('^0[x|X][0-9a-fA-F]+')

if not IsValidBaseAddrValue.match(self.__Token.upper()):

raise Warning("Unknown FV base address value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)

Obj.FvBaseAddress = self.__Token

return True

## __GetFvForceRebase() method

#

# Get FvForceRebase for FV

#

# @param self The object pointer

# @param Obj for whom FvForceRebase is got

# @retval True Successfully find a FvForceRebase statement

# @retval False Not able to find a FvForceRebase statement

#

def __GetFvForceRebase(self, Obj):

if not self.__IsKeyword("FvForceRebase"):

return False

if not self.__IsToken( "="):

raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

if not self.__GetNextToken():

raise Warning("expected FvForceRebase value", self.FileName, self.CurrentLineNumber)

if self.__Token.upper() not in ["TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"]:

raise Warning("Unknown FvForceRebase value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)

if self.__Token.upper() in ["TRUE", "1", "0X1", "0X01"]:

Obj.FvForceRebase = True

elif self.__Token.upper() in ["FALSE", "0", "0X0", "0X00"]:

Obj.FvForceRebase = False

else:

Obj.FvForceRebase = None

return True

## __GetFvAttributes() method

#

# Get attributes for FV

#

# @param self The object pointer

# @param Obj for whom attribute is got

# @retval None

#

def __GetFvAttributes(self, FvObj):

while self.__GetNextWord():

name = self.__Token

if name not in ("ERASE_POLARITY", "MEMORY_MAPPED", \